@Override
 public BuildType fromShownString(final String s) {
   for (BuildType l : BuildType.values()) {
     if (l.getShownName().equals(s)) {
       return l;
     }
   }
   return null;
 }
  private void deserializeRule(DeserializationContext context, Build.Rule rulePb)
      throws PackageDeserializationException, InterruptedException {
    Location ruleLocation = EmptyLocation.INSTANCE;
    RuleClass ruleClass = packageDeserializationEnvironment.getRuleClass(rulePb, ruleLocation);
    Map<String, ParsedAttributeValue> attributeValues = new HashMap<>();
    AttributesToDeserialize attrToDeserialize =
        packageDeserializationEnvironment.attributesToDeserialize();

    Hasher hasher = Hashing.md5().newHasher();
    for (Build.Attribute attrPb : rulePb.getAttributeList()) {
      Type<?> type = ruleClass.getAttributeByName(attrPb.getName()).getType();
      attributeValues.put(attrPb.getName(), deserializeAttribute(type, attrPb));
      if (attrToDeserialize.addSyntheticAttributeHash) {
        // TODO(bazel-team): This might give false positives because of explicit vs implicit.
        hasher.putBytes(attrPb.toByteArray());
      }
    }
    AttributeContainerWithoutLocation attributeContainer =
        new AttributeContainerWithoutLocation(ruleClass, hasher.hash());

    Label ruleLabel = deserializeLabel(rulePb.getName());
    try {
      Rule rule =
          createRuleWithParsedAttributeValues(
              ruleClass,
              ruleLabel,
              context.packageBuilder,
              ruleLocation,
              attributeValues,
              NullEventHandler.INSTANCE,
              attributeContainer);
      context.packageBuilder.addRule(rule);

      // Remove the attribute after it is added to package in order to pass the validations
      // and be able to compute all the outputs.
      if (attrToDeserialize != DESERIALIZE_ALL_ATTRS) {
        for (String attrName : attributeValues.keySet()) {
          Attribute attribute = ruleClass.getAttributeByName(attrName);
          if (!(attrToDeserialize.shouldKeepAttributeWithName.apply(attrName)
              || BuildType.isLabelType(attribute.getType()))) {
            attributeContainer.clearIfNotLabel(attrName);
          }
        }
      }

      Preconditions.checkState(!rule.containsErrors());
    } catch (NameConflictException | LabelSyntaxException e) {
      throw new PackageDeserializationException(e);
    }
  }
  public final void doBuild(StaplerRequest req, StaplerResponse rsp)
      throws ServletException, IOException {
    if (LOGGER.isLoggable(Level.FINE)) {
      LOGGER.log(Level.FINE, "doBuild action called");
    }

    String buildAction = req.getParameter("action");
    if (buildAction == null) {
      rsp.forwardToPreviousPage(req);
      return;
    }

    String buildType = req.getParameter("build");
    if (buildType == null) {
      rsp.forwardToPreviousPage(req);
      return;
    }

    BuildAction action;
    BuildType type;

    try {
      action = BuildAction.valueOf(buildAction.toUpperCase());
      type = BuildType.valueOf(buildType.toUpperCase());
    } catch (IllegalArgumentException e) {
      rsp.forwardToPreviousPage(req);
      return;
    }

    Builder builder = new Builder(action);

    String params = req.getParameter("params");
    BulkParamProcessor processor = new BulkParamProcessor(params);
    Map<String, String> projectParams = processor.getProjectParams();

    String paramBuild = req.getParameter("paramBuild");
    if (paramBuild != null && !paramBuild.isEmpty() && !projectParams.isEmpty()) {
      builder.setUserParams(projectParams);
    }

    String pattern = req.getParameter("pattern");
    if (pattern != null && !pattern.isEmpty()) {
      builder.setPattern(pattern);
      BuildHistory history = Jenkins.getInstance().getPlugin(BuildHistory.class);
      history.add(new BuildHistoryItem(pattern));
    }

    String view = req.getParameter("view");
    if (view != null && !view.isEmpty()) {
      builder.setView(view);
    }

    switch (type) {
      case ABORTED:
        builder.buildAborted();
        break;
      case ALL:
        builder.buildAll();
        break;
      case FAILED:
        builder.buildFailed();
        break;
      case FAILED_ONLY:
        builder.buildFailedOnly();
        break;
      case NOT_BUILD_ONLY:
        builder.buildNotBuildOnly();
        break;
      case NOT_BUILT:
        builder.buildNotBuilt();
        break;
      case UNSTABLE:
        builder.buildUnstable();
        break;
      case UNSTABLE_ONLY:
        builder.buildUnstableOnly();
        break;
    }

    rsp.forwardToPreviousPage(req);
  }
 @Override
 public String toShownString(final BuildType o) {
   return o.getShownName();
 }
 @Override
 public String toCabalString(final BuildType o) {
   return o.getCabalName();
 }
 @Override
 public BuildType[] getValues() {
   return BuildType.values();
 }
 /** 生成索引 */
 @RequestMapping(value = "/build", method = RequestMethod.GET)
 public String build(ModelMap model) {
   model.addAttribute("buildTypes", BuildType.values());
   return "/admin/index/build";
 }