private boolean partialElasticAgentAutoregistrationInfo(String elasticAgentId, String elasticPluginId) { return (isBlank(elasticAgentId) && isNotBlank(elasticPluginId)) || (isNotBlank(elasticAgentId) && isBlank(elasticPluginId)); }
public static PrimitiveType fromTypeAndFormat(String type, String format) { if (StringUtils.isNotBlank(type) && type.equals("object")) { return null; } return fromName(datatypeMappings.get(String.format("%s_%s", StringUtils.isBlank(type) ? "" : type, StringUtils.isBlank(format) ? "" : format))); }
static void configureLogging(final List<String> commandList) { String configFilePropertyValue = System.getProperty(CONFIGURATION_FILE_PROPERTY); if (StringUtils.isBlank(configFilePropertyValue)) { URL configUrl = LogService.class.getResource(Configuration.CLI_CONFIG); configFilePropertyValue = configUrl.toString(); } commandList.add("-D" + CONFIGURATION_FILE_PROPERTY + "=" + configFilePropertyValue); }
public void validateName(Map<String, ParamConfig> paramConfigMap, ValidationContext validationContext) { CaseInsensitiveString parentName = validationContext.getPipeline().name(); if (StringUtils.isBlank(name)) { configErrors.add("name", String.format("Parameter cannot have an empty name for pipeline '%s'.", parentName)); return; } String currentParamName = name.toLowerCase(); ParamConfig paramWithSameName = paramConfigMap.get(currentParamName); if (paramWithSameName != null) { paramWithSameName.addNameConflictError(name, parentName); addNameConflictError(name, parentName); return; } paramConfigMap.put(currentParamName, this); }
@Override public List<Command> getHighWatermarkMetadata(String schema, String entity, String watermarkColumn, List<Predicate> predicateList) throws HighWatermarkException { log.debug("Build query to get high watermark"); List<Command> commands = new ArrayList<>(); String columnProjection = "max(" + Utils.getCoalesceColumnNames(watermarkColumn) + ")"; String watermarkFilter = this.concatPredicates(predicateList); String query = this.getExtractSql(); if (StringUtils.isBlank(watermarkFilter)) { watermarkFilter = "1=1"; } query = query.replace(this.getOutputColumnProjection(), columnProjection) .replace(ConfigurationKeys.DEFAULT_SOURCE_QUERYBASED_WATERMARK_PREDICATE_SYMBOL, watermarkFilter); commands.add(JdbcExtractor.getCommand(query, JdbcCommand.JdbcCommandType.QUERY)); return commands; }
private Map<String,String> getHeadersWithToken(final String base64token) { if (StringUtils.isBlank(base64token)) { throw new IllegalArgumentException("Token cannot be null"); } final Map<String,String> headers = new HashMap<>(); headers.put(AUTHORIZATION_HEADER, BEARER + " " + base64token); return headers; }
private Admin[] extractAdminUsers(List<Map<String, String>> map) { List<Admin> result = new ArrayList<>(map.size()); for (Map<String, String> usernameMap : map) { String value = usernameMap.get("name").trim(); if (!StringUtils.isBlank(value)) { result.add(new AdminUser(new CaseInsensitiveString(value))); } } return result.toArray(new Admin[result.size()]); }
@Override public List<MetaDto> metas(String type, String orderBy, int limit){ LOGGER.debug("Enter metas method:type={},order={},limit={}", type, orderBy, limit); List<MetaDto> retList=null; if (StringUtils.isNotBlank(type)) { if(StringUtils.isBlank(orderBy)){ orderBy = "count desc, a.mid desc"; } if(limit < 1 || limit > WebConst.MAX_POSTS){ limit = 10; } Map<String, Object> paraMap = new HashMap<>(); paraMap.put("type", type); paraMap.put("order", orderBy); paraMap.put("limit", limit); retList= metaDao.selectFromSql(paraMap); } LOGGER.debug("Exit metas method"); return retList; }
static void addCurrentLocators(OfflineGfshCommand gfshCommand, final List<String> commandLine, final Properties gemfireProperties) throws MalformedObjectNameException { if (StringUtils.isBlank(gemfireProperties.getProperty(LOCATORS))) { String currentLocators = getCurrentLocators(gfshCommand); if (StringUtils.isNotBlank(currentLocators)) { commandLine.add("-D".concat(ProcessLauncherContext.OVERRIDDEN_DEFAULTS_PREFIX) .concat(LOCATORS).concat("=").concat(currentLocators)); } } }
@Override public CredentialsService getCredentialsService(String applicationId) { String serviceName = this.cacheService.findAppById(applicationId).getCredentialsServiceName(); if (StringUtils.isBlank(serviceName)) { serviceName = DEFAULT_CREDENTIALS_SERVICE_NAME; LOG.debug("No credentials service configured for application [{}], using [{}]", applicationId, serviceName); } CredentialsServiceLocator locator = credentialsServiceLocatorMap.get(serviceName); if (locator == null) { throw new IllegalStateException("Can't find credentials service factory for name: " + serviceName); } else { return locator.getCredentialsService(applicationId); } }
@Override public List<MetaDto> getMetaList(String type, String orderby, int limit) { if (StringUtils.isNotBlank(type)) { if (StringUtils.isBlank(orderby)) { orderby = "count desc, a.mid desc"; } if (limit < 1 || limit > WebConst.MAX_POSTS) { limit = 10; } Map<String, Object> paraMap = new HashMap<>(); paraMap.put("type", type); paraMap.put("order", orderby); paraMap.put("limit", limit); return metaDao.selectFromSql(paraMap); } return null; }
private String generateUuid(final String propposedId, final String destinationGroupId, final String seed) { long msb = UUID.nameUUIDFromBytes((propposedId + destinationGroupId).getBytes(StandardCharsets.UTF_8)).getMostSignificantBits(); UUID uuid; if (StringUtils.isBlank(seed)) { long lsb = randomGenerator.nextLong(); // since msb is extracted from type-one UUID, the type-one semantics will be preserved uuid = new UUID(msb, lsb); } else { UUID seedId = UUID.nameUUIDFromBytes((propposedId + destinationGroupId + seed).getBytes(StandardCharsets.UTF_8)); uuid = new UUID(msb, seedId.getLeastSignificantBits()); } LOG.debug("Generating UUID {} from currentId={}, seed={}", uuid, propposedId, seed); return uuid.toString(); }
/** * @param source * @param token * * @return */ public static List<String> parseStringToStringList(String source, String token) { if (StringUtils.isBlank(source) || StringUtils.isEmpty(token)) { return null; } List<String> result = new ArrayList<String>(); String[] units = source.split(token); for (String unit : units) { result.add(unit); } return result; }
@Override public void validateNameUniqueness(Map<CaseInsensitiveString, AbstractMaterialConfig> map) { if (StringUtils.isBlank(scmId)) { return; } if (map.containsKey(new CaseInsensitiveString(scmId))) { AbstractMaterialConfig material = map.get(new CaseInsensitiveString(scmId)); material.addError(SCM_ID, "Duplicate SCM material detected!"); addError(SCM_ID, "Duplicate SCM material detected!"); } else { map.put(new CaseInsensitiveString(scmId), this); } }
@Override public List<Command> getHighWatermarkMetadata(String schema, String entity, String watermarkColumn, List<Predicate> predicateList) throws HighWatermarkException { log.debug("Build query to get high watermark"); List<Command> commands = new ArrayList<>(); String columnProjection = "max(" + Utils.getCoalesceColumnNames(watermarkColumn) + ")"; String watermarkFilter = this.concatPredicates(predicateList); String query = this.getExtractSql(); if (StringUtils.isBlank(watermarkFilter)) { watermarkFilter = "1=1"; } query = query.replace(this.getOutputColumnProjection(), columnProjection) .replace(ConfigurationKeys.DEFAULT_SOURCE_QUERYBASED_WATERMARK_PREDICATE_SYMBOL, watermarkFilter); commands.add(getCommand(query, JdbcCommand.JdbcCommandType.QUERY)); return commands; }
@JSONField(serialize = false) public Map<String, String> getCustomHeaders() { if (StringUtils.isBlank(headers)) { return Collections.emptyMap(); } Map<String, String> headerMap = new HashMap<String, String>(16); for (String s : headers.split(Constants.NAMING_HTTP_HEADER_SPILIER)) { String[] splits = s.split(":"); if (splits.length != 2) { continue; } headerMap.put(StringUtils.trim(splits[0]), StringUtils.trim(splits[1])); } return headerMap; }
private Admin[] extractAdminRole(List<Map<String, String>> map) { List<Admin> result = new ArrayList<>(map.size()); for (Map<String, String> usernameMap : map) { String value = usernameMap.get("name").trim(); if (!StringUtils.isBlank(value)) { result.add(new AdminRole(new CaseInsensitiveString(value))); } } return result.toArray(new Admin[result.size()]); }
@GET @Path("/refresh") public Response cassRefresh(@QueryParam(REST_HEADER_KEYSPACES) String keyspaces) throws IOException, ExecutionException, InterruptedException, JSONException { logger.debug("node tool refresh is being called"); if (StringUtils.isBlank(keyspaces)) return Response.status(400).entity("Missing keyspace in request").build(); JMXNodeTool nodeTool; try { nodeTool = JMXNodeTool.instance(config); } catch (JMXConnectionException e) { logger.error( "Exception in fetching c* jmx tool . Msgl: {}", e.getLocalizedMessage(), e); return Response.status(503).entity("JMXConnectionException").build(); } nodeTool.refresh(Lists.newArrayList(keyspaces.split(","))); return Response.ok(REST_SUCCESS, MediaType.APPLICATION_JSON).build(); }