getUserName();
+}
diff --git a/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/CloudFoundryClientCache.java b/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/CloudFoundryClientCache.java
new file mode 100644
index 000000000..e12b171b8
--- /dev/null
+++ b/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/CloudFoundryClientCache.java
@@ -0,0 +1,250 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.commons.cloudfoundry.client.v2;
+
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import org.cloudfoundry.client.CloudFoundryClient;
+import org.cloudfoundry.reactor.ConnectionContext;
+import org.cloudfoundry.reactor.DefaultConnectionContext;
+import org.cloudfoundry.reactor.ProxyConfiguration;
+import org.cloudfoundry.reactor.TokenProvider;
+import org.cloudfoundry.reactor.client.ReactorCloudFoundryClient;
+import org.cloudfoundry.reactor.doppler.ReactorDopplerClient;
+import org.cloudfoundry.reactor.tokenprovider.OneTimePasscodeTokenProvider;
+import org.cloudfoundry.reactor.tokenprovider.PasswordGrantTokenProvider;
+import org.cloudfoundry.reactor.tokenprovider.RefreshTokenGrantTokenProvider;
+import org.cloudfoundry.reactor.uaa.ReactorUaaClient;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.target.CFCredentials;
+
+/**
+ * TODO: Remove this class when the 'thread leak bug' in V2 client is fixed.
+ *
+ * At the moment each time {@link SpringCloudFoundryClient} is create a threadpool
+ * is created by the client and it is never cleaned up. The only way we have
+ * to mitigate this leak is to try and create as few clients as possible.
+ *
+ * So we have a permanent cache of clients here that is reused.
+ *
+ * When the bug is fixed then this should no longer be necessary and we can removed this cache
+ * and just create the client as needed.
+ *
+ * @author Kris De Volder
+ */
+public class CloudFoundryClientCache {
+
+ public class CFClientProvider {
+
+ final ConnectionContext connection;
+ final TokenProvider tokenProvider;
+
+ //Note the three client objects below are 'stateless' wrappers and it would be
+ // fine to recreate as needed instead of store them
+
+ final CloudFoundryClient client;
+ final ReactorUaaClient uaaClient;
+ final ReactorDopplerClient doppler;
+
+ private ProxyConfiguration getProxy(String host) {
+ // TODO: enable proxy support for vscode. The code below retrieves proxy via Eclipse proxy service thus
+ // not applicable when this is used outside of Eclipse
+// try {
+// if (StringUtils.hasText(host)) {
+// URL url = new URL("https://"+host);
+// // In certain cases, the activator would have stopped and the plugin may
+// // no longer be available. Usually onl happens on shutdown.
+// BootDashActivator plugin = BootDashActivator.getDefault();
+// if (plugin != null) {
+// IProxyService proxyService = plugin.getProxyService();
+// if (proxyService != null) {
+// IProxyData[] selectedProxies = proxyService.select(url.toURI());
+//
+// // No proxy configured or not found
+// if (selectedProxies == null || selectedProxies.length == 0) {
+// return null;
+// }
+//
+// IProxyData data = selectedProxies[0];
+// int proxyPort = data.getPort();
+// String proxyHost = data.getHost();
+// String user = data.getUserId();
+// String password = data.getPassword();
+// if (proxyHost!=null) {
+// return ProxyConfiguration.builder()
+// .host(proxyHost)
+// .port(proxyPort==-1?Optional.empty():Optional.of(proxyPort))
+// .username(Optional.ofNullable(user))
+// .password(Optional.ofNullable(password))
+// .build();
+//// return proxyHost != null ? new HttpProxyConfiguration(proxyHost, proxyPort,
+//// data.isRequiresAuthentication(), user, password) : null;
+// }
+// }
+// }
+// }
+// } catch (Exception e) {
+// Log.log(e);
+// }
+ return null;
+ }
+
+ public CFClientProvider(Params params) {
+ long sslTimeout = Long.getLong("sts.bootdash.cf.client.ssl.handshake.timeout", 60); //TODO: make a preference for this?
+ Optional keepAlive = getBooleanSystemProp("http.keepAlive");
+ debug("cf client keepAlive = "+keepAlive);
+ connection = DefaultConnectionContext.builder()
+ .proxyConfiguration(Optional.ofNullable(getProxy(params.host)))
+ .apiHost(params.host)
+ .sslHandshakeTimeout(Duration.ofSeconds(sslTimeout))
+ .keepAlive(keepAlive)
+ .skipSslValidation(params.skipSsl)
+ .build();
+
+ tokenProvider = createTokenProvider(params);
+
+ client = ReactorCloudFoundryClient.builder()
+ .connectionContext(connection)
+ .tokenProvider(tokenProvider)
+ .build();
+
+ uaaClient = ReactorUaaClient.builder()
+ .connectionContext(connection)
+ .tokenProvider(tokenProvider)
+ .build();
+
+ doppler = ReactorDopplerClient.builder()
+ .connectionContext(connection)
+ .tokenProvider(tokenProvider)
+ .build();
+ }
+
+ private TokenProvider createTokenProvider(Params params) {
+ CFCredentials creds = params.credentials;
+ switch (creds.getType()) {
+ case PASSWORD:
+ return PasswordGrantTokenProvider.builder()
+ .username(params.username)
+ .password(creds.getSecret())
+ .build();
+ case REFRESH_TOKEN:
+ return RefreshTokenGrantTokenProvider.builder()
+ .token(creds.getSecret())
+ .build();
+ case TEMPORARY_CODE:
+ return OneTimePasscodeTokenProvider.builder()
+ .passcode(creds.getSecret())
+ .build();
+ default:
+ throw new IllegalStateException("BUG! Missing switch case?");
+ }
+ }
+
+ private Optional getBooleanSystemProp(String name) {
+ String str = System.getProperty(name);
+ if (str!=null) {
+ return Optional.of(Boolean.valueOf(str));
+ }
+ return Optional.empty();
+ }
+ }
+
+ private static final boolean DEBUG = true;
+
+ private static void debug(String string) {
+ if (DEBUG) {
+ System.out.println(string);
+ }
+ }
+
+ public static class Params {
+ public final String username;
+ public final CFCredentials credentials;
+ public final String host;
+ public final boolean skipSsl;
+ public Params(String username, CFCredentials credentials, String host, boolean skipSsl) {
+ super();
+ this.username = username;
+ this.credentials = credentials;
+ this.host = host;
+ this.skipSsl = skipSsl;
+ }
+
+ @Override
+ public String toString() {
+ return "Params [username=" + username + ", host=" + host + ", skipSsl=" + skipSsl
+ + "]";
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((host == null) ? 0 : host.hashCode());
+ result = prime * result + ((credentials == null) ? 0 : credentials.hashCode());
+ result = prime * result + (skipSsl ? 1231 : 1237);
+ result = prime * result + ((username == null) ? 0 : username.hashCode());
+ return result;
+ }
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ Params other = (Params) obj;
+ if (host == null) {
+ if (other.host != null)
+ return false;
+ } else if (!host.equals(other.host))
+ return false;
+ if (credentials == null) {
+ if (other.credentials != null)
+ return false;
+ } else if (!credentials.equals(other.credentials))
+ return false;
+ if (skipSsl != other.skipSsl)
+ return false;
+ if (username == null) {
+ if (other.username != null)
+ return false;
+ } else if (!username.equals(other.username))
+ return false;
+ return true;
+ }
+ }
+
+ private Map cache = new HashMap<>();
+
+ private int clientCount = 0;
+
+ public synchronized CFClientProvider getOrCreate(String username, CFCredentials credentials, String host, boolean skipSsl) {
+ Params params = new Params(username, credentials, host, skipSsl);
+ CFClientProvider client = cache.get(params);
+ if (client==null) {
+ clientCount++;
+ debug("Creating client ["+clientCount+"]: "+params);
+ cache.put(params, client = create(params));
+ } else {
+ debug("Reusing client ["+clientCount+"]: "+params);
+ }
+ return client;
+ }
+
+ protected CFClientProvider create(Params params) {
+ return new CFClientProvider(params);
+ }
+
+}
diff --git a/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/CloudFoundryClientFactory.java b/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/CloudFoundryClientFactory.java
new file mode 100644
index 000000000..f54a993ae
--- /dev/null
+++ b/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/CloudFoundryClientFactory.java
@@ -0,0 +1,19 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Pivotal, Inc.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.commons.cloudfoundry.client.v2;
+
+import org.springframework.ide.vscode.commons.cloudfoundry.client.target.CFClientParams;
+
+public interface CloudFoundryClientFactory {
+
+ ClientRequests getClient(CFClientParams params) throws Exception;
+
+}
\ No newline at end of file
diff --git a/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/DefaultClientRequestsV2.java b/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/DefaultClientRequestsV2.java
new file mode 100644
index 000000000..57c7474db
--- /dev/null
+++ b/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/DefaultClientRequestsV2.java
@@ -0,0 +1,1330 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.commons.cloudfoundry.client.v2;
+
+import static org.cloudfoundry.util.tuple.TupleUtils.function;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.cloudfoundry.client.CloudFoundryClient;
+import org.cloudfoundry.client.v2.applications.ApplicationEntity;
+import org.cloudfoundry.client.v2.applications.CreateApplicationRequest;
+import org.cloudfoundry.client.v2.applications.GetApplicationResponse;
+import org.cloudfoundry.client.v2.applications.UpdateApplicationRequest;
+import org.cloudfoundry.client.v2.applications.UpdateApplicationResponse;
+import org.cloudfoundry.client.v2.buildpacks.ListBuildpacksRequest;
+import org.cloudfoundry.client.v2.buildpacks.ListBuildpacksResponse;
+import org.cloudfoundry.client.v2.domains.DomainResource;
+import org.cloudfoundry.client.v2.domains.ListDomainsRequest;
+import org.cloudfoundry.client.v2.domains.ListDomainsResponse;
+import org.cloudfoundry.client.v2.info.GetInfoRequest;
+import org.cloudfoundry.client.v2.info.GetInfoResponse;
+import org.cloudfoundry.client.v2.serviceinstances.DeleteServiceInstanceRequest;
+import org.cloudfoundry.client.v2.stacks.GetStackRequest;
+import org.cloudfoundry.client.v2.stacks.GetStackResponse;
+import org.cloudfoundry.client.v2.userprovidedserviceinstances.DeleteUserProvidedServiceInstanceRequest;
+import org.cloudfoundry.operations.CloudFoundryOperations;
+import org.cloudfoundry.operations.DefaultCloudFoundryOperations;
+import org.cloudfoundry.operations.applications.ApplicationDetail;
+import org.cloudfoundry.operations.applications.DeleteApplicationRequest;
+import org.cloudfoundry.operations.applications.GetApplicationEnvironmentsRequest;
+import org.cloudfoundry.operations.applications.GetApplicationRequest;
+import org.cloudfoundry.operations.applications.RestartApplicationRequest;
+import org.cloudfoundry.operations.applications.StartApplicationRequest;
+import org.cloudfoundry.operations.applications.StopApplicationRequest;
+import org.cloudfoundry.operations.organizations.OrganizationDetail;
+import org.cloudfoundry.operations.organizations.OrganizationInfoRequest;
+import org.cloudfoundry.operations.organizations.OrganizationSummary;
+import org.cloudfoundry.operations.routes.ListRoutesRequest;
+import org.cloudfoundry.operations.routes.MapRouteRequest;
+import org.cloudfoundry.operations.routes.UnmapRouteRequest;
+import org.cloudfoundry.operations.services.BindServiceInstanceRequest;
+import org.cloudfoundry.operations.services.CreateServiceInstanceRequest;
+import org.cloudfoundry.operations.services.CreateUserProvidedServiceInstanceRequest;
+import org.cloudfoundry.operations.services.GetServiceInstanceRequest;
+import org.cloudfoundry.operations.services.ServiceInstance;
+import org.cloudfoundry.operations.services.UnbindServiceInstanceRequest;
+import org.cloudfoundry.operations.spaces.GetSpaceRequest;
+import org.cloudfoundry.operations.spaces.SpaceDetail;
+import org.cloudfoundry.reactor.tokenprovider.AbstractUaaTokenProvider;
+import org.cloudfoundry.uaa.UaaClient;
+import org.cloudfoundry.util.PaginationUtils;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.CFApplication;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.CFApplicationDetail;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.CFBuildpack;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.CFCloudDomain;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.CFServiceInstance;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.CFSpace;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.CFStack;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.SshClientSupport;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.SshHost;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.target.CFClientParams;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.v2.CancelationTokens.CancelationToken;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.v2.CloudFoundryClientCache.CFClientProvider;
+import org.springframework.ide.vscode.commons.util.ExceptionUtil;
+import org.springframework.util.StringUtils;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMap.Builder;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * @author Kris De Volder
+ * @author Nieraj Singh
+ */
+public class DefaultClientRequestsV2 implements ClientRequests {
+
+ private static final Duration APP_START_TIMEOUT = Duration.ofMillis(60*10);
+ private static final Duration GET_SERVICES_TIMEOUT = Duration.ofSeconds(60);
+ private static final Duration GET_SPACES_TIMEOUT = Duration.ofSeconds(20);
+ private static final Duration GET_USERNAME_TIMEOUT = Duration.ofSeconds(5);
+ private static final Logger logger = Logger.getLogger(DefaultClientRequestsV2.class.getName());
+ private static final boolean DEBUG = false;
+
+
+
+// static {
+// if (DEBUG_REACTOR) {
+// Loggers.enableExtension(new Extension() {
+// @Override
+// public void log(String category, java.util.logging.Level level, String msg, Object... arguments) {
+// debug(category +"["+level + "] : "+MessageFormatter.format(msg, arguments).getMessage());
+// }
+// });
+// }
+// }
+
+
+// TODO: it would be good not to create another 'threadpool' and use something like the below code
+// instead so that eclipse job scheduler is used for reactor 'tasks'. However... the code below
+// may not be 100% correct.
+// private static final Callable> SCHEDULER_GROUP = () -> {
+// return (Runnable task) -> {
+// Job job = new Job("CF Client background task") {
+// @Override
+// protected IStatus run(IProgressMonitor monitor) {
+// if (task!=null) {
+// task.run();
+// }
+// return Status.OK_STATUS;
+// }
+// };
+// job.setRule(JobUtil.lightRule("reactor-job-rule"));
+// job.setSystem(true);
+// job.schedule();
+// };
+// };
+
+
+ private CFClientParams params;
+ private CloudFoundryClient _client ;
+ private UaaClient _uaa;
+ private CloudFoundryOperations _operations;
+
+ private Mono orgId;
+ private Mono info;
+ private Mono spaceId;
+ private AbstractUaaTokenProvider _tokenProvider;
+
+ public DefaultClientRequestsV2(CloudFoundryClientCache clients, CFClientParams params) {
+ this.params = params;
+ CFClientProvider provider = clients.getOrCreate(params.getUsername(), params.getCredentials(), params.getHost(), params.skipSslValidation());
+ this._client = provider.client;
+ this._uaa = provider.uaaClient;
+ this._tokenProvider = (AbstractUaaTokenProvider) provider.tokenProvider;
+ this._operations = DefaultCloudFoundryOperations.builder()
+ .cloudFoundryClient(_client)
+ .dopplerClient(provider.doppler)
+ .uaaClient(provider.uaaClient)
+ .organization(params.getOrgName())
+ .space(params.getSpaceName())
+ .build();
+ this.orgId = getOrgId();
+ this.spaceId = getSpaceId();
+ this.info = client_getInfo().cache();
+ }
+
+ private Mono client_createOperations(OrganizationSummary org) {
+ return log("client.createOperations(org="+org.getName()+")",
+ Mono.fromCallable(() -> DefaultCloudFoundryOperations.builder()
+ .cloudFoundryClient(_client)
+ .organization(org.getName())
+ .build()
+ )
+ );
+ }
+
+ private Mono getOrgId() {
+ String orgName = params.getOrgName();
+ if (orgName==null) {
+ return Mono.error(new IOException("No organization targetted"));
+ } else {
+ return operations_getOrgId().cache();
+ }
+ }
+
+ private Mono getSpaceId() {
+ String spaceName = params.getSpaceName();
+ if (spaceName==null) {
+ return Mono.error(new IOException("No space targetted"));
+ } else {
+ return _operations.spaces().get(GetSpaceRequest.builder()
+ .name(params.getSpaceName())
+ .build()
+ )
+ .map(SpaceDetail::getId)
+ .cache();
+ }
+ }
+
+ @Override
+ public List getApplicationsWithBasicInfo() throws Exception {
+ return ReactorUtils.get(operations_listApps());
+ }
+
+ private ApplicationExtras getApplicationExtras(String appName) {
+ //Stuff used in computing the 'extras'...
+ Mono appIdMono = getApplicationId(appName);
+ Mono entity = appIdMono
+ .then((appId) ->
+ client_getApplication(appId)
+ )
+ .map((appResource) -> appResource.getEntity())
+ .cache();
+
+ //The stuff returned from the getters of 'extras'...
+ Mono> services = prefetch("services", getBoundServicesList(appName));
+ Mono> env = prefetch("env",
+ DefaultClientRequestsV2.this.getEnv(appName)
+ );
+ Mono buildpack = prefetch("buildpack",
+ entity.then((e) -> Mono.justOrEmpty(e.getBuildpack()))
+ );
+
+ Mono stack = prefetch("stack",
+ entity.then((e) -> Mono.justOrEmpty(e.getStackId()))
+ .then((stackId) -> {
+ return client_getStack(stackId);
+ }).map((response) -> {
+ return response.getEntity().getName();
+ })
+ );
+ Mono timeout = prefetch("timeout",
+ entity
+ .then((v) -> Mono.justOrEmpty(v.getHealthCheckTimeout()))
+ );
+
+ Mono command = prefetch("command",
+ entity.then((e) -> Mono.justOrEmpty(e.getCommand()))
+ );
+
+ Mono healthCheckType = prefetch("healthCheckType",
+ entity.then((e) -> Mono.justOrEmpty(e.getHealthCheckType()))
+ );
+
+ return new ApplicationExtras() {
+ @Override
+ public Mono> getServices() {
+ return services;
+ }
+
+ @Override
+ public Mono> getEnv() {
+ return env;
+ }
+
+ @Override
+ public Mono getBuildpack() {
+ return buildpack;
+ }
+
+ @Override
+ public Mono getStack() {
+ return stack;
+ }
+
+ public Mono getTimeout() {
+ return timeout;
+ }
+
+ @Override
+ public Mono getCommand() {
+ return command;
+ }
+
+ @Override
+ public Mono getHealthCheckType() {
+ return healthCheckType;
+ }
+ };
+ }
+
+ private Mono prefetch(String id, Mono toFetch) {
+ return toFetch
+// .log(id + " before error handler")
+ .otherwise((error) -> {
+ logger.log(Level.SEVERE,"Failed prefetch '"+id+"'", error);
+ return Mono.empty();
+ })
+// .log(id + " after error handler")
+ .cache()
+// .log(id + "after cache")
+ ;
+ }
+
+// private Mono prefetch(Mono toFetch) {
+// Mono result = toFetch
+// .cache(); // It should only be fetched once.
+//
+// //We must ensure the 'result' is being consumed by something to force its execution:
+// result
+// .publishOn(SCHEDULER_GROUP) //Ensure the consume is truly async or it may block here.
+// .consume((dont_care) -> {});
+//
+// return result;
+// }
+
+ @Override
+ public List getServices() throws Exception {
+ return ReactorUtils.get(GET_SERVICES_TIMEOUT, CancelationTokens.NULL,
+ log("operations.services.listInstances()",
+ _operations
+ .services()
+ .listInstances()
+ .map(CFWrappingV2::wrap)
+ .collectList()
+ .map(ImmutableList::copyOf)
+ )
+ );
+ }
+
+ /**
+ * Get details for a given list of applications. This does a 'best' effort getting the details for
+ * as many apps as possible but it does not guarantee that it will return details for each app in the
+ * list. This is to avoid one 'bad apple' from spoiling the whole batch. (I.e if failing to fetch details for
+ * some apps we can still return details for the others rather than throw an exception).
+ */
+ @Override
+ public Flux getApplicationDetails(List appsToLookUp) throws Exception {
+ return Flux.fromIterable(appsToLookUp)
+ .flatMap((CFApplication appSummary) -> {
+ return getApplicationDetail(appSummary.getName())
+ .otherwise((error) -> {
+ logger.log(Level.SEVERE,"getting application details for '"+appSummary.getName()+"' failed", error);
+
+ return Mono.empty();
+ })
+ .map((ApplicationDetail appDetails) -> CFWrappingV2.wrap((CFApplicationSummaryData)appSummary, appDetails));
+ });
+ }
+
+
+ /**
+ * Creates a retry 'signal factory' to be used with Flux.retryWhen.
+ *
+ * @param timeBetween How much time to wait before retrying after a failure
+ * @param duration If this much time has elapsed when the error happens there will be no further retries.
+ * @return Functon that can be passed to retryWhen.
+ */
+ private Function, Flux> retryInterval(Duration timeBetween, Duration duration) {
+ Predicate falseAfterDuration = falseAfter(duration);
+ return (errors) -> {
+ return errors.flatMap((error) -> {
+ if (falseAfterDuration.test(error)) {
+ return Mono.delay(timeBetween);
+ } else {
+ return Mono.error(error);
+ }
+ });
+ };
+ }
+
+ private Predicate falseAfter(Duration timeToWait) {
+ return new Predicate() {
+
+ private Long firstCalledAt;
+
+ @Override
+ public boolean test(Throwable t) {
+ if (firstCalledAt==null) {
+ firstCalledAt = System.currentTimeMillis();
+ }
+ long waitedTime = System.currentTimeMillis() - firstCalledAt;
+ //debug("falseAfter: remaining = "+(timeToWait.toMillis() - waitedTime));
+ return waitedTime < timeToWait.toMillis();
+ }
+
+ };
+ }
+
+ @Override
+ public void stopApplication(String appName) throws Exception {
+ ReactorUtils.get(
+ stopApp(appName)
+ );
+ }
+
+ private Mono stopApp(String appName) {
+ return log("operations.applications.stop(name="+appName+")",
+ _operations.applications().stop(StopApplicationRequest.builder()
+ .name(appName)
+ .build()
+ )
+ );
+ }
+
+ @Override
+ public void restartApplication(String appName, CancelationToken cancelationToken) throws Exception {
+ ReactorUtils.get(APP_START_TIMEOUT, cancelationToken,
+ restartApp(appName)
+ );
+ }
+
+ private Mono restartApp(String appName) {
+ return log("operations.applications().restart(name="+appName+")",
+ _operations.applications().restart(RestartApplicationRequest.builder()
+ .name(appName)
+ .build())
+ );
+ }
+
+ @Override
+ public void logout() {
+ _operations = null;
+ _client = null;
+ }
+
+ public boolean isLoggedOut() {
+ return _client==null;
+ }
+
+ @Override
+ public List getStacks() throws Exception {
+ return ReactorUtils.get(
+ log("operations.stacks().list()",
+ _operations.stacks()
+ .list()
+ .map(CFWrappingV2::wrap)
+ .collectList()
+ )
+ );
+ }
+
+ @Override
+ public SshClientSupport getSshClientSupport() throws Exception {
+ return new SshClientSupport() {
+
+ @Override
+ public String getSshUser(UUID appGuid, int instance) {
+ return "cf:"+appGuid+"/" + instance;
+ }
+
+ @Override
+ public String getSshUser(String appName, int instance) throws Exception {
+ return ReactorUtils.get(
+ getApplicationId(appName)
+ .map((guid) -> getSshUser(guid, instance))
+ );
+ }
+
+ @Override
+ public SshHost getSshHost() throws Exception {
+ return ReactorUtils.get(
+ info.then((i) -> {
+ String fingerPrint = i.getApplicationSshHostKeyFingerprint();
+ String host = i.getApplicationSshEndpoint();
+ int port = 22; //Default ssh port
+ if (host!=null) {
+ if (host.contains(":")) {
+ String[] pieces = host.split(":");
+ host = pieces[0];
+ port = Integer.parseInt(pieces[1]);
+ }
+ }
+ if (host!=null) {
+ return Mono.just(new SshHost(host, port, fingerPrint));
+ }
+ // Workaround for bug in Eclipse Neon.1 JDT cannot properly infer type SshHost.
+ // Works in Mars. Returning Mono.empty() results in compilation error in Neon.1
+ return Mono.empty();
+ })
+ );
+ }
+
+ @Override
+ public String getSshCode() throws Exception {
+ return ReactorUtils.get(
+ log("operations.advanced.sshCode()",
+ _operations.advanced().sshCode()
+ )
+ );
+ }
+ };
+ }
+
+ private Mono operationsFor(OrganizationSummary org) {
+ return client_createOperations(org);
+ }
+
+ @Override
+ public List getSpaces() throws Exception {
+ Object it = ReactorUtils.get(GET_SPACES_TIMEOUT, log("operations.organizations().list()",
+ _operations.organizations()
+ .list()
+ )
+ .flatMap((OrganizationSummary org) -> {
+ return operationsFor(org).flatMap((operations) ->
+ log("operations.spaces.list(org="+org.getId()+")",
+ operations
+ .spaces()
+ .list()
+ .map((space) -> CFWrappingV2.wrap(org, space))
+ )
+ );
+ })
+ .collectList()
+ );
+ //workaround eclipse jdt bug: https://bugs.eclipse.org/bugs/show_bug.cgi?id=501949
+ return (List) it;
+ }
+
+ @Override
+ public String getHealthCheck(UUID appGuid) throws Exception {
+ //XXX CF V2: getHealthcheck (via operations API)
+ // See: https://www.pivotaltracker.com/story/show/116462215
+ return ReactorUtils.get(
+ client_getApplication(appGuid)
+ .map((response) -> response.getEntity().getHealthCheckType())
+ );
+ }
+
+ @Override
+ public void setHealthCheck(UUID guid, String hcType) throws Exception {
+ //XXX CF V2: setHealthCheck (via operations API)
+ // See: https://www.pivotaltracker.com/story/show/116462369
+ ReactorUtils.get(
+ client_setHealthCheck(guid, hcType)
+ );
+ }
+
+ @Override
+ public List getDomains() throws Exception {
+ //XXX CF V2: list domains using 'operations' api.
+ return ReactorUtils.get(Duration.ofMinutes(2),
+ orgId.flatMap(this::requestDomains)
+ .map(CFWrappingV2::wrap)
+ .collectList()
+ );
+ }
+
+ private Flux requestDomains(String orgId) {
+ return PaginationUtils.requestClientV2Resources((page) ->
+ client_listDomains(page)
+ );
+ }
+
+ @Override
+ public List getBuildpacks() throws Exception {
+ //XXX CF V2: getBuilpacks using 'operations' API.
+ return ReactorUtils.get(
+ PaginationUtils.requestClientV2Resources((page) -> {
+ return client_listBuildpacks(page);
+ })
+ .map(CFWrappingV2::wrap)
+ .collectList()
+ );
+ }
+
+ @Override
+ public CFApplicationDetail getApplication(String appName) throws Exception {
+ return ReactorUtils.get(
+ getApplicationMono(appName)
+ // .log("getApplication("+appName+")")
+ );
+ }
+
+ private Mono getApplicationMono(String appName) {
+ return getApplicationDetail(appName)
+ .map((appDetail) -> {
+ //TODO: we have 'real' appdetails now so we could get most of the 'application extras' info from that.
+ return CFWrappingV2.wrap(appDetail, getApplicationExtras(appName));
+ })
+ .otherwise(ReactorUtils.suppressException(IllegalArgumentException.class));
+ }
+
+
+ @Override
+ public void deleteApplication(String appName) throws Exception {
+ ReactorUtils.get(
+ log("operations.applications().delete(name="+appName+")",
+ _operations.applications().delete(DeleteApplicationRequest
+ .builder()
+ .name(appName)
+ .build()
+ )
+ )
+ );
+ }
+
+ @Override
+ public boolean applicationExists(String appName) throws Exception {
+ return ReactorUtils.get(
+ getApplicationMono(appName)
+ .map((app) -> true)
+ .otherwiseIfEmpty(Mono.just(false))
+ );
+ }
+
+ public Mono ifApplicationExists(String appName, Function> then, Mono els) throws Exception {
+ return getApplicationDetail(appName)
+ .map((app) -> Optional.of(app))
+ .otherwiseIfEmpty(Mono.just(Optional.empty()))
+ .otherwise((error) -> Mono.just(Optional.empty()))
+ .then((Optional app) -> {
+ if (app.isPresent()) {
+ return then.apply(app.get());
+ } else {
+ return els;
+ }
+ });
+ }
+
+ @Override
+ public void push(CFPushArguments params, CancelationToken cancelationToken) throws Exception {
+ String appName = params.getAppName();
+ ReactorUtils.get(APP_START_TIMEOUT, cancelationToken,
+ ifApplicationExists(appName,
+ ((app) -> pushExisting(app, params)),
+ firstPush(params)
+ )
+ );
+ }
+
+ private Mono pushExisting(ApplicationDetail app, CFPushArguments params) {
+ String appName = params.getAppName();
+ UUID appId = UUID.fromString(app.getId());
+ return updateApp(appId, params)
+ .then(getApplicationDetail(appName))
+ .then((appDetail) -> {
+ return Flux.merge(
+ setRoutes(appDetail, params.getRoutes()),
+ bindAndUnbindServices(appName, params.getServices())
+ ).then();
+ })
+ .then(mono_debug("Uploading[1]..."))
+ .then(Mono.fromCallable(() -> {
+ debug("Uploading[2]...");
+// v1().uploadApplication(appName, params.getApplicationData());
+ debug("Uploading[2] DONE");
+ return "who cares";
+ }))
+ .then(mono_debug("Uploading[1] DONE"))
+ .then(params.isNoStart()
+ ? stopApp(appName)
+ : restartApp(appName)
+ );
+ }
+
+// private DefaultClientRequestsV1 v1() throws Exception {
+// if (_v1==null) {
+// CFClientParams v1params = new CFClientParams(
+// params.getApiUrl(),
+// params.getUsername(),
+// CFCredentials.fromRefreshToken(getRefreshToken()),
+// params.isSelfsigned(),
+// params.getOrgName(),
+// params.getSpaceName(),
+// params.skipSslValidation()
+// );
+// _v1 = new DefaultClientRequestsV1(v1params);
+// }
+// return _v1;
+// }
+
+ private Mono mono_debug(String string) {
+ return Mono.fromRunnable(() -> debug(string));
+ }
+
+ private Mono firstPush(CFPushArguments params) {
+ String appName = params.getAppName();
+ return createApp(params)
+ .then(getApplicationDetail(appName))
+ .then((appDetail) ->
+ Flux.merge(
+ setRoutes(appDetail, params.getRoutes()),
+ bindAndUnbindServices(appName, params.getServices())
+ ).then()
+ )
+ .then(Mono.fromCallable(() -> {
+// v1().uploadApplication(appName, params.getApplicationData());
+ return "who cares";
+ }))
+ .then(params.isNoStart()
+ ? Mono.empty()
+ : startApp(appName)
+ )
+ .then();
+ }
+
+ private Mono createApp(CFPushArguments params) {
+ return spaceId.and(getStackId(params))
+ .then(function((spaceId, stackId) -> {
+ CreateApplicationRequest req = CreateApplicationRequest.builder()
+ .spaceId(spaceId)
+ .stackId(stackId.orElse(null))
+ .name(params.getAppName())
+ .memory(params.getMemory())
+ .diskQuota(params.getDiskQuota())
+ .healthCheckType(params.getHealthCheckType())
+ .healthCheckTimeout(params.getTimeout())
+ .buildpack(params.getBuildpack())
+ .command(params.getCommand())
+ .environmentJsons(params.getEnv())
+ .instances(params.getInstances())
+ .build();
+ return log("client.applications.create("+req+")",
+ _client.applicationsV2().create(req)
+ );
+ }))
+ .map(response -> UUID.fromString(response.getMetadata().getId()));
+ }
+
+ private Mono> getStackId(CFPushArguments params) {
+ String stackName = params.getStack();
+ if (stackName==null) {
+ return Mono.just(Optional.empty());
+ } else {
+ return log("operations.stacks.get("+stackName+")",
+ _operations.stacks().get(org.cloudfoundry.operations.stacks.GetStackRequest.builder()
+ .name(stackName)
+ .build()
+ )
+ .map((stack) -> Optional.of(stack.getId()))
+ );
+ }
+ }
+
+
+ private Mono updateApp(UUID appId, CFPushArguments params) {
+ return getStackId(params)
+ .then((stackId) -> {
+ UpdateApplicationRequest req = UpdateApplicationRequest.builder()
+ .applicationId(appId.toString())
+ .name(params.getAppName())
+ .memory(params.getMemory())
+ .diskQuota(params.getDiskQuota())
+ .healthCheckType(params.getHealthCheckType())
+ .healthCheckTimeout(params.getTimeout())
+ .buildpack(params.getBuildpack())
+ .command(params.getCommand())
+ .stackId(stackId.orElse(null))
+ .environmentJsons(params.getEnv())
+ .instances(params.getInstances())
+ .build();
+ return log("client.applications.update("+req+")",
+ _client.applicationsV2().update(req)
+ );
+ })
+ .then(Mono.just(appId));
+ }
+
+// public void pushV2(CFPushArguments params, CancelationToken cancelationToken) throws Exception {
+// debug("Pushing app starting: "+params.getAppName());
+// //XXX CF V2: push should use 'manifest' in a future version of V2
+// PushApplicationRequest pushRequest = toPushRequest(params)
+// .noStart(true)
+// .noRoute(true)
+// .build();
+// ReactorUtils.get(APP_START_TIMEOUT, cancelationToken,
+// log("operations.applications().push("+pushRequest+")",
+// _operations.applications()
+// .push(pushRequest)
+// )
+// .then(getApplicationDetail(params.getAppName()))
+// .then(appDetail -> {
+// return Flux.merge(
+// setRoutes(appDetail, params.getRoutes()),
+// setEnvVars(appDetail, params.getEnv()),
+// bindAndUnbindServices(params.getAppName(), params.getServices())
+// )
+// .then();
+// })
+// .then(() -> {
+// if (!params.isNoStart()) {
+// return startApp(params.getAppName());
+// } else {
+// return Mono.empty();
+// }
+// })
+// );
+// debug("Pushing app succeeded: "+params.getAppName());
+// }
+
+ private Mono getApplicationDetail(String appName) {
+ return log("operations.applications.get(name="+appName+")",
+ _operations.applications().get(GetApplicationRequest.builder()
+ .name(appName)
+ .build()
+ )
+ );
+ }
+
+ public Mono setRoutes(ApplicationDetail appDetails, Collection desiredUrls) {
+ debug("setting routes for '"+appDetails.getName()+"': "+desiredUrls);
+
+ //Carefull! It is not safe map/unnmap multiple routes in parallel. Doing so causes some of the
+ // operations to fail, presumably because of some 'optimisitic locking' being used in the database
+ // that keeps track of routes.
+ //To avoid this problem we must execute all that map / unmap calls in sequence!
+ return ReactorUtils.sequence(
+ unmapUndesiredRoutes(appDetails.getName(), desiredUrls),
+ mapDesiredRoutes(appDetails, desiredUrls)
+ );
+ }
+
+ public Mono setRoutes(String appName, Collection desiredUrls) {
+ return getApplicationDetail(appName)
+ .then(appDetails -> setRoutes(appDetails, desiredUrls));
+ }
+
+ private Mono mapDesiredRoutes(ApplicationDetail appDetail, Collection desiredUrls) {
+ Set currentUrls = ImmutableSet.copyOf(appDetail.getUrls());
+ Mono> domains = getDomainNames().cache();
+ String appName = appDetail.getName();
+
+ debug("currentUrls = "+currentUrls);
+ return Flux.fromIterable(desiredUrls)
+ .flatMap((url) -> {
+ if (currentUrls.contains(url)) {
+ debug("skipping: "+url);
+ return Mono.empty();
+ } else {
+ debug("mapping: "+url);
+ return mapRoute(domains, appName, url);
+ }
+ }, 1) //!!!IN SEQUENCE!!!
+ .then();
+ }
+
+ private Mono mapRoute(Mono> domains, String appName, String desiredUrl) {
+ debug("mapRoute: "+appName+" -> "+desiredUrl);
+ return toRoute(domains, desiredUrl)
+ .then((CFRoute route) -> mapRoute(appName, route))
+ .doOnError((e) -> {
+ logger.info("mapRoute FAILED!");
+ });
+ }
+
+ private Mono mapRoute(String appName, CFRoute route) {
+ MapRouteRequest mapRouteReq = MapRouteRequest.builder()
+ .applicationName(appName)
+ .domain(route.getDomain())
+ .host(route.getHost())
+ .path(route.getPath())
+ .build();
+ return log("operations.routes.map("+mapRouteReq+")",
+ _operations.routes().map(mapRouteReq)
+ );
+ }
+
+ private Mono toRoute(Mono> domains, String desiredUrl) {
+ return domains.then((ds) -> {
+ for (String d : ds) {
+ //TODO: we assume that there's no 'path' component for now, which simpiflies things. What if there is a path component?
+ if (desiredUrl.endsWith(d)) {
+ String host = desiredUrl.substring(0, desiredUrl.length()-d.length());
+ while (host.endsWith(".")) {
+ host = host.substring(0, host.length()-1);
+ }
+ CFRoute.Builder route = CFRoute.builder();
+ route.domain(d);
+ if (StringUtils.hasText(host)) {
+ route.host(host);
+ }
+ return Mono.just(route.build());
+ }
+ }
+ return Mono.error(new IOException("Couldn't find a domain matching "+desiredUrl));
+ });
+ }
+
+ private Mono> getDomainNames() {
+ return orgId.flatMap(this::requestDomains)
+ .map((r) -> r.getEntity().getName())
+ .collectList()
+ .map(ImmutableSet::copyOf);
+ }
+
+// private Set getUrls(ApplicationDetail app) {
+// return operations.applications().get(GetApplicationRequest.builder()
+// .name(appName)
+// .build()
+// )
+// .map((app) -> ImmutableSet.copyOf(app.getUrls()));
+// }
+
+ private Mono unmapUndesiredRoutes(String appName, Collection desiredUrls) {
+ return getExistingRoutes(appName)
+ .flatMap((route) -> {
+ debug("unmap? "+route);
+ if (desiredUrls.contains(getUrl(route))) {
+ debug("unmap? "+route+" SKIP");
+ return Mono.empty();
+ } else {
+ debug("unmap? "+route+" UNMAP");
+ return unmapRoute(appName, route);
+ }
+ }, 1) //!!!IN SEQUENCE!!!
+ .then();
+ }
+
+ private String getUrl(CFRoute route) {
+ String url = route.getDomain();
+ if (route.getHost()!=null) {
+ url = route.getHost() + "." + url;
+ }
+ String path = route.getPath();
+ if (path!=null) {
+ while (path.startsWith("/")) {
+ path = path.substring(1);
+ }
+ if (StringUtils.hasText(path)) {
+ url = url +"/" +path;
+ }
+ }
+ return url;
+ }
+
+ private Mono unmapRoute(String appName, CFRoute route) {
+ String path = route.getPath();
+// if (!StringUtil.hasText(path)) {
+// //client doesn't like to get 'empty string' it will complain that route doesn't exist.
+// path = null;
+// }
+ UnmapRouteRequest req = UnmapRouteRequest.builder()
+ .applicationName(appName)
+ .domain(route.getDomain())
+ .host(route.getHost())
+ .path(path)
+ .build();
+ return log("operations.routes.unmap("+req+")",
+ _operations.routes().unmap(req)
+ );
+ }
+
+ public Flux getExistingRoutes(String appName) {
+ return log("operations.routes.list(level=SPACE)",
+ _operations.routes().list(ListRoutesRequest.builder()
+ .level(org.cloudfoundry.operations.routes.Level.SPACE)
+ .build()
+ )
+ )
+ .flatMap((route) -> {
+ for (String app : route.getApplications()) {
+ if (app.equals(appName)) {
+ return Mono.just(new CFRoute(route));
+ }
+ };
+ return Mono.empty();
+ });
+ }
+
+// private static PushApplicationRequest.Builder toPushRequest(CFPushArguments params) {
+// return PushApplicationRequest.builder()
+// .name(params.getAppName())
+// .memory(params.getMemory())
+// .diskQuota(params.getDiskQuota())
+// .timeout(params.getTimeout())
+// .buildpack(params.getBuildpack())
+// .command(params.getCommand())
+// .stack(params.getStack())
+// .instances(params.getInstances())
+// .application(params.getApplicationData());
+// }
+
+ public Mono bindAndUnbindServices(String appName, List _services) {
+ debug("bindAndUnbindServices "+_services);
+ Set services = ImmutableSet.copyOf(_services);
+ return getBoundServicesSet(appName)
+ .flatMap((boundServices) -> {
+ debug("boundServices = "+boundServices);
+ Set toUnbind = Sets.difference(boundServices, services);
+ Set toBind = Sets.difference(services, boundServices);
+ debug("toBind = "+toBind);
+ debug("toUnbind = "+toUnbind);
+ return Flux.merge(
+ bindServices(appName, toBind),
+ unbindServices(appName, toUnbind)
+ );
+ })
+ .then();
+ }
+
+ public Flux getBoundServices(String appName) {
+ return log("operations.services.listInstances()",
+ _operations.services().listInstances()
+ )
+ .filter((service) -> isBoundTo(service, appName))
+ .map(ServiceInstance::getName);
+ }
+
+ public Mono> getBoundServicesSet(String appName) {
+ return getBoundServices(appName)
+ .collectList()
+ .map(ImmutableSet::copyOf);
+ }
+
+ public Mono> getBoundServicesList(String appName) {
+ return getBoundServices(appName)
+ .collectList()
+ .map(ImmutableList::copyOf);
+ }
+
+ private boolean isBoundTo(ServiceInstance service, String appName) {
+ return service.getApplications().stream()
+ .anyMatch((boundAppName) -> boundAppName.equals(appName));
+ }
+
+ private Flux bindServices(String appName, Set services) {
+ return Flux.fromIterable(services)
+ .flatMap((service) -> {
+ return log("operations.services().bind(appName="+appName+", services="+services+")",
+ _operations.services().bind(BindServiceInstanceRequest.builder()
+ .applicationName(appName)
+ .serviceInstanceName(service)
+ .build()
+ )
+ );
+ });
+ }
+
+ private Flux unbindServices(String appName, Set toUnbind) {
+ return Flux.fromIterable(toUnbind)
+ .flatMap((service) -> {
+ return log("operations.services.unbind(appName="+appName+", serviceInstanceName="+service+")",
+ _operations.services().unbind(UnbindServiceInstanceRequest.builder()
+ .applicationName(appName)
+ .serviceInstanceName(service)
+ .build()
+ )
+ );
+ });
+ }
+
+
+ protected Mono startApp(String appName) {
+ return log("operations.applications.start(name="+appName+")",
+ _operations.applications()
+ .start(StartApplicationRequest.builder()
+ .name(appName)
+ .build()
+ )
+ );
+ }
+
+ private Mono getApplicationId(String appName) {
+ return log("operations.applications.get(name="+appName+")",
+ _operations.applications().get(GetApplicationRequest.builder()
+ .name(appName)
+ .build()
+ )
+ ).map((app) -> UUID.fromString(app.getId()));
+ }
+
+ public Mono setEnvVars(ApplicationDetail appDetail, Map environment) {
+ return setEnvVars(UUID.fromString(appDetail.getId()), environment);
+ }
+
+ public Mono setEnvVars(UUID appId, Map environment) {
+ return client_setEnv(appId, environment);
+ }
+
+ public Mono setEnvVars(String appName, Map environment) {
+ return getApplicationId(appName)
+ .then((applicationId) -> setEnvVars(applicationId, environment));
+ }
+
+// protected Publisher setEnvVar(String appName, String var, String value) {
+// System.out.println("Set var starting: "+var +" = "+value);
+// return operations.applications()
+// .setEnvironmentVariable(SetEnvironmentVariableApplicationRequest.builder()
+// .name(appName)
+// .variableName(var)
+// .variableValue(value)
+// .build()
+// )
+// .after(() -> {
+// System.out.println("Set var complete: "+var +" = "+value);
+// return Mono.empty();
+// });
+// }
+
+ public Mono createService(String name, String service, String plan) {
+ return log("operations.services.createInstance(instanceName="+name+",serviceName="+service+",planName="+plan+")",
+ _operations.services().createInstance(CreateServiceInstanceRequest.builder()
+ .serviceInstanceName(name)
+ .serviceName(service)
+ .planName(plan)
+ .build()
+ )
+ );
+ }
+
+ public Mono createUserProvidedService(String name, Map credentials) {
+ return log("operations.services.createUserProvidedInstance(name="+name+")",
+ _operations.services().createUserProvidedInstance(CreateUserProvidedServiceInstanceRequest.builder()
+ .name(name)
+ .credentials(credentials)
+ .build()
+ )
+ );
+ }
+
+// @Override
+// public void deleteService(String serviceName) {
+// deleteServiceMono(serviceName).get();
+// }
+
+ @Override
+ public Mono deleteServiceAsync(String serviceName) {
+ return getService(serviceName)
+ .then(this::deleteServiceInstance);
+ }
+
+ protected Mono deleteServiceInstance(ServiceInstance s) {
+ switch (s.getType()) {
+ case MANAGED:
+ return client_deleteServiceInstance(s);
+ case USER_PROVIDED:
+ return client_deleteUserProvidedService(s);
+ default:
+ return Mono.error(new IllegalStateException("Unknown service type: "+s.getType()));
+ }
+ }
+
+ protected Mono getService(String serviceName) {
+ return log("operations.services.getInstance(name="+serviceName+")",
+ _operations.services().getInstance(GetServiceInstanceRequest.builder()
+ .name(serviceName)
+ .build()
+ )
+ );
+ }
+
+ public Mono> getEnv(String appName) {
+ return log("operations.applications.getEnvironments(appName="+appName+")",
+ _operations.applications().getEnvironments(GetApplicationEnvironmentsRequest.builder()
+ .name(appName)
+ .build()
+ )
+ )
+ .map((envs) -> envs.getUserProvided())
+ .map(this::dropObjectsFromMap);
+ }
+
+ @Override
+ public Map getApplicationEnvironment(String appName) throws Exception {
+ return ReactorUtils.get(getEnv(appName));
+ }
+
+ private Map dropObjectsFromMap(Map map) {
+ Builder builder = ImmutableMap.builder();
+ for (Entry entry : map.entrySet()) {
+ try {
+ builder.put(entry.getKey(), (String) entry.getValue());
+ } catch (ClassCastException e) {
+ logger.log(Level.SEVERE,e.getMessage(), e);
+
+ }
+ }
+ return builder.build();
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////
+ //// calls to client and operations with 'logging'.
+
+ private Flux log(String msg, Flux flux) {
+ if (DEBUG) {
+ return flux
+ .doOnSubscribe((sub) -> debug(">>> "+msg))
+ .doOnComplete(() -> {
+ debug("<<< "+msg+" OK");
+ })
+ .doOnCancel(() -> {
+ debug("<<< "+msg+" CANCEL");
+ })
+ .doOnError((error) -> {
+ debug("<<< "+msg+" ERROR: "+ExceptionUtil.getMessage(error));
+ });
+ } else {
+ return flux;
+ }
+ }
+
+ private Mono log(String msg, Mono mono) {
+ if (DEBUG) {
+ return mono
+ .doOnSubscribe((sub) -> debug(">>> "+msg))
+ .doOnCancel(() -> debug("<<< "+msg+" CANCEL"))
+ .doOnSuccess((data) -> {
+ debug("<<< "+msg+" OK");
+ })
+ .doOnError((error) -> {
+ debug("<<< "+msg+" ERROR: "+ExceptionUtil.getMessage(error));
+ });
+ } else {
+ return mono;
+ }
+ }
+
+ private void debug(String string) {
+ // TODO Auto-generated method stub
+
+ }
+
+ private Mono client_getInfo() {
+ return log("client.info().get()",
+ _client.info().get(GetInfoRequest.builder().build())
+ );
+ }
+
+ private Mono operations_getOrgId() {
+ return log("operations.organizations.get(name="+params.getOrgName()+")",
+ _operations.organizations().get(OrganizationInfoRequest.builder()
+ .name(params.getOrgName())
+ .build()
+ )
+ .map(OrganizationDetail::getId)
+ );
+ }
+
+ private Mono> operations_listApps() {
+ return log("operations.applications.list()",
+ _operations.applications()
+ .list()
+ .map((appSummary) ->
+ CFWrappingV2.wrap(appSummary, getApplicationExtras(appSummary.getName()))
+ )
+ .collectList()
+ .map(ImmutableList::copyOf)
+ );
+ }
+
+ private Mono client_getApplication(UUID appId) {
+ return log("client.applicationsV2.get(id="+appId+")",
+ _client.applicationsV2()
+ .get(org.cloudfoundry.client.v2.applications.GetApplicationRequest.builder()
+ .applicationId(appId.toString())
+ .build()
+ )
+ );
+ }
+
+ private Mono client_getStack(String stackId) {
+ return log("client.stacks.get(id="+stackId+")",
+ _client.stacks().get(GetStackRequest.builder()
+ .stackId(stackId)
+ .build()
+ )
+ );
+ }
+
+ private Mono client_setHealthCheck(UUID guid, String hcType) {
+ return log("client.applicationsV2.update(id="+guid+", hcType="+hcType+")",
+ _client.applicationsV2()
+ .update(UpdateApplicationRequest.builder()
+ .applicationId(guid.toString())
+ .healthCheckType(hcType)
+ .build()
+ )
+ );
+ }
+
+ private Mono client_listDomains(Integer page) {
+ return log("client.domains.list(page="+page+")",
+ _client.domains().list(ListDomainsRequest.builder()
+ .page(page)
+ // .owningOrganizationId(orgId)
+ .build()
+ )
+ );
+ }
+
+ private Mono client_listBuildpacks(Integer page) {
+ return log("client.buildpacks.list(page="+page+")",
+ _client.buildpacks()
+ .list(ListBuildpacksRequest.builder()
+ .page(page)
+ .build()
+ )
+ );
+ }
+
+ private Mono client_setEnv(UUID appId, Map environment) {
+ return log("client.applicationsV2.update(id="+appId+", env=...)",
+ _client.applicationsV2()
+ .update(UpdateApplicationRequest.builder()
+ .applicationId(appId.toString())
+ .environmentJsons(environment)
+ .build())
+ .then()
+ );
+ }
+
+ private Mono client_deleteServiceInstance(ServiceInstance s) {
+ return log("client.serviceInstances.delete(id="+s.getId()+")",
+ _client.serviceInstances().delete(DeleteServiceInstanceRequest.builder()
+ .serviceInstanceId(s.getId())
+ .build()
+ )
+ .then()
+ );
+ }
+
+ private Mono client_deleteUserProvidedService(ServiceInstance s) {
+ return log("client.userProvidedServiceInstances.delete(id="+s.getId()+")",
+ _client.userProvidedServiceInstances().delete(DeleteUserProvidedServiceInstanceRequest.builder()
+ .userProvidedServiceInstanceId(s.getId())
+ .build()
+ )
+ );
+ }
+
+ @Override
+ public String getRefreshToken() {
+ return _tokenProvider.getRefreshToken();
+ }
+
+ @Override
+ public Mono getUserName() {
+ return log("uaa.getUsername",
+ _uaa.getUsername()
+ ).timeout(GET_USERNAME_TIMEOUT);
+ }
+
+}
diff --git a/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/DefaultCloudFoundryClientFactoryV2.java b/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/DefaultCloudFoundryClientFactoryV2.java
new file mode 100644
index 000000000..312f69f0a
--- /dev/null
+++ b/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/DefaultCloudFoundryClientFactoryV2.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.commons.cloudfoundry.client.v2;
+
+import org.springframework.ide.vscode.commons.cloudfoundry.client.target.CFClientParams;
+
+public class DefaultCloudFoundryClientFactoryV2 implements CloudFoundryClientFactory {
+
+ public static final CloudFoundryClientFactory INSTANCE = new DefaultCloudFoundryClientFactoryV2();
+
+ /**
+ * Use 'INSTANCE' constant instead. This class is a singleton.
+ */
+ private DefaultCloudFoundryClientFactoryV2() {}
+
+ private CloudFoundryClientCache cache = new CloudFoundryClientCache();
+
+ /* (non-Javadoc)
+ * @see org.springframework.ide.vscode.commons.cloudfoundry.client.v2.CloudFoundryClientFactory#getClient(org.springframework.ide.vscode.commons.cloudfoundry.client.target.CFClientParams)
+ */
+ @Override
+ public ClientRequests getClient(CFClientParams params) throws Exception {
+ return new DefaultClientRequestsV2(cache, params);
+ }
+}
diff --git a/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/DeploymentProperties.java b/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/DeploymentProperties.java
new file mode 100644
index 000000000..65cd42ebf
--- /dev/null
+++ b/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/DeploymentProperties.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.commons.cloudfoundry.client.v2;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Interface for Cloud Foundry application deployment properties
+ *
+ * @author Alex Boyko
+ *
+ */
+public interface DeploymentProperties {
+
+ int DEFAULT_MEMORY = 1024;
+ int DEFAULT_INSTANCES = 1;
+ String DEFAULT_HEALTH_CHECK_TYPE = "port";
+
+ String getAppName();
+
+ int getMemory();
+
+ int getDiskQuota();
+
+ Integer getTimeout();
+
+ String getHealthCheckType();
+
+ String getBuildpack();
+
+ String getCommand();
+
+ String getStack();
+
+ Map getEnvironmentVariables();
+
+ int getInstances();
+
+ List getServices();
+
+ Set getUris();
+
+}
diff --git a/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/ReactorUtils.java b/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/ReactorUtils.java
new file mode 100644
index 000000000..aaec46eca
--- /dev/null
+++ b/vscode-extensions/commons/commons-cf/src/main/java/org/springframework/ide/vscode/commons/cloudfoundry/client/v2/ReactorUtils.java
@@ -0,0 +1,295 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.commons.cloudfoundry.client.v2;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
+
+import org.reactivestreams.Publisher;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.v2.CancelationTokens.CancelationToken;
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Schedulers;
+import reactor.util.function.Tuple2;
+import reactor.util.function.Tuples;
+
+/**
+ * @author Kris De Volder
+ */
+public class ReactorUtils {
+
+ private static final Duration DEFAULT_TIMEOUT = Duration.ofSeconds(45); // reflects default timeout of Mono.block in reactor 2.x.
+ public static boolean DUMP_STACK_ON_TIMEOUT = false;
+
+ // TODO: uncommented when cancellation is handled in vscode
+// /**
+// * Convert a {@link CancelationToken} into a Mono that raises
+// * an {@link OperationCanceledException} when the token is canceled.
+// */
+// public static Mono toMono(CancelationToken cancelToken) {
+// return Mono.delay(Duration.ofSeconds(1))
+// .then((ping) ->
+// cancelToken.isCanceled()
+// ? Mono.error(new OperationCanceledException())
+// : Mono.empty()
+// )
+// .repeatWhenEmpty((x) -> x);
+// }
+
+ /**
+ * Similar to Mono.get but logs a more traceable version of the exception to Eclipse's error
+ * log before 'rethrowing' it.
+ *
+ * This is useful because the actual exception is pretty hard to trace. It doesn't even 'point'
+ * to the line where 'get' was called.
+ */
+ public static T get(Mono mono) throws Exception {
+ try {
+ return mono.block(DEFAULT_TIMEOUT);
+ } catch (Exception e) {
+ dumpStacks();
+ throw new IOException(e);
+ }
+ }
+
+ /**
+ * Similar to Mono.get but logs a more traceable version of the exception to Eclipse's error
+ * log before 'rethrowing' it.
+ *
+ * This is useful because the actual exception is pretty hard to trace. It doesn't even 'point'
+ * to the line where 'get' was called.
+ */
+ public static T get(Duration timeout, CancelationToken cancelationToken, Mono mono) throws Exception {
+ try {
+ return mono
+ // TODO: uncomment when cancellation properly supported in vscode
+// Mono
+// .first(mono,
+// toMono(cancelationToken))
+// .otherwise(errorFilter(cancelationToken))
+ .block(timeout);
+ } catch (Exception e) {
+ dumpStacks();
+ throw new IOException(e);
+ }
+ }
+
+
+ public static List get(Duration t, Mono> m) throws IOException {
+ try {
+ return m.block(t);
+ } catch (Exception e) {
+ dumpStacks();
+ throw new IOException(e);
+ }
+ }
+
+ private static void dumpStacks() {
+ if (DUMP_STACK_ON_TIMEOUT) {
+ System.out.println(getStackDumps().toString());
+ }
+ }
+
+ /**
+ * A 'filter' to use as a Mono.otherwise hanlder. It transforms any exception into {@link OperationCanceledException}
+ * when cancelationToken has been canceled.
+ */
+ private static Function> errorFilter(CancelationToken cancelationToken) {
+// return (Throwable e) -> cancelationToken.isCanceled()?Mono.error(new OperationCanceledException()):Mono.error(e);
+ return (Throwable e) -> Mono.error(e);
+
+ }
+
+ /**
+ * Deprecated because this is really the same as Mono.justOrEmpty, so use that instead.
+ */
+ @Deprecated
+ public static Mono just(T it) {
+ return it == null ? Mono.empty() : Mono.just(it);
+ }
+
+ /**
+ * @return A function that can be passed to Mono.otherwise to convert a specific exception type into
+ * Mono.empty().
+ */
+ public static Function> suppressException(Class exceptionType) {
+ return (Throwable caught) -> {
+ if (exceptionType.isAssignableFrom(caught.getClass())) {
+ return Mono.empty();
+ } else {
+ return Mono.error(caught);
+ }
+ };
+ }
+
+ /**
+ * Build a Mono that executes a given number of Mono one after the
+ * other.
+ */
+ @SafeVarargs
+ public static Mono sequence(Mono... tasks) {
+ Mono seq = Mono.empty();
+ for (Mono t : tasks) {
+ seq = seq.then(t);
+ }
+ return seq;
+ }
+
+ /**
+ * Execute a bunch of mono in parallel. All monos are executed to completion (rather than canceled early
+ * when one of them fails)
+ *
+ * When at least one operation has failed then, upon completion or failure of the last Mono we guarantee that at least
+ * one of the exceptions is propagated.
+ */
+ public static Mono safeMerge(Flux> operations, int concurrency) {
+ AtomicReference failure = new AtomicReference<>(null);
+ return Flux.merge(
+ operations
+ .map((Mono op) -> {
+ return op.otherwise((e) -> {
+ failure.compareAndSet(null, e);
+ return Mono.empty();
+ });
+ }),
+ concurrency //limit concurrency otherwise troubles (flooding/choking request broker?)
+ )
+ .then(() -> {
+ Throwable error = failure.get();
+ if (error!=null) {
+ return Mono.error(error);
+ } else {
+ return Mono.empty();
+ }
+ });
+ }
+
+ /**
+ * Attach a timestamp to each element in a Stream
+ */
+ public static Flux> timestamp(Flux stream) {
+ return stream.map((e) -> Tuples.of(e, System.currentTimeMillis()));
+ }
+
+ /**
+ * Sorts the elements in a flux in a moving time window. I.e. this assumes element order may be
+ * scrambled but the scrambling has a certain 'time localilty' to it. So we only need to consider
+ * sorting of elements that arrive 'close to eachother'.
+ *
+ * WARNING: The returned flux is intended for a single subscriber. It only maintains a
+ * single buffer for sorting stream elements. This buffer is consumed when elements
+ * are released to any subscriber. Therefore if one subscriber received a element it is gone
+ * from the buffer and will not be delivered to the other subscribers.
+ *
+ * @param stream The stream to be sorted
+ * @param comparator Compare function to sort with
+ * @param bufferTime The 'window' of time beyond which we don't need to compare elements.
+ */
+ public static Flux sort(Flux stream, Comparator comparator, Duration bufferTime) {
+
+ class SorterAccumulator {
+
+ final PriorityQueue> holdingPen = new PriorityQueue<>((Tuple2 o1, Tuple2 o2) -> {
+ return comparator.compare(o1.getT1(), o2.getT1());
+ });
+
+ final Flux released = Flux.fromIterable(() -> new Iterator() {
+ @Override
+ public boolean hasNext() {
+ Tuple2 nxt;
+ synchronized (holdingPen) {
+ nxt = holdingPen.peek();
+ }
+ return nxt!=null && isOldEnough(nxt);
+ }
+
+ private boolean isOldEnough(Tuple2 nxt) {
+ long age = System.currentTimeMillis() - nxt.getT2();
+ return age > bufferTime.toMillis();
+ }
+
+ @Override
+ public T next() {
+ synchronized (holdingPen) {
+ return holdingPen.remove().getT1();
+ }
+ }
+ });
+
+ public SorterAccumulator next(Flux> window) {
+ window.subscribe((e) -> {
+ synchronized (holdingPen) {
+ holdingPen.add(e);
+ }
+ });
+ return this;
+ }
+
+ public Flux getReleased() {
+ return released;
+ }
+
+ public Publisher drain() {
+ return Flux.fromIterable(holdingPen)
+ .map(Tuple2::getT1);
+ }
+ }
+
+ SorterAccumulator sorter = new SorterAccumulator();
+ return timestamp(stream)
+ .window(bufferTime)
+ .scan(sorter, SorterAccumulator::next)
+ .concatMap(SorterAccumulator::getReleased)
+ .concatWith(sorter.drain());
+ }
+
+ protected static StringBuffer getStackDumps() {
+ StringBuffer sb = new StringBuffer();
+ Map traces = Thread.getAllStackTraces();
+ for (Map.Entry entry : traces.entrySet()) {
+ sb.append(entry.getKey().toString());
+ sb.append("\n");
+ for (StackTraceElement element : entry.getValue()) {
+ sb.append(" ");
+ sb.append(element.toString());
+ sb.append("\n");
+ }
+ sb.append("\n");
+ }
+ return sb;
+ }
+
+
+ /**
+ * Connect a mono to a CompletableFuture so that the result of the mono
+ * can be retrieved from the {@link CompletableFuture} by calling it's 'get'
+ * method.
+ */
+ public static void completeWith(CompletableFuture future, Mono mono) {
+ mono.doOnNext((T v) -> {
+ future.complete(v);
+ })
+ .doOnError((Throwable e) -> {
+ future.completeExceptionally(e);
+ })
+ .subscribeOn(Schedulers.elastic())
+ .subscribe();
+ }
+}
diff --git a/vscode-extensions/commons/commons-cf/src/test/java/org/springframework/ide/vscode/commons/cloudfoundry/client/CFClientTest.java b/vscode-extensions/commons/commons-cf/src/test/java/org/springframework/ide/vscode/commons/cloudfoundry/client/CFClientTest.java
new file mode 100644
index 000000000..7e2982a7d
--- /dev/null
+++ b/vscode-extensions/commons/commons-cf/src/test/java/org/springframework/ide/vscode/commons/cloudfoundry/client/CFClientTest.java
@@ -0,0 +1,41 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Pivotal, Inc.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.commons.cloudfoundry.client;
+
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.target.CFClientParamsFactory;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.target.CFClientTarget;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.target.CFClientTargets;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.v2.CloudFoundryClientFactory;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.v2.DefaultCloudFoundryClientFactoryV2;
+
+public class CFClientTest {
+
+
+
+ @Ignore @Test public void testGetBuildpacksFromCliParamsTarget() throws Exception {
+
+ CFClientParamsFactory paramsFactory = CFClientParamsFactory.INSTANCE;
+ CloudFoundryClientFactory clientFactory = DefaultCloudFoundryClientFactoryV2.INSTANCE;
+
+ CFClientTargets targets = new CFClientTargets(paramsFactory, clientFactory);
+ CFClientTarget target = targets.getTargets().get(0);
+
+ List buildPacks = target.getBuildpacks();
+ assertTrue(!buildPacks.isEmpty());
+ }
+
+}
diff --git a/vscode-extensions/commons/commons-util/src/main/java/org/springframework/ide/vscode/commons/util/ExceptionUtil.java b/vscode-extensions/commons/commons-util/src/main/java/org/springframework/ide/vscode/commons/util/ExceptionUtil.java
index 7135a9c0d..ce0b380d1 100644
--- a/vscode-extensions/commons/commons-util/src/main/java/org/springframework/ide/vscode/commons/util/ExceptionUtil.java
+++ b/vscode-extensions/commons/commons-util/src/main/java/org/springframework/ide/vscode/commons/util/ExceptionUtil.java
@@ -76,4 +76,13 @@ public class ExceptionUtil {
return new ExecutionException(cause);
}
+ public static Object exception(String message, Throwable error) {
+ if (message != null) {
+ // Wrap only if there is an additional message
+ return new ExecutionException(message, error);
+ } else {
+ return exception(error);
+ }
+ }
+
}
diff --git a/vscode-extensions/commons/language-server-test-harness/src/main/java/org/springframework/ide/vscode/languageserver/testharness/Editor.java b/vscode-extensions/commons/language-server-test-harness/src/main/java/org/springframework/ide/vscode/languageserver/testharness/Editor.java
index 79cce2554..0221ba872 100644
--- a/vscode-extensions/commons/language-server-test-harness/src/main/java/org/springframework/ide/vscode/languageserver/testharness/Editor.java
+++ b/vscode-extensions/commons/language-server-test-harness/src/main/java/org/springframework/ide/vscode/languageserver/testharness/Editor.java
@@ -238,6 +238,22 @@ public class Editor {
assertEquals(expect.toString(), actual.toString());
}
+ public void assertContainsCompletions(String... expectTextAfter) throws Exception {
+ StringBuilder actual = new StringBuilder();
+
+ for (CompletionItem completion : getCompletions()) {
+ Editor editor = this.clone();
+ editor.apply(completion);
+ actual.append(editor.getText());
+ actual.append("\n-------------------\n");
+ }
+ String actualText = actual.toString();
+
+ for (String after : expectTextAfter) {
+ assertContains(after, actualText);
+ }
+ }
+
public void apply(CompletionItem completion) throws Exception {
TextEdit edit = completion.getTextEdit();
String docText = document.getText();
diff --git a/vscode-extensions/commons/pom.xml b/vscode-extensions/commons/pom.xml
index ea520ebbf..78b1128a2 100644
--- a/vscode-extensions/commons/pom.xml
+++ b/vscode-extensions/commons/pom.xml
@@ -16,7 +16,7 @@
commons-util
commons-java
java-properties
-
+ commons-cf
commons-maven
@@ -45,6 +45,11 @@
true
+
+ spring-releases
+ Spring Releases
+ http://repo.spring.io/release
+
@@ -57,7 +62,10 @@
2.5.0
2.10
0.1.0-SNAPSHOT
- 3.0.2.RELEASE
+
+ 3.0.4.RELEASE
+ 0.6.0.RELEASE
+ 2.1.0.RELEASE
diff --git a/vscode-extensions/vscode-manifest-yaml/pom.xml b/vscode-extensions/vscode-manifest-yaml/pom.xml
index 741d863fc..46b14d30c 100644
--- a/vscode-extensions/vscode-manifest-yaml/pom.xml
+++ b/vscode-extensions/vscode-manifest-yaml/pom.xml
@@ -42,6 +42,12 @@
commons-yaml
${project.version}
+
+
+ org.springframework.ide.vscode
+ commons-cf
+ ${project.version}
+
org.springframework.ide.vscode
diff --git a/vscode-extensions/vscode-manifest-yaml/src/main/java/org/springframework/ide/vscode/manifest/yaml/ManifestYamlCFBuildpacksProvider.java b/vscode-extensions/vscode-manifest-yaml/src/main/java/org/springframework/ide/vscode/manifest/yaml/ManifestYamlCFBuildpacksProvider.java
new file mode 100644
index 000000000..21ebd3e3c
--- /dev/null
+++ b/vscode-extensions/vscode-manifest-yaml/src/main/java/org/springframework/ide/vscode/manifest/yaml/ManifestYamlCFBuildpacksProvider.java
@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Pivotal, Inc.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.manifest.yaml;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.inject.Provider;
+
+import org.springframework.ide.vscode.commons.cloudfoundry.client.CFBuildpack;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.target.CFClientTarget;
+import org.springframework.ide.vscode.commons.yaml.schema.BasicYValueHint;
+import org.springframework.ide.vscode.commons.yaml.schema.YValueHint;
+
+public class ManifestYamlCFBuildpacksProvider implements Provider> {
+
+ private final List targets;
+ private static final Logger logger = Logger.getLogger(ManifestYamlCFBuildpacksProvider.class.getName());
+
+
+ public ManifestYamlCFBuildpacksProvider(List targets) {
+ this.targets = targets;
+ }
+
+
+ @Override
+ public Collection get() {
+ List hints = new ArrayList<>();
+
+ if (targets != null) {
+ for (CFClientTarget cfClientTarget : targets) {
+
+ List buildpacks;
+ try {
+ buildpacks = cfClientTarget.getBuildpacks();
+ if (buildpacks != null) {
+ for (CFBuildpack buildpack : buildpacks) {
+ String name = buildpack.getName();
+ String label = getBuildpackLabel(cfClientTarget, buildpack);
+ YValueHint hint = new BasicYValueHint(name, label);
+ if (!hints.contains(hint)) {
+ hints.add(hint);
+ }
+ }
+ }
+ } catch (Exception e) {
+ logger.log(Level.SEVERE, e.getMessage(), e);
+ }
+ }
+ }
+ return hints;
+ }
+
+ protected String getBuildpackLabel(CFClientTarget target, CFBuildpack buildpack) {
+ return buildpack.getName() + " (" + target.getName() + ")";
+ }
+
+}
diff --git a/vscode-extensions/vscode-manifest-yaml/src/main/java/org/springframework/ide/vscode/manifest/yaml/ManifestYamlCFServicesProvider.java b/vscode-extensions/vscode-manifest-yaml/src/main/java/org/springframework/ide/vscode/manifest/yaml/ManifestYamlCFServicesProvider.java
new file mode 100644
index 000000000..b80b1377b
--- /dev/null
+++ b/vscode-extensions/vscode-manifest-yaml/src/main/java/org/springframework/ide/vscode/manifest/yaml/ManifestYamlCFServicesProvider.java
@@ -0,0 +1,67 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Pivotal, Inc.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.manifest.yaml;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.inject.Provider;
+
+import org.springframework.ide.vscode.commons.cloudfoundry.client.CFServiceInstance;
+import org.springframework.ide.vscode.commons.cloudfoundry.client.target.CFClientTarget;
+import org.springframework.ide.vscode.commons.yaml.schema.BasicYValueHint;
+import org.springframework.ide.vscode.commons.yaml.schema.YValueHint;
+
+public class ManifestYamlCFServicesProvider implements Provider> {
+
+ private final List