io.pivotal.cfenv.core.CfService Java Examples

@Test
public void redisServiceCreation() {
	mockVcapServices(
			getServicesPayload(
					getRedisServicePayload("redis-1", hostname, port, password, "redis-db"),
					getRedisServicePayload("redis-2", hostname, port, password, "redis-db")));

	CfEnv cfEnv = new CfEnv();
	List<CfService> cfServices = cfEnv.findServicesByName("redis-1", "redis-2");
	assertThat(cfServices).hasSize(2);
	assertThat(cfServices).allMatch(cfService -> cfService.getLabel().equals("rediscloud"));
	assertThat(cfServices).allMatch(
			cfService -> cfService.getCredentials().getUriInfo("redis").getUriString()
					.equals("redis://10.20.30.40:1234"));

}
 

@Override
public boolean isDatabaseService(CfService cfService) {
	if (jdbcUrlMatchesScheme(cfService, MYSQL_SCHEME)
			|| cfService.existsByTagIgnoreCase(MYSQL_TAG)
			|| cfService.existsByLabelStartsWith(MYSQL_LABEL)
			|| cfService.existsByUriSchemeStartsWith(MYSQL_SCHEME)
			|| cfService.existsByCredentialsContainsUriField(MYSQL_SCHEME)) {
		return true;
	}
	return false;
}
 

@SuppressWarnings("unchecked")
private static Properties retrieveCfProperties(CfEnv cfEnv,
		String gcpServiceName, String cfServiceName, Map<String, String> fieldsToMap) {
	Properties properties = new Properties();

	try {
		List<CfService> serviceBindings = cfEnv.findServicesByLabel(cfServiceName);

		// If finding by label fails, attempt to find the service by tag.
		if (serviceBindings.isEmpty()) {
			serviceBindings = cfEnv.findServicesByTag(cfServiceName);
		}

		if (serviceBindings.size() != 1) {
			if (serviceBindings.size() > 1) {
				LOGGER.warn("The service " + cfServiceName + " has to be bound to a "
						+ "Cloud Foundry application once and only once.");
			}
			return properties;
		}

		CfService cfService = serviceBindings.get(0);
		CfCredentials credentials = cfService.getCredentials();
		String prefix = SPRING_CLOUD_GCP_PROPERTY_PREFIX + gcpServiceName + ".";
		fieldsToMap.forEach(
				(cfPropKey, gcpPropKey) -> properties.put(
						prefix + gcpPropKey,
						credentials.getMap().get(cfPropKey)));
	}
	catch (ClassCastException ex) {
		LOGGER.warn("Unexpected format of CF (VCAP) properties", ex);
	}

	return properties;
}
 

@Test
public void redisServiceCreationNoLabelNoTags() {
	mockVcapServices(
		getServicesPayload(
			getRedisServicePayloadNoLabelNoTags("redis-1", hostname, port, password, "redis-db"),
			getRedisServicePayloadNoLabelNoTags("redis-2", hostname, port, password, "redis-db")));

	CfEnv cfEnv = new CfEnv();
	List<CfService> cfServices = cfEnv.findServicesByName("redis-1", "redis-2");
	assertThat(cfServices).hasSize(2);
	assertThat(cfServices).allMatch(
		cfService -> cfService.getCredentials().getUri("rediss")
			.equals("rediss://myuser:[email protected]:1234"));
}
 

@Test
public void qpidServiceCreationNoLabelNoTags() throws Exception {
	mockVcapServices(getServicesPayload(
			getQpidServicePayloadNoLabelNoTags("qpid-1", hostname, port, username, password, "q-1", "vhost1"),
			getQpidServicePayloadNoLabelNoTags("qpid-2", hostname, port, username, password, "q-2", "vhost2")));
	CfEnv cfEnv = new CfEnv();
	assertThat(cfEnv.findServicesByName("qpid-1","qpid-2")).hasSize(2);
	CfService cfService = cfEnv.findServiceByName("qpid-1");
	assertThat(cfService.getCredentials().getUsername()).isEqualTo(username);
	assertThat(cfService.getCredentials().getPassword()).isEqualTo(password);
	assertThat(cfService.getCredentials().getUriInfo().getUri().getQuery())
		.contains(String.format("tcp://%s:%s", hostname, port));
}
 

@Override
public boolean accept(CfService service) {
	boolean serviceIsBound = service.existsByTagIgnoreCase("rabbitmq", "amqp") ||
			service.existsByLabelStartsWith("rabbitmq") ||
			service.existsByLabelStartsWith("cloudamqp") ||
			service.existsByUriSchemeStartsWith(amqpSchemes) ||
			service.existsByCredentialsContainsUriField(amqpSchemes);
	if (serviceIsBound) {
		ConnectorLibraryDetector.assertNoConnectorLibrary();
	}
	return serviceIsBound;
}
 

@Override
public boolean accept(CfService service) {
	boolean serviceIsBound = service.existsByTagIgnoreCase("cassandra") &&
			cassandraCredentialsPresent(service.getCredentials().getMap());
	if (serviceIsBound) {
		ConnectorLibraryDetector.assertNoConnectorLibrary();
	}
	return serviceIsBound;
}
 

@Override
public boolean accept(CfService service) {
	boolean serviceIsBound = service.existsByTagIgnoreCase("mongodb") ||
			service.existsByLabelStartsWith("mongolab") ||
			service.existsByUriSchemeStartsWith(mongoScheme) ||
			service.existsByCredentialsContainsUriField(mongoScheme);
	if (serviceIsBound) {
		ConnectorLibraryDetector.assertNoConnectorLibrary();
	}
	return serviceIsBound;
}
 

@Override
public boolean accept(CfService service) {
	boolean serviceIsBound = service.existsByTagIgnoreCase("redis") ||
			service.existsByLabelStartsWith("rediscloud") ||
			service.existsByUriSchemeStartsWith(redisSchemes) ||
			service.existsByCredentialsContainsUriField(redisSchemes);
	if (serviceIsBound) {
		ConnectorLibraryDetector.assertNoConnectorLibrary();
	}
	return serviceIsBound;
}
 

@Override
public boolean accept(CfService service) {
    return
        service.getName().equalsIgnoreCase(SERVICE_NAME);
}
 

@Override
public boolean isDatabaseService(CfService cfService) {
	// Match tags
	return jdbcUrlMatchesScheme(cfService, SQLSERVER_SCHEME)
			|| cfService.existsByLabelStartsWith(SQLSERVER_LABEL)
			|| cfService.existsByUriSchemeStartsWith(SQLSERVER_SCHEME)
			|| cfService.existsByCredentialsContainsUriField(SQLSERVER_SCHEME);
}
 

@Override
public String createJdbcUrl(CfService cfService) {
	CfCredentials cfCredentials = cfService.getCredentials();
	String jdbcUrl = (String) cfCredentials.getMap().get("jdbcUrl");
	if (jdbcUrl != null) {
		return jdbcUrl;
	}
	else {
		return buildJdbcUrlFromUriField(cfCredentials);
	}
}
 

protected boolean jdbcUrlMatchesScheme(CfService cfService, String... uriSchemes) {
	CfCredentials cfCredentials = cfService.getCredentials();
	String jdbcUrl = (String) cfCredentials.getMap().get("jdbcUrl");
	if (jdbcUrl != null) {
		for (String uriScheme : uriSchemes) {
			if (jdbcUrl.startsWith(JDBC_PREFIX + uriScheme + ":")) {
				return true;
			}
		}
	}
	return false;
}
 

@Override
public boolean isDatabaseService(CfService cfService) {
	if (jdbcUrlMatchesScheme(cfService, POSTGRESQL_SCHEME, POSTGRES_JDBC_SCHEME)
			|| cfService.existsByTagIgnoreCase(POSTGRESQL_TAG)
			|| cfService.existsByLabelStartsWith(POSTGRESQL_LABEL)
			|| cfService.existsByUriSchemeStartsWith(POSTGRESQL_SCHEME)
			|| cfService.existsByCredentialsContainsUriField(POSTGRESQL_SCHEME)) {
		return true;
	}
	return false;
}
 

@Override
public boolean isDatabaseService(CfService cfService) {
	if (jdbcUrlMatchesScheme(cfService, DB2_SCHEME)
			|| cfService.existsByTagIgnoreCase(DB2_TAGS)
			|| cfService.existsByLabelStartsWith(DB2_LABEL)
			|| cfService.existsByUriSchemeStartsWith(DB2_SCHEME)
			|| cfService.existsByCredentialsContainsUriField(DB2_SCHEME)) {
		return true;
	}
	return false;
}
 

@Override
public boolean isDatabaseService(CfService cfService) {
	// Match tags
	if (jdbcUrlMatchesScheme(cfService, ORACLE_SCHEME)
			|| cfService.existsByLabelStartsWith(ORACLE_LABEL)
			|| cfService.existsByUriSchemeStartsWith(ORACLE_SCHEME)
			|| cfService.existsByCredentialsContainsUriField(ORACLE_SCHEME)) {
		return true;
	}
	return false;
}
 

@Override
public boolean accept(CfService service) {
	return service.existsByTagIgnoreCase("credhub") ||
			service.existsByLabelStartsWith("credhub");
}
 

@Override
public boolean accept(CfService service) {
	return SpringSecurityDetector.isLegacySpringSecurityPresent() && service.existsByLabelStartsWith(PIVOTAL_SSO_LABEL);
}
 

@Override
public boolean accept(CfService service) {
    return SpringSecurityDetector.isSpringSecurityPresent() && service.existsByLabelStartsWith(PIVOTAL_SSO_LABEL);
}
 

@Override
public boolean accept(CfService service) {
    return service.existsByTagIgnoreCase("eureka");
}
 

private CfCredentials extractDatabaseServiceCredentials(String serviceName) {
    CfEnv cfEnv = new CfEnv();
    CfService sourceService = cfEnv.findServiceByName(serviceName);
    return sourceService.getCredentials();
}
 

@Override
public void postProcessEnvironment(ConfigurableEnvironment environment,
		SpringApplication application) {
	CfEnv cfEnv = new CfEnv();
	if (cfEnv.isInCf()) {
		Properties gcpCfServiceProperties = new Properties();

		Set<GcpCfService> servicesToMap = new HashSet<>(Arrays.asList(GcpCfService.values()));

		List<CfService> sqlServices = cfEnv.findServicesByLabel(GcpCfService.MYSQL.getCfServiceName(), GcpCfService.POSTGRES.getCfServiceName());
		if (sqlServices.size() == 2) {
			LOGGER.warn("Both MySQL and PostgreSQL bound to the app. "
					+ "Not configuring Cloud SQL.");
			servicesToMap.remove(GcpCfService.MYSQL);
			servicesToMap.remove(GcpCfService.POSTGRES);
		}

		servicesToMap.forEach(
				(service) -> gcpCfServiceProperties.putAll(
						retrieveCfProperties(
								cfEnv,
								service.getGcpServiceName(),
								service.getCfServiceName(),
								service.getCfPropNameToGcp())));

		// For Cloud SQL, there are some exceptions to the rule.
		// The instance connection name must be built from three fields.
		if (gcpCfServiceProperties.containsKey("spring.cloud.gcp.sql.instance-name")) {
			String instanceConnectionName =
					gcpCfServiceProperties.getProperty("spring.cloud.gcp.sql.project-id") + ":"
					+ gcpCfServiceProperties.getProperty("spring.cloud.gcp.sql.region") + ":"
					+ gcpCfServiceProperties.getProperty("spring.cloud.gcp.sql.instance-name");
			gcpCfServiceProperties.put("spring.cloud.gcp.sql.instance-connection-name",
					instanceConnectionName);
		}
		// The username and password should be in the generic DataSourceProperties.
		if (gcpCfServiceProperties.containsKey("spring.cloud.gcp.sql.username")) {
			gcpCfServiceProperties.put("spring.datasource.username",
					gcpCfServiceProperties.getProperty("spring.cloud.gcp.sql.username"));
		}
		if (gcpCfServiceProperties.containsKey("spring.cloud.gcp.sql.password")) {
			gcpCfServiceProperties.put("spring.datasource.password",
					gcpCfServiceProperties.getProperty("spring.cloud.gcp.sql.password"));
		}

		environment.getPropertySources()
				.addFirst(new PropertiesPropertySource("gcpCf", gcpCfServiceProperties));
	}
}
 

@Override
public boolean accept(CfService service) {
	return service.existsByTagIgnoreCase("configuration");
}
 

/**
 * Determine if a service is enabled.
 *
 * @param service a service to inspect.
 * @param environment the Environment.
 * @return {@code true} if the service is enabled; {@code false} otherwise
 */
default boolean isEnabled(CfService service, Environment environment) {
	return Boolean.valueOf(
		environment.getProperty(String.format("cfenv.service.%s.enabled", service.getName()),
			"true"));
}
 

/**
 * Identifies the provided service as a database service
 * @param cfService a Cloud Foundry service
 * @return {@code true} if the service describes a database service, {@code false}
 * otherwise.
 */
boolean isDatabaseService(CfService cfService);
 

/**
 * Determine if a service is supported by this processor.
 *
 * @param service a service to inspect
 * @return {@code true} if the service matches criteria; {@code false} otherwise
 */
boolean accept(CfService service);
 

String createJdbcUrl(CfService cfService);