Java PropertiesProcessor类代码示例

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Nullable
@Override
public PropertiesProcessor getPropertiesProcessor() {
    return properties -> {
        List<InvalidProperty> result = new Vector<InvalidProperty>();
        final String releaseName = properties.get(HELM_ROLLBACK_COMMAND_NAME + HelmConstants.RELEASE_NAME);
        if (PropertiesUtil.isEmptyOrNull(releaseName)) {
            result.add(new InvalidProperty(HELM_ROLLBACK_COMMAND_NAME + HelmConstants.RELEASE_NAME, "Release name must be specified"));
        }
        final Integer revision = PropertiesUtil.parseInt(properties.get(HELM_ROLLBACK_COMMAND_NAME + HelmConstants.REVISION));
        if (revision == null || revision <= 0) {
            result.add(new InvalidProperty(HELM_ROLLBACK_COMMAND_NAME + HelmConstants.REVISION, "Revision must be specified as positive integer"));
        }
        return result;
    };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Nullable
@Override
public PropertiesProcessor getPropertiesProcessor() {
    return properties -> {
        List<InvalidProperty> result = new Vector<InvalidProperty>();
        final String chart = properties.get(HELM_UPGRADE_COMMAND_NAME + HelmConstants.CHART);
        if (PropertiesUtil.isEmptyOrNull(chart)) {
            result.add(new InvalidProperty(HELM_UPGRADE_COMMAND_NAME + HelmConstants.CHART, "Chart must be specified"));
        }
        final String releaseName = properties.get(HELM_UPGRADE_COMMAND_NAME + HelmConstants.RELEASE_NAME);
        if (PropertiesUtil.isEmptyOrNull(releaseName)) {
            result.add(new InvalidProperty(HELM_UPGRADE_COMMAND_NAME + HelmConstants.RELEASE_NAME, "Release name must be specified"));
        }
        return result;
    };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Nullable
@Override
public PropertiesProcessor getRunnerPropertiesProcessor() {
    return properties -> {
        List<InvalidProperty> result = new Vector<>();
        final String commandId = properties.get(HelmConstants.COMMAND_ID);
        if (PropertiesUtil.isEmptyOrNull(commandId)) {
            result.add(new InvalidProperty(HelmConstants.COMMAND_ID, "Command to run must be specified"));
        }
        final HelmCommand helmCommand = HelmCommands.find(commandId);
        if(helmCommand != null){
            PropertiesProcessor propertiesProcessor = helmCommand.getPropertiesProcessor();
            if(propertiesProcessor != null) {
                result.addAll(propertiesProcessor.process(properties));
            }
        }
        return result;
    };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Nullable
@Override
public PropertiesProcessor getParametersProcessor() {
    return properties -> {
        ArrayList<InvalidProperty> toReturn = new ArrayList<>();
        if (!properties.containsKey(RunInContainerCloudConstants.ParameterName_CloudProfile))
            toReturn.add(new InvalidProperty(RunInContainerCloudConstants.ParameterName_CloudProfile,
                    "Please choose a cloud profile"));

        if (!properties.containsKey(RunInContainerCloudConstants.ParameterName_Image) ||
                properties.get(RunInContainerCloudConstants.ParameterName_Image).isEmpty())
            toReturn.add(new InvalidProperty(RunInContainerCloudConstants.ParameterName_Image,
                    "Please choose an image"));
        else if (!properties.get(RunInContainerCloudConstants.ParameterName_Image).matches(ContainerCloudConstants.ContainerImageRegex))
            toReturn.add(new InvalidProperty(RunInContainerCloudConstants.ParameterName_Image,
                    "Image must have format owner/image:version or repo-domain/owner/image:version (note that upper-case letters are not allowed)"));

        return toReturn;
    };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
public static PropertiesProcessor getPropertiesProcessor() {
    return properties -> {
        if (!properties.containsKey(ContainerCloudConstants.ProfileParameterName_ContainerProvider)) {
            // There's no use trying to validate anything more at this point (shouldn't ever happen anayway...)
            return Stream.of(
                    new InvalidProperty(ContainerCloudConstants.ProfileParameterName_ContainerProvider,
                            "Container provider not selected"))
                    .collect(Collectors.toList());
        }

        PropertiesProcessor specificProcessor;
        String provider = properties.get(ContainerCloudConstants.ProfileParameterName_ContainerProvider);
        switch (provider) {
            case ContainerCloudConstants.ProfileParameterValue_ContainerProvider_DockerSocket:
                specificProcessor = DockerSocketContainerProvider.getPropertiesProcessor();
                break;
            case ContainerCloudConstants.ProfileParameterValue_ContainerProvider_Helios:
                specificProcessor = HeliosContainerProvider.getPropertiesProcessor();
                break;
            default:
                throw new CloudException("Unknown container provider '" + provider + "'");
        }

        return specificProcessor.process(properties);
    };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Nullable
@Override
public PropertiesProcessor getParametersProcessor() {
  return new PropertiesProcessor() {
    public Collection<InvalidProperty> process(Map<String, String> properties) {
      List<InvalidProperty> result = new ArrayList<InvalidProperty>();

      final String userName = properties.get(myBean.getRunAsUserKey());
      if (isEmpty(userName))
        result.add(new InvalidProperty(myBean.getRunAsUserKey(), "Please specify an user name"));

      final String password = properties.get(myBean.getRunAsPasswordKey());
      if (isEmpty(password))
        result.add(new InvalidProperty(myBean.getRunAsPasswordKey(), "Please specify a password"));

      return result;
    }
  };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Nullable
@Override
public PropertiesProcessor getRunnerPropertiesProcessor() {
  return new PropertiesProcessor() {
    @Override
    public Collection<InvalidProperty> process(final Map<String, String> properties) {
      final ArrayList<InvalidProperty> result = new ArrayList<InvalidProperty>();

      final String user = properties.get(RunAsBean.Shared.getRunAsUserKey());
      final String password = properties.get(RunAsBean.Shared.getRunAsPasswordKey());

      if(!(StringUtil.isEmpty(user) && StringUtil.isEmpty(password))) {
        if (StringUtil.isEmptyOrSpaces(user)) {
          result.add(new InvalidProperty(RunAsBean.Shared.getRunAsUserKey(), "The user must be specified."));
        }

        if (StringUtil.isEmpty(password)) {
          result.add(new InvalidProperty(RunAsBean.Shared.getRunAsPasswordKey(), "The password must be specified."));
        }
      }

      return result;
    }
  };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Override
public PropertiesProcessor getRunnerPropertiesProcessor() {
  return new SSHDeployerPropertiesProcessor() {
    @Override
    public Collection<InvalidProperty> process(Map<String, String> properties) {
      final Collection<InvalidProperty> invalidProperties = new HashSet<InvalidProperty>();
      if (jetbrains.buildServer.util.StringUtil.isEmptyOrSpaces(properties.get(DeployerRunnerConstants.PARAM_USERNAME)) &&
          !SSHRunnerConstants.AUTH_METHOD_DEFAULT_KEY.equals(properties.get(SSHRunnerConstants.PARAM_AUTH_METHOD))) {
        invalidProperties.add(new InvalidProperty(DeployerRunnerConstants.PARAM_USERNAME, "Username must be specified."));
      }

      if (jetbrains.buildServer.util.StringUtil.isEmptyOrSpaces(properties.get(DeployerRunnerConstants.PARAM_TARGET_URL))) {
        invalidProperties.add(new InvalidProperty(DeployerRunnerConstants.PARAM_TARGET_URL, "The target must be specified."));
      }

      if (jetbrains.buildServer.util.StringUtil.isEmptyOrSpaces(properties.get(SSHRunnerConstants.PARAM_COMMAND))) {
        invalidProperties.add(new InvalidProperty(SSHRunnerConstants.PARAM_COMMAND, "Remote command must be specified"));
      }
      return invalidProperties;
    }
  };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Nullable
@Override
public PropertiesProcessor getRunnerPropertiesProcessor() {
    return new PropertiesProcessor() {
        private void checkNotEmpty(@NotNull final Map<String, String> properties,
                                   @NotNull final String key,
                                   @NotNull final String message,
                                   @NotNull final Collection<InvalidProperty> res) {
            if (jetbrains.buildServer.util.StringUtil.isEmptyOrSpaces(properties.get(key))) {
                res.add(new InvalidProperty(key, message));
            }
        }

        @NotNull
        public Collection<InvalidProperty> process(@Nullable final Map<String, String> p) {
            final Collection<InvalidProperty> result = new ArrayList<InvalidProperty>();
            if (p == null) return result;

            checkNotEmpty(p, DotNetBuildConstants.Instance.getAssemblyKey(), "Assembly must be specified", result);
            checkNotEmpty(p, DotNetBuildConstants.Instance.getTargetKey(), "Target must be specified", result);

            return result;
        }
    };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Nullable
@Override
public PropertiesProcessor getRunnerPropertiesProcessor() {
  return new PropertiesProcessor() {
    @Override
    public Collection<InvalidProperty> process(final Map<String, String> properties) {
      final ArrayList<InvalidProperty> result = new ArrayList<InvalidProperty>();

      final boolean useDotTrace = StringUtil.isTrue(properties.get(DotTraceBean.Shared.getUseDotTraceKey()));
      if(useDotTrace && StringUtil.isEmptyOrSpaces(properties.get(DotTraceBean.Shared.getPathKey()))) {
        result.add(new InvalidProperty(DotTraceBean.Shared.getPathKey(), PATH_NOT_SPECIFIED_ERROR_MESSAGE));
      }

      if(useDotTrace && StringUtil.isEmptyOrSpaces(properties.get(DotTraceBean.Shared.getThresholdsKey()))) {
        result.add(new InvalidProperty(DotTraceBean.Shared.getThresholdsKey(), THRESHOLDS_NOT_SPECIFIED_ERROR_MESSAGE));
      }

      return result;
    }
  };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Nullable
@Override
public PropertiesProcessor getRunnerPropertiesProcessor() {
  return new PropertiesProcessor() {
    @Override
    public Collection<InvalidProperty> process(final Map<String, String> properties) {
      final ArrayList<InvalidProperty> result = new ArrayList<InvalidProperty>();

      final boolean useDotMemoryUnit = StringUtil.isTrue(properties.get(DotMemoryUnitBean.Shared.getUseDotMemoryUnitKey()));
      if(useDotMemoryUnit && StringUtil.isEmptyOrSpaces(properties.get(DotMemoryUnitBean.Shared.getPathKey()))) {
        result.add(new InvalidProperty(DotMemoryUnitBean.Shared.getPathKey(), DOT_MEMORY_UNIT_PATH_NOT_SPECIFIED_ERROR_MESSAGE));
      }

      if(useDotMemoryUnit && StringUtil.isEmptyOrSpaces(properties.get(DotMemoryUnitBean.Shared.getSnapshotsPathKey()))) {
        result.add(new InvalidProperty(DotMemoryUnitBean.Shared.getSnapshotsPathKey(), SNAPSHOTS_PATH_NOT_SPECIFIED_ERROR_MESSAGE));
      }

      return result;
    }
  };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@NotNull
@Override
public PropertiesProcessor getRunnerPropertiesProcessor() {
  return new PropertiesProcessor() {
    public Collection<InvalidProperty> process(final Map<String, String> properties) {
        List<InvalidProperty> errors = new ArrayList<InvalidProperty>();
        AnsibleRunConfig config = new AnsibleRunConfig(properties);
        if (AnsibleCommand.EXECUTABLE.equals(config.getCommandType())) {
            if (StringUtil.isEmptyOrSpaces(config.getExecutable())) {
                errors.add(new InvalidProperty(AnsibleRunnerConstants.EXECUTABLE_KEY, "Cannot be empty"));
            }
            if (StringUtil.isEmptyOrSpaces(config.getPlaybook())) {
                errors.add(new InvalidProperty(AnsibleRunnerConstants.PLAYBOOK_FILE_KEY, "Cannot be empty"));
            }
        } else if (AnsibleCommand.CUSTOM_SCRIPT.equals(config.getCommandType())) {
            if (StringUtil.isEmptyOrSpaces(config.getSourceCode())) {
                errors.add(new InvalidProperty(AnsibleRunnerConstants.SOURCE_CODE_KEY, "Cannot be empty"));
            }
        }
      return errors;
    }
  };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Nullable
@Override
public PropertiesProcessor getRunnerPropertiesProcessor() {
    return new PropertiesProcessor() {
        public Collection<InvalidProperty> process(Map<String, String> properties) {
            List<InvalidProperty> invalidProperties = new LinkedList<InvalidProperty>();

            final String serverId = properties.get(Constants.SONAR_SERVER_ID);
            if (serverId == null) {
                invalidProperties.add(new InvalidProperty(Constants.SQS_CHOOSER, "Choose a SonarQube Server to send information to"));
            }

            return invalidProperties;
        }
    };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Nullable
@Override
public PropertiesProcessor getRunnerPropertiesProcessor() {
  return new PropertiesProcessor() {
    @NotNull
    public Collection<InvalidProperty> process(Map<String, String> properties) {
      List<InvalidProperty> result = new ArrayList<InvalidProperty>();
      if (StringUtil.isEmptyOrSpaces(properties.get(VMConstants.PARAMETER_SCRIPT))) {
        result.add(new InvalidProperty(VMConstants.PARAMETER_SCRIPT, "Script should not be empty"));
      }

      final String vm = properties.get(VMConstants.PARAMETER_VM);
      final VM w = VM.find(vm);
      if (w == null) {
        result.add(new InvalidProperty(VMConstants.PARAMETER_VM, "Unknown VM"));
      } else {
        result.addAll(w.validate(properties));
      }
      return result;
    }
  };
}
 

import jetbrains.buildServer.serverSide.PropertiesProcessor; //导入依赖的package包/类
@Override
public PropertiesProcessor getRunnerPropertiesProcessor() {
  return properties -> {
    Collection<InvalidProperty> col = new ArrayList<>();
    final PowerShellExecutionMode exe = PowerShellExecutionMode.fromString(properties.get(RUNNER_EXECUTION_MODE));
    if (exe == null) {
      col.add(new InvalidProperty(RUNNER_EXECUTION_MODE, "Execution mode must be specified"));
    }

    final PowerShellScriptMode mod = getScriptMode(properties);
    if (mod == null) {
      col.add(new InvalidProperty(RUNNER_SCRIPT_MODE, "Script mode is not defined"));
    } else {
      switch (mod) {
        case FILE:
          final String script = properties.get(RUNNER_SCRIPT_FILE);
          if (StringUtil.isEmptyOrSpaces(script)) {
            col.add(new InvalidProperty(RUNNER_SCRIPT_FILE, "Script file is not defined"));
          } else if (!ReferencesResolverUtil.containsReference(script) && !script.toLowerCase().endsWith(".ps1")) {
            col.add(new InvalidProperty(RUNNER_SCRIPT_FILE, "PowerShell requires script files to have .ps1 extension"));
          }
          break;
        case CODE:
          if (StringUtil.isEmptyOrSpaces(properties.get(RUNNER_SCRIPT_CODE))) {
            col.add(new InvalidProperty(RUNNER_SCRIPT_CODE, "Code should not be empty"));
          }
          break;
      }
    }
    return col;
  };
}