org.cloudfoundry.reactor.client.ReactorCloudFoundryClient Java Examples

protected CloudFoundryOperations getCfOperations() {
    CfProperties cfAppProperties = this.cfPropertiesMapper.getProperties();

    ConnectionContext connectionContext = DefaultConnectionContext.builder()
        .apiHost(cfAppProperties.ccHost())
        .skipSslValidation(true)
        .proxyConfiguration(tryGetProxyConfiguration(cfAppProperties))
        .build();

    TokenProvider tokenProvider = getTokenProvider(cfAppProperties);

    CloudFoundryClient cfClient = ReactorCloudFoundryClient.builder()
        .connectionContext(connectionContext)
        .tokenProvider(tokenProvider)
        .build();

    DefaultCloudFoundryOperations cfOperations = DefaultCloudFoundryOperations.builder()
        .cloudFoundryClient(cfClient)
        .organization(cfAppProperties.org())
        .space(cfAppProperties.space())
        .build();

    return cfOperations;
}
 

public UserCloudFoundryService(CloudFoundryOperations cloudFoundryOperations, CloudFoundryProperties cloudFoundryProperties) {
	DefaultCloudFoundryOperations sourceCloudFoundryOperations =
		(DefaultCloudFoundryOperations) cloudFoundryOperations;

	this.targetOrg = cloudFoundryProperties.getDefaultOrg() + "-instances";
	this.targetSpace = cloudFoundryProperties.getDefaultSpace();

	ClientCredentialsGrantTokenProvider tokenProvider = ClientCredentialsGrantTokenProvider.builder()
		.clientId(USER_CLIENT_ID)
		.clientSecret(USER_CLIENT_SECRET)
		.build();

	ReactorCloudFoundryClient cloudFoundryClient = ReactorCloudFoundryClient.builder()
		.from((ReactorCloudFoundryClient) sourceCloudFoundryOperations.getCloudFoundryClient())
		.tokenProvider(tokenProvider)
		.build();

	this.cloudFoundryOperations = DefaultCloudFoundryOperations
		.builder()
		.from(sourceCloudFoundryOperations)
		.space(targetSpace)
		.organization(targetOrg)
		.cloudFoundryClient(cloudFoundryClient)
		.build();
}
 

@Bean
public DefaultCloudFoundryOperations opsClient(ReactorCloudFoundryClient cloudFoundryClient,
        ReactorDopplerClient dopplerClient, ReactorUaaClient uaaClient) {
    return DefaultCloudFoundryOperations
            .builder()
                .cloudFoundryClient(cloudFoundryClient)
                .dopplerClient(dopplerClient)
                .uaaClient(uaaClient)
                .build();
}
 

private void assertCloudFoundryClientBeansPresent(
		AssertableApplicationContext context) {
	assertThat(context).hasSingleBean(ReactorCloudFoundryClient.class);
	assertThat(context).hasSingleBean(DefaultCloudFoundryOperations.class);
	assertThat(context).hasSingleBean(DefaultConnectionContext.class);
	assertThat(context).hasSingleBean(DopplerClient.class);
	assertThat(context).hasSingleBean(RoutingClient.class);
	assertThat(context).hasSingleBean(PasswordGrantTokenProvider.class);
	assertThat(context).hasSingleBean(ReactorUaaClient.class);
}
 

@Bean
@Lazy
@ConditionalOnMissingBean
public ReactorCloudFoundryClient cloudFoundryClient(
		ConnectionContext connectionContext, TokenProvider tokenProvider) {
	return ReactorCloudFoundryClient.builder().connectionContext(connectionContext)
			.tokenProvider(tokenProvider).build();
}
 

public CloudFoundryClient cloudFoundryClient(String account){
		cloudFoundryClients.putIfAbsent(account, ReactorCloudFoundryClient.builder()
			.connectionContext(connectionContextProvider.connectionContext(account))
			.tokenProvider(platformTokenProvider.tokenProvider(account))
			.build());
		return cloudFoundryClients.get(account);
}
 

@Bean
public CloudFoundryClient cloudFoundryClient(ConnectionContext connectionContext,
											 TokenProvider tokenProvider) {
	return ReactorCloudFoundryClient.builder()
			.connectionContext(connectionContext)
			.tokenProvider(tokenProvider)
			.build();
}
 

@Bean
@ConditionalOnMissingBean
public CloudFoundryClient cloudFoundryClient(ConnectionContext connectionContext, TokenProvider tokenProvider) {
	return ReactorCloudFoundryClient.builder()
		.connectionContext(connectionContext)
		.tokenProvider(tokenProvider)
		.build();
}
 

@Test
    public void getAppDetailTests() {
        ConnectionContext connectionContext = DefaultConnectionContext.builder()
            .apiHost("api.local.pcfdev.io")
            .skipSslValidation(true)
            .build();

        TokenProvider tokenProvider = PasswordGrantTokenProvider.builder()
            .password("admin")
            .username("admin")
            .build();

        CloudFoundryClient cfClient = ReactorCloudFoundryClient.builder()
            .connectionContext(connectionContext)
            .tokenProvider(tokenProvider)
            .build();

        CloudFoundryOperations cfOperations = DefaultCloudFoundryOperations.builder()
            .cloudFoundryClient(cfClient)
            .organization("pcfdev-org")
            .space("pcfdev-space")
            .build();

        CfAppDetailsDelegate appDetailsTaskDelegate = new CfAppDetailsDelegate();
        CfProperties cfAppProps = envDetails();
        Mono<Optional<ApplicationDetail>> applicationDetailMono = appDetailsTaskDelegate
            .getAppDetails(cfOperations, cfAppProps);


//		Mono<Void> resp = applicationDetailMono.then(applicationDetail -> Mono.fromSupplier(() -> {
//			return 1;
//		})).then();
//
//		resp.block();
//		ApplicationDetail applicationDetail = applicationDetailMono.block(Duration.ofMillis(5000));
//		System.out.println("applicationDetail = " + applicationDetail);
    }
 

private CloudFoundryOperations buildCloudFoundryOperations(String platformName) {
	CloudFoundryPlatformProperties.CloudFoundryProperties cloudFoundryProperties = this.cloudFoundryPlatformProperties
			.getAccounts()
			.get(platformName);
	CloudFoundryConnectionProperties connectionProperties = cloudFoundryProperties.getConnection();
	ConnectionContext connectionContext = DefaultConnectionContext.builder()
			.apiHost(connectionProperties.getUrl().getHost())
			.skipSslValidation(connectionProperties.isSkipSslValidation())
			.build();
	Builder tokenProviderBuilder = PasswordGrantTokenProvider.builder()
			.username(connectionProperties.getUsername())
			.password(connectionProperties.getPassword())
			.loginHint(connectionProperties.getLoginHint());
	if (StringUtils.hasText(connectionProperties.getClientId())) {
		tokenProviderBuilder.clientId(connectionProperties.getClientId());
	}
	if (StringUtils.hasText(connectionProperties.getClientSecret())) {
		tokenProviderBuilder.clientSecret(connectionProperties.getClientSecret());
	}
	TokenProvider tokenProvider = tokenProviderBuilder.build();
	CloudFoundryClient cloudFoundryClient = ReactorCloudFoundryClient.builder()
			.connectionContext(connectionContext)
			.tokenProvider(tokenProvider)
			.build();
	return DefaultCloudFoundryOperations
			.builder().cloudFoundryClient(cloudFoundryClient)
			.organization(connectionProperties.getOrg())
			.space(connectionProperties.getSpace()).build();
}
 

@Bean
protected CloudFoundryClient cloudFoundryClient(ConnectionContext connectionContext,
	@Qualifier("userCredentials") TokenProvider tokenProvider) {
	return ReactorCloudFoundryClient.builder()
		.connectionContext(connectionContext)
		.tokenProvider(tokenProvider)
		.build();
}
 

@Test
void clientIsNotCreatedWithoutConfiguration() {
	this.contextRunner
		.run((context) -> {
			assertThat(context).doesNotHaveBean(CloudFoundryTargetProperties.class);
			assertThat(context).doesNotHaveBean(CloudFoundryDeploymentProperties.class);
			assertThat(context).doesNotHaveBean(ReactorCloudFoundryClient.class);
			assertThat(context).doesNotHaveBean(ReactorDopplerClient.class);
			assertThat(context).doesNotHaveBean(ReactorUaaClient.class);
			assertThat(context).doesNotHaveBean(CloudFoundryOperations.class);
			assertThat(context).doesNotHaveBean(CloudFoundryOperationsUtils.class);
			assertThat(context).doesNotHaveBean(ConnectionContext.class);
			assertThat(context).doesNotHaveBean(TokenProvider.class);
		});
}
 

@Test
void clientIsCreatedWithCredentialsGrantConfiguration() {
	this.contextRunner
		.withPropertyValues(
			"spring.cloud.appbroker.deployer.cloudfoundry.api-host=api.example.local",
			"spring.cloud.appbroker.deployer.cloudfoundry.api-port=443",
			"spring.cloud.appbroker.deployer.cloudfoundry.default-org=example-org",
			"spring.cloud.appbroker.deployer.cloudfoundry.default-space=example-space",
			"spring.cloud.appbroker.deployer.cloudfoundry.client-id=oauth-client",
			"spring.cloud.appbroker.deployer.cloudfoundry.client-secret=secret"
		)
		.run((context) -> {
			assertThat(context).hasSingleBean(CloudFoundryTargetProperties.class);
			CloudFoundryTargetProperties targetProperties = context.getBean(CloudFoundryTargetProperties.class);
			assertThat(targetProperties.getApiHost()).isEqualTo("api.example.local");
			assertThat(targetProperties.getApiPort()).isEqualTo(443);
			assertThat(targetProperties.getDefaultOrg()).isEqualTo("example-org");
			assertThat(targetProperties.getDefaultSpace()).isEqualTo("example-space");
			assertThat(targetProperties.getClientId()).isEqualTo("oauth-client");
			assertThat(targetProperties.getClientSecret()).isEqualTo("secret");

			assertThat(context).hasSingleBean(AppDeployer.class);
			assertThat(context).hasSingleBean(AppManager.class);

			assertThat(context).hasSingleBean(ReactorCloudFoundryClient.class);
			assertThat(context).hasSingleBean(ReactorDopplerClient.class);
			assertThat(context).hasSingleBean(ReactorUaaClient.class);
			assertThat(context).hasSingleBean(CloudFoundryOperations.class);
			assertThat(context).hasSingleBean(CloudFoundryOperationsUtils.class);
			assertThat(context).hasSingleBean(DefaultConnectionContext.class);
			assertThat(context).hasSingleBean(ClientCredentialsGrantTokenProvider.class);
		});
}
 

@Test
void configureCloudFoundryClientWithClientCredentials() {
	this.contextRunner
		.withPropertyValues("spring.cloud.appbroker.deployer.cloudfoundry.api-host=https://api.example.local",
			"spring.cloud.appbroker.deployer.cloudfoundry.client_id=user",
			"spring.cloud.appbroker.deployer.cloudfoundry.client_secret=secret")
		.run(context -> {
			assertThat(context).hasSingleBean(TokenProvider.class);
			assertThat(context).hasSingleBean(ReactorCloudFoundryClient.class);
		});
}
 

/**
 * Provide a {@link ReactorCloudFoundryClient} bean
 *
 * @param connectionContext the ConnectionContext bean
 * @param tokenProvider the TokenProvider bean
 * @return the bean
 */
@Bean
public ReactorCloudFoundryClient cloudFoundryClient(ConnectionContext connectionContext,
	@TokenQualifier TokenProvider tokenProvider) {
	return ReactorCloudFoundryClient.builder()
		.connectionContext(connectionContext)
		.tokenProvider(tokenProvider)
		.build();
}
 

@Bean
ReactorCloudFoundryClient cloudFoundryClient(
	ConnectionContext connectionContext,
	TokenProvider tokenProvider) {
	return ReactorCloudFoundryClient
		.builder()
		.connectionContext(connectionContext)
		.tokenProvider(tokenProvider).build();
}
 

@Bean
    public ReactorCloudFoundryClient cloudFoundryClient(ConnectionContext connectionContext, TokenProvider tokenProvider) {
        return ReactorCloudFoundryClient
                .builder()
                    .connectionContext(connectionContext)
                    .tokenProvider(tokenProvider)
                    .build();
}
 

private ReactorCloudFoundryClient cloudFoundryClient(ConnectionContext connectionContext, TokenProvider tokenProvider) {
	return ReactorCloudFoundryClient.builder().connectionContext(connectionContext).tokenProvider(tokenProvider).build();
}
 

public CloudFoundryClient createClient(URL controllerUrl, OAuthClient oAuthClient) {
    return ReactorCloudFoundryClient.builder()
                                    .connectionContext(getOrCreateConnectionContext(controllerUrl.getHost()))
                                    .tokenProvider(oAuthClient.getTokenProvider())
                                    .build();
}
 

@Bean
ReactorCloudFoundryClient cloudFoundryClient(ConnectionContext connectionContext,
		TokenProvider tokenProvider) {
	return ReactorCloudFoundryClient.builder().connectionContext(connectionContext)
			.tokenProvider(tokenProvider).build();
}
 

@Test
void clientIsCreatedWithPasswordGrantConfiguration() {
	this.contextRunner
		.withPropertyValues(
			"spring.cloud.appbroker.deployer.cloudfoundry.api-host=api.example.local",
			"spring.cloud.appbroker.deployer.cloudfoundry.api-port=443",
			"spring.cloud.appbroker.deployer.cloudfoundry.default-org=example-org",
			"spring.cloud.appbroker.deployer.cloudfoundry.default-space=example-space",
			"spring.cloud.appbroker.deployer.cloudfoundry.username=user",
			"spring.cloud.appbroker.deployer.cloudfoundry.password=secret",
			"spring.cloud.appbroker.deployer.cloudfoundry.properties.memory=2G",
			"spring.cloud.appbroker.deployer.cloudfoundry.properties.count=3",
			"spring.cloud.appbroker.deployer.cloudfoundry.properties.buildpack=example-buildpack",
			"spring.cloud.appbroker.deployer.cloudfoundry.properties.domain=example.local"
		)
		.run((context) -> {
			assertThat(context).hasSingleBean(CloudFoundryTargetProperties.class);
			CloudFoundryTargetProperties targetProperties = context.getBean(CloudFoundryTargetProperties.class);
			assertThat(targetProperties.getApiHost()).isEqualTo("api.example.local");
			assertThat(targetProperties.getApiPort()).isEqualTo(443);
			assertThat(targetProperties.getDefaultOrg()).isEqualTo("example-org");
			assertThat(targetProperties.getDefaultSpace()).isEqualTo("example-space");
			assertThat(targetProperties.getUsername()).isEqualTo("user");
			assertThat(targetProperties.getPassword()).isEqualTo("secret");

			assertThat(context).hasSingleBean(CloudFoundryDeploymentProperties.class);
			CloudFoundryDeploymentProperties deploymentProperties = context
				.getBean(CloudFoundryDeploymentProperties.class);
			assertThat(deploymentProperties.getMemory()).isEqualTo("2G");
			assertThat(deploymentProperties.getCount()).isEqualTo(3);
			assertThat(deploymentProperties.getBuildpack()).isEqualTo("example-buildpack");
			assertThat(deploymentProperties.getDomain()).isEqualTo("example.local");

			assertThat(context).hasSingleBean(AppDeployer.class);
			assertThat(context).hasSingleBean(AppManager.class);
			assertThat(context).hasSingleBean(OAuth2Client.class);

			assertThat(context).hasSingleBean(ReactorCloudFoundryClient.class);
			assertThat(context).hasSingleBean(ReactorDopplerClient.class);
			assertThat(context).hasSingleBean(ReactorUaaClient.class);
			assertThat(context).hasSingleBean(CloudFoundryOperations.class);
			assertThat(context).hasSingleBean(CloudFoundryOperationsUtils.class);
			assertThat(context).hasSingleBean(DefaultConnectionContext.class);
			assertThat(context).hasSingleBean(PasswordGrantTokenProvider.class);
		});
}