org.cloudfoundry.reactor.ConnectionContext 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;
}
 

@Override
public Launcher createLauncher(String account) {
	ConnectionContext connectionContext = connectionContext(account);
	TokenProvider tokenProvider = tokenProvider(account);
	CloudFoundryClient cloudFoundryClient = cloudFoundryClient(account);
	CloudFoundryOperations cloudFoundryOperations = cloudFoundryOperations(cloudFoundryClient, account);
	CloudFoundryTaskLauncher taskLauncher = new CloudFoundryTaskLauncher(
			cloudFoundryClient,
			deploymentProperties(account),
			cloudFoundryOperations,
			runtimeEnvironmentInfo(cloudFoundryClient, account));
	Launcher launcher = new Launcher(account, CLOUDFOUNDRY_PLATFORM_TYPE, taskLauncher,
			scheduler(account, taskLauncher, cloudFoundryOperations));
	CloudFoundryConnectionProperties connectionProperties = connectionProperties(account);
	launcher.setDescription(String.format("org = [%s], space = [%s], url = [%s]",
			connectionProperties.getOrg(), connectionProperties.getSpace(),
			connectionProperties.getUrl()));
	return launcher;
}
 

@Bean
public CloudFoundryOperations cloudFoundryOperations(CloudFoundryClient cloudFoundryClient,
													 ConnectionContext connectionContext,
													 TokenProvider tokenProvider,
													 CloudFoundryConnectionProperties properties) {
	ReactorDopplerClient.builder()
		.connectionContext(connectionContext)
		.tokenProvider(tokenProvider)
		.build();

	ReactorUaaClient.builder()
		.connectionContext(connectionContext)
		.tokenProvider(tokenProvider)
		.build();

	return DefaultCloudFoundryOperations.builder()
		.cloudFoundryClient(cloudFoundryClient)
		.organization(properties.getOrg())
		.space(properties.getSpace())
		.build();
}
 

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

private OAuthClient createOAuthClient(URL controllerUrl, String origin) {
    Map<String, Object> infoMap = getInfoMap(controllerUrl);
    URL authorizationEndpoint = getAuthorizationEndpoint(infoMap);
    if (StringUtils.isEmpty(origin)) {
        return restUtil.createOAuthClient(authorizationEndpoint, getHttpProxyConfiguration(), shouldTrustSelfSignedCertificates());
    }
    ConnectionContext connectionContext = getCloudFoundryClientFactory().getOrCreateConnectionContext(controllerUrl.getHost());
    return restUtil.createOAuthClient(authorizationEndpoint, getHttpProxyConfiguration(), shouldTrustSelfSignedCertificates(),
                                      connectionContext, origin);
}
 

public OAuthClient createOAuthClient(URL authorizationUrl, HttpProxyConfiguration httpProxyConfiguration, boolean trustSelfSignedCerts,
                                     ConnectionContext connectionContext, String origin) {
    return new OAuthClientWithLoginHint(authorizationUrl,
                                        createRestTemplate(httpProxyConfiguration, trustSelfSignedCerts),
                                        connectionContext,
                                        origin);
}
 

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

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

@Bean
@ConditionalOnMissingBean
public ConnectionContext connectionContext(CloudFoundryConnectionProperties properties) {
	return DefaultConnectionContext.builder()
		.apiHost(properties.getUrl().getHost())
		.skipSslValidation(properties.isSkipSslValidation())
		.build();
}
 

@Bean
@ConditionalOnMissingBean
public ReactorSchedulerClient reactorSchedulerClient(ConnectionContext context,
		TokenProvider passwordGrantTokenProvider,
		CloudFoundrySchedulerProperties properties) {
	return ReactorSchedulerClient.builder()
			.connectionContext(context)
			.tokenProvider(passwordGrantTokenProvider)
			.root(Mono.just(properties.getSchedulerUrl()))
			.build();
}
 

@Bean
public ConnectionContext connectionContext(CloudFoundryConnectionProperties properties) {
	return DefaultConnectionContext.builder()
			.apiHost(properties.getUrl().getHost())
			.skipSslValidation(properties.isSkipSslValidation())
			.build();
}
 

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

public ConnectionContext connectionContext(String account) {
	CloudFoundryConnectionProperties connectionProperties =
		this.platformProperties.accountProperties(account).getConnection();
	this.connectionContexts.putIfAbsent(account, DefaultConnectionContext.builder()
		.apiHost(connectionProperties.getUrl().getHost())
		.skipSslValidation(connectionProperties.isSkipSslValidation())
		.build());
	return connectionContexts.get(account);
}
 

@Bean
@ConditionalOnMissingBean
public ReactorSchedulerClient reactorSchedulerClient(ConnectionContext context,
		TokenProvider passwordGrantTokenProvider,
		CloudFoundrySchedulerProperties properties) {
	return ReactorSchedulerClient.builder()
			.connectionContext(context)
			.tokenProvider(passwordGrantTokenProvider)
			.root(Mono.just(properties.getSchedulerUrl()))
			.build();
}
 

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

@Bean
@Lazy
@ConditionalOnMissingBean
public DopplerClient dopplerClient(ConnectionContext connectionContext,
		TokenProvider tokenProvider) {
	return ReactorDopplerClient.builder().connectionContext(connectionContext)
			.tokenProvider(tokenProvider).build();
}
 

@Bean
@Lazy
@ConditionalOnMissingBean
public RoutingClient routingClient(ConnectionContext connectionContext,
		TokenProvider tokenProvider) {
	return ReactorRoutingClient.builder().connectionContext(connectionContext)
			.tokenProvider(tokenProvider).build();
}
 

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

@Bean
protected ConnectionContext connectionContext(CloudFoundryProperties properties) {
	return DefaultConnectionContext.builder()
		.apiHost(properties.getApiHost())
		.port(Optional.ofNullable(properties.getApiPort()))
		.skipSslValidation(properties.isSkipSslValidation())
		.secure(properties.isSecure())
		.build();
}
 

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

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

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

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

@Bean
ReactorUaaClient uaaClient(ConnectionContext ctx, TokenProvider tokenProvider) {
	return ReactorUaaClient
		.builder()
		.connectionContext(ctx)
		.tokenProvider(tokenProvider)
		.build();
}
 

/**
 * 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();
}
 

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

/**
 * Provide a {@link ReactorUaaClient} bean
 *
 * @param connectionContext the ConnectionContext bean
 * @param tokenProvider the TokenProvider bean
 * @return the bean
 */
@UaaClientQualifier
@Bean
public ReactorUaaClient uaaClient(ConnectionContext connectionContext,
	@TokenQualifier TokenProvider tokenProvider) {
	return ReactorUaaClient.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);
		});
}
 

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

private ConnectionContext createConnectionContext(String controllerApiHost) {
    DefaultConnectionContext.Builder builder = DefaultConnectionContext.builder()
                                                                       .apiHost(controllerApiHost);
    getSslHandshakeTimeout().ifPresent(builder::sslHandshakeTimeout);
    getConnectTimeout().ifPresent(builder::connectTimeout);
    getConnectionPoolSize().ifPresent(builder::connectionPoolSize);
    getThreadPoolSize().ifPresent(builder::threadPoolSize);
    builder.additionalHttpClientConfiguration(client -> client.metrics(true));
    return builder.build();
}