Java Code Examples for jetbrains.buildServer.util.StringUtil#isEmptyOrSpaces()

@Override
public Collection<InvalidProperty> process(Map<String, String> map) {
    Collection<InvalidProperty> invalids = new ArrayList<>();
    if(StringUtil.isEmptyOrSpaces(map.get(API_SERVER_URL))) invalids.add(new InvalidProperty(API_SERVER_URL, "Kubernetes API server URL must not be empty"));
    final String authStrategy = map.get(AUTH_STRATEGY);
    if (StringUtil.isEmptyOrSpaces(authStrategy)) {
        invalids.add(new InvalidProperty(AUTH_STRATEGY, "Authentication strategy must be selected"));
        return invalids;
    }
    KubeAuthStrategy strategy = myKubeAuthStrategyProvider.find(authStrategy);
    if (strategy != null) {
        Collection<InvalidProperty> strategyCollection = strategy.process(map);
        if (strategyCollection != null && !strategyCollection.isEmpty()){
            invalids.addAll(strategyCollection);
        }
    }

    return invalids;
}
 

@NotNull
public String generateNewVmName(@NotNull KubeCloudImage image) {
  try {
    myLock.readLock().lock();
    if (!myIsAvailable.get()){
      throw new CloudException("Unable to generate a name for image " + image.getId() + " - server is shutting down");
    }
    String newVmName;
    do {
      String prefix = image.getAgentNamePrefix();
      if (StringUtil.isEmptyOrSpaces(prefix)) {
        prefix = image.getDockerImage();
      }
      if (StringUtil.isEmptyOrSpaces(prefix)) {
        return UUID.randomUUID().toString();
      }
      prefix = StringUtil.replaceNonAlphaNumericChars(prefix.trim().toLowerCase(), '-');
      newVmName = String.format("%s-%d", prefix, getNextCounter(prefix));
      setTouched(prefix);

    } while (image.findInstanceById(newVmName) != null);
    return newVmName;
  } finally {
    myLock.readLock().unlock();
  }
}
 

protected Config createConfig(@NotNull KubeApiConnection connectionSettings, @NotNull KubeAuthStrategy authStrategy){
    ConfigBuilder configBuilder = new ConfigBuilder()
      .withMasterUrl(connectionSettings.getApiServerUrl())
      .withNamespace(connectionSettings.getNamespace())
      .withRequestTimeout(DEFAULT_REQUEST_TIMEOUT_MS)
      .withHttp2Disable(true)
      .withConnectionTimeout(DEFAULT_CONNECTION_TIMEOUT_MS);
    final String caCertData = connectionSettings.getCACertData();
    if(StringUtil.isEmptyOrSpaces(caCertData)){
        configBuilder.withTrustCerts(true);
    } else {
        configBuilder.withCaCertData(KubeUtils.encodeBase64IfNecessary(caCertData));
    }
    configBuilder = authStrategy.apply(configBuilder, connectionSettings);
    return configBuilder.build();
}
 

private ActionErrors validate(@NotNull TelegramSettingsBean settings) {
  ActionErrors errors = new ActionErrors();
  if (StringUtil.isEmptyOrSpaces(settings.getBotToken())) {
    errors.addError("emptyBotToken", "Bot token must not be empty");
  }
  if (settings.isUseProxy()) {
    if (StringUtils.isEmpty(settings.getProxyServer())) {
      errors.addError("emptyProxyServer", "Proxy server must not be empty");
    }
    if (StringUtils.isEmpty(settings.getProxyPort())) {
      errors.addError("emptyProxyPort", "Proxy port must not be empty");
    }
  }
  String port = settings.getProxyPort();
  if (!StringUtils.isEmpty(port) &&
      (!StringUtil.isNumber(port) || Integer.valueOf(port) < 1 || Integer.valueOf(port) > 65535)) {
    errors.addError("badProxyPort", "Proxy port must be integer between 1 and 65535");
  }
  return errors;
}
 

@NotNull
public static Map<String, String> validateParameters(@NotNull final Map<String, String> params, final boolean acceptReferences) {
  final Map<String, String> commonErrors = AWSCommonParams.validate(params, acceptReferences);
  if (!commonErrors.isEmpty()) {
    return commonErrors;
  }
  final Map<String, String> invalids = new HashMap<>();
  if (StringUtil.isEmptyOrSpaces(getBucketName(params))) {
    invalids.put(beanPropertyNameForBucketName(), "S3 bucket name must not be empty");
  }
  final String pathPrefix = params.getOrDefault(S3_PATH_PREFIX_SETTING, "");
  if (TeamCityProperties.getBoolean("teamcity.internal.storage.s3.bucket.prefix.enable") && !StringUtil.isEmptyOrSpaces(pathPrefix)) {
    if (pathPrefix.length() > OUT_MAX_PREFIX_LENGTH) {
      invalids.put(S3_PATH_PREFIX_SETTING, "Should be less than " + OUT_MAX_PREFIX_LENGTH + " characters");
    }
    if (!OUR_OBJECT_KEY_PATTERN.matcher(pathPrefix).matches()) {
      invalids.put(S3_PATH_PREFIX_SETTING, "Should match the regexp [" + OUR_OBJECT_KEY_PATTERN.pattern() + "]");
    }
  }
  return invalids;
}
 

@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;
    }
  };
}
 

@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;
    }
  };
}
 

@NotNull
private String getPathPrefix(@NotNull final AgentRunningBuild build) {
  final List<String> pathSegments = new ArrayList<>();
  final String prefix = build.getArtifactStorageSettings().getOrDefault(S3Constants.S3_PATH_PREFIX_SETTING, "");
  if (!StringUtil.isEmptyOrSpaces(prefix)) {
    pathSegments.add(prefix);
  }
  pathSegments.add(build.getSharedConfigParameters().get(ServerProvidedProperties.TEAMCITY_PROJECT_ID_PARAM));
  pathSegments.add(build.getBuildTypeExternalId());
  pathSegments.add(Long.toString(build.getBuildId()));
  return StringUtil.join("/", pathSegments) + "/";
}
 

@Override
public Collection<InvalidProperty> process(Map<String, String> properties) {
  Collection<InvalidProperty> result = super.process(properties);
  if (StringUtil.isEmptyOrSpaces(properties.get(DeployerRunnerConstants.PARAM_USERNAME)) &&
      !SSHRunnerConstants.AUTH_METHOD_DEFAULT_KEY.equals(properties.get(SSHRunnerConstants.PARAM_AUTH_METHOD))) {
    result.add(new InvalidProperty(DeployerRunnerConstants.PARAM_USERNAME, "Username must be specified."));
  }
  return result;
}
 

@Override
public Collection<InvalidProperty> process(Map<String, String> properties) {
  Collection<InvalidProperty> result = super.process(properties);

  if (StringUtil.isEmptyOrSpaces(properties.get(DeployerRunnerConstants.PARAM_USERNAME))) {
    result.add(new InvalidProperty(DeployerRunnerConstants.PARAM_USERNAME, "Username must be specified."));
  }

  if (StringUtil.isEmptyOrSpaces(properties.get(DeployerRunnerConstants.PARAM_PASSWORD))) {
    result.add(new InvalidProperty(DeployerRunnerConstants.PARAM_PASSWORD, "Password must be specified"));
  }

  return result;
}
 

@Override
public Collection<InvalidProperty> process(Map<String, String> properties) {
  Collection<InvalidProperty> result = new HashSet<InvalidProperty>();
  if (StringUtil.isEmptyOrSpaces(properties.get(DeployerRunnerConstants.PARAM_TARGET_URL))) {
    result.add(new InvalidProperty(DeployerRunnerConstants.PARAM_TARGET_URL, "The target must be specified."));
  }

  if (StringUtil.isEmptyOrSpaces(properties.get(DeployerRunnerConstants.PARAM_SOURCE_PATH))) {
    result.add(new InvalidProperty(DeployerRunnerConstants.PARAM_SOURCE_PATH, "Artifact to deploy must be specified"));
  }
  return result;
}
 

private void notEmpty(@NotNull final Map<String, String> props,
                               @NotNull final String key,
                               @NotNull final Collection<InvalidProperty> col) {
  if (!props.containsKey(key) || StringUtil.isEmptyOrSpaces(props.get(key))) {
    col.add(new InvalidProperty(key, "Value should be set"));
  }
}
 

@NotNull
public static List<String> additionalCommands(@Nullable final String text) {
  if (StringUtil.isEmptyOrSpaces(text)) return Collections.emptyList();

  final List<String> result = new ArrayList<String>();
  for (String s : text.split("[\\r\\n]+")) {
    final String arg = s.trim();
    if (arg.length() == 0) continue;

    result.addAll(StringUtil.splitHonorQuotes(arg));
  }

  return result;
}
 

@NotNull
public String getScript() throws RunBuildException {
  final String script = myContext.getRunnerParameters().get(VMConstants.PARAMETER_SCRIPT);
  if (StringUtil.isEmptyOrSpaces(script)) {
    throw new RunBuildException("Script should not be empty");
  }
  return script;
}
 

@NotNull
public String getImageName() throws RunBuildException {
  final String image = myContext.getRunnerParameters().get(VMConstants.PARAMETER_DOCKER_IMAGE_NAME);
  if (StringUtil.isEmptyOrSpaces(image)) throw new RunBuildException("Docker image is not specified");
  return image;
}
 

@NotNull
public String getCheckoutMountPoint() {
  String mountPoint = myContext.getRunnerParameters().get(VMConstants.PARAMETER_CHECKOUT_MOUNT_POINT);
  return StringUtil.isEmptyOrSpaces(mountPoint) ? "/checkout" : mountPoint;
}