import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
@Override
public void createService(CloudService service) {
    assertSpaceProvided("create service");
    Assert.notNull(service, "Service must not be null");
    Assert.notNull(service.getName(), "Service name must not be null");
    Assert.notNull(service.getLabel(), "Service label must not be null");
    Assert.notNull(service.getPlan(), "Service plan must not be null");

    CloudServicePlan cloudServicePlan = findPlanForService(service);

    HashMap<String, Object> serviceRequest = new HashMap<String, Object>();
    serviceRequest.put("space_guid", sessionSpace.getMeta().getGuid());
    serviceRequest.put("name", service.getName());
    serviceRequest.put("service_plan_guid", cloudServicePlan.getMeta().getGuid());
    getRestTemplate().postForObject(getUrl("/v2/service_instances"), serviceRequest, String.class);
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
@Override
public List<CloudService> getServices() {
    Map<String, Object> urlVars = new HashMap<String, Object>();
    String urlPath = "/v2";
    if (sessionSpace != null) {
        urlVars.put("space", sessionSpace.getMeta().getGuid());
        urlPath = urlPath + "/spaces/{space}";
    }
    urlPath = urlPath + "/service_instances?inline-relations-depth=1&return_user_provided_service_instances=true";
    List<Map<String, Object>> resourceList = getAllResources(urlPath, urlVars);
    List<CloudService> services = new ArrayList<CloudService>();
    for (Map<String, Object> resource : resourceList) {
        if (hasEmbeddedResource(resource, "service_plan")) {
            fillInEmbeddedResource(resource, "service_plan", "service");
        }
        services.add(resourceMapper.mapResource(resource, CloudService.class));
    }
    return services;
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
private void createUserProvidedServiceDelegate(CloudService service, Map<String, Object> credentials, String syslogDrainUrl) {
    assertSpaceProvided("create service");
    Assert.notNull(credentials, "Service credentials must not be null");
    Assert.notNull(service, "Service must not be null");
    Assert.notNull(service.getName(), "Service name must not be null");
    Assert.isNull(service.getLabel(), "Service label is not valid for user-provided services");
    Assert.isNull(service.getProvider(), "Service provider is not valid for user-provided services");
    Assert.isNull(service.getVersion(), "Service version is not valid for user-provided services");
    Assert.isNull(service.getPlan(), "Service plan is not valid for user-provided services");

    HashMap<String, Object> serviceRequest = new HashMap<>();
    serviceRequest.put("space_guid", sessionSpace.getMeta().getGuid());
    serviceRequest.put("name", service.getName());
    serviceRequest.put("credentials", credentials);
    if (syslogDrainUrl != null && !syslogDrainUrl.equals("")) {
        serviceRequest.put("syslog_drain_url", syslogDrainUrl);
    }

    getRestTemplate().postForObject(getUrl("/v2/user_provided_service_instances"), serviceRequest, String.class);
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private List<UUID> getAppsBoundToService(CloudService cloudService) {
    List<UUID> appGuids = new ArrayList<UUID>();
    String urlPath = "/v2";
    Map<String, Object> urlVars = new HashMap<String, Object>();
    if (sessionSpace != null) {
        urlVars.put("space", sessionSpace.getMeta().getGuid());
        urlPath = urlPath + "/spaces/{space}";
    }
    urlVars.put("q", "name:" + cloudService.getName());
    urlPath = urlPath + "/service_instances?q={q}";
    List<Map<String, Object>> resourceList = getAllResources(urlPath, urlVars);
    for (Map<String, Object> resource : resourceList) {
        fillInEmbeddedResource(resource, "service_bindings");
        List<Map<String, Object>> bindings = CloudEntityResourceMapper.getEntityAttribute(resource, "service_bindings", List.class);
        for (Map<String, Object> binding : bindings) {
            String appId = CloudEntityResourceMapper.getEntityAttribute(binding, "app_guid", String.class);
            if (appId != null) {
                appGuids.add(UUID.fromString(appId));
            }
        }
    }
    return appGuids;
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private CloudServiceInstance mapServiceInstanceResource(Map<String, Object> resource) {
    CloudServiceInstance serviceInstance = new CloudServiceInstance(getMeta(resource), getNameOfResource(resource));

    serviceInstance.setType(getEntityAttribute(resource, "type", String.class));
    serviceInstance.setDashboardUrl(getEntityAttribute(resource, "dashboard_url", String.class));
    serviceInstance.setCredentials(getEntityAttribute(resource, "credentials", Map.class));

    Map<String, Object> servicePlanResource = getEmbeddedResource(resource, "service_plan");
    if (servicePlanResource != null) {
        serviceInstance.setServicePlan(mapServicePlanResource(servicePlanResource));
    }

    CloudService service = mapServiceResource(resource);
    serviceInstance.setService(service);

    List<Map<String, Object>> bindingsResource = getEmbeddedResourceList(getEntity(resource), "service_bindings");
    List<CloudServiceBinding> bindings = new ArrayList<>(bindingsResource.size());
    for (Map<String, Object> bindingResource : bindingsResource) {
        bindings.add(mapServiceBinding(bindingResource));
    }
    serviceInstance.setBindings(bindings);

    return serviceInstance;
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
@Test
public void getCreateDeleteService() throws MalformedURLException {
    String serviceName = "mysql-test";
    createMySqlService(serviceName);

    CloudService service = connectedClient.getService(serviceName);
    assertNotNull(service);
    assertEquals(serviceName, service.getName());
    assertTimeWithinRange("Creation time should be very recent", service.getMeta().getCreated().getTime(), FIVE_MINUTES);

    connectedClient.deleteService(serviceName);

    List<CloudService> services = connectedClient.getServices();
    assertNotNull(services);
    assertEquals(0, services.size());
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
private Map<String, ServiceOperationType> createOrUpdateServices(ExecutionWrapper execution, CloudFoundryOperations client,
    List<CloudServiceExtended> services, Map<String, CloudService> existingServices, Map<String, List<ServiceKey>> serviceKeys,
    Map<String, List<String>> defaultTags) throws SLException, FileStorageException {

    Map<String, ServiceOperationType> triggeredOperations = new TreeMap<>();
    for (CloudServiceExtended service : services) {
        CloudService existingService = existingServices.get(service.getName());
        List<String> defaultTagsForService = defaultTags.get(service.getLabel());
        ServiceOperationType triggeredOperation = createOrUpdateService(execution, client, service, existingService,
            defaultTagsForService);
        triggeredOperations.put(service.getName(), triggeredOperation);
        List<ServiceKey> serviceKeysForService = serviceKeys.getOrDefault(service.getName(), Collections.emptyList());
        createOrUpdateServiceKeys(serviceKeysForService, service, existingService, client, execution);
    }
    return triggeredOperations;
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
private void attemptToUpdateServiceParameters(CloudFoundryOperations client, String serviceName, Map<String, Object> parameters) {
    assertServiceAttributes(serviceName, parameters);
    CloudService service = client.getService(serviceName);

    RestTemplate restTemplate = getRestTemplate(client);
    String cloudControllerUrl = getCloudControllerUrl(client);

    if (service.isUserProvided()) {
        attemptToUpdateServiceParameter(SERVICE_CREDENTIALS, parameters, restTemplate,
            getUrl(cloudControllerUrl, getUpdateServiceUrl(USER_PROVIDED_SERVICE_INSTANCES_URL, service.getMeta().getGuid().toString(),
                ACCEPTS_INCOMPLETE_FALSE)));
        return;
    }

    attemptToUpdateServiceParameter(SERVICE_PARAMETERS, parameters, restTemplate, getUrl(cloudControllerUrl,
        getUpdateServiceUrl(SERVICE_INSTANCES_URL, service.getMeta().getGuid().toString(), ACCEPTS_INCOMPLETE_FALSE)));
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
private DatabaseService getDatabaseServiceFromServiceKey(CloudServiceKey cloudServiceKey, DatabaseRef databaseRef, String org, String space) {
    CloudService cloudService = cloudServiceKey.getService();
    DatabaseService databaseService = new DatabaseService(
            cloudService.getMeta().getGuid().toString(),
            cloudService.getName(),
            org,
            space,
            cloudServiceKey.getMeta().getGuid().toString()
    );

    if (!this.databaseServiceRepo.exists(cloudService.getMeta().getGuid().toString())) {
        databaseService.setDatabaseRef(databaseRef);
        this.databaseServiceRepo.save(databaseService);
        return databaseService;
    }
    DatabaseService databaseServiceDao = this.databaseServiceRepo.findOne(cloudService.getMeta().getGuid().toString());
    this.updateDatabaseService(databaseService, databaseServiceDao);
    return databaseServiceDao;
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
protected void createService(CloudService cloudService) {
    try {
        logger.info("Creating service {} from {} with plan {} ", cloudService.getName(), cloudService.getLabel(), cloudService.getPlan());
        cfClientToPopulate.createService(cloudService);
        if (!this.isFinishedCreatingService(cloudService)) {
            fail("Cannot create service '" + cloudService.getName() + "'");
        }
    } catch (HttpServerErrorException e) {
        if (!e.getStatusCode().equals(HttpStatus.BAD_GATEWAY)) {
            throw e;
        } else {
            String skipMessage = "Bad gateway error, skipping test";
            this.reportIntegration.setSkipped(true);
            this.reportIntegration.setSkippedReason(skipMessage);
            assumeTrue(skipMessage, false);
        }
    }

}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
@Test
public void when_getting_user_service_it_should_give_the_correct_one_or_null_if_user_dont_have_access() {
    CloudService cloudService = cloudFoundryServiceKeyManager.getUserService(cloudServiceName, "token", "org", "space");
    assertThat(cloudService).isNotNull();
    assertThat(cloudService.getName()).isEqualTo(cloudServiceName);

    cloudService = cloudFoundryServiceKeyManager.getUserService(cloudServiceName, "token", null, null);
    assertThat(cloudService).isNotNull();
    assertThat(cloudService.getName()).isEqualTo(cloudServiceName);

    cloudService = cloudFoundryServiceKeyManager.getUserService(CloudFoundryClientFake.SERVICE_NOT_ACCESSIBLE, "token", "org", "space");
    assertThat(cloudService).isNull();

    cloudService = cloudFoundryServiceKeyManager.getUserService(CloudFoundryClientFake.SERVICE_NOT_ACCESSIBLE, "token", null, null);
    assertThat(cloudService).isNull();
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
public static void checkSafeTarget(HarnessProperties cred) throws Exception {

		// To avoid junits deleting contents of a target by accident, ensure
		// the target is empty
		CloudFoundryOperations ops = createExternalClient(cred);

		List<CloudApplication> apps = ops.getApplications();
		if (apps != null && !apps.isEmpty()) {
			throw CloudErrorUtil.toCoreException(NLS.bind(
					"Empty Cloud target required to run junits. Existing number of applications {0} found in: server = {1}, org = {2}, space = {3}",
					new Object[] { apps.size(), cred.getApiUrl(), cred.getOrg(), cred.getSpace() }));
		}
		List<CloudService> services = ops.getServices();
		if (services != null && !services.isEmpty()) {
			throw CloudErrorUtil.toCoreException(NLS.bind(
					"Empty Cloud target required to run junits. Existing number of services {0} found in: server = {1}, org = {2}, space = {3}",
					new Object[] { services.size(), cred.getApiUrl(), cred.getOrg(), cred.getSpace() }));
		}

	}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
/**
 * Copy the deployment info, with any known mutable values set as copies as
 * well. Therefore, if an info property is a list of values (e.g. list of
 * bound services), modifying the list in the copy will not affect the list
 * of values in the original version.
 * @return non-null copy of this info.
 */
public ApplicationDeploymentInfo copy() {
	ApplicationDeploymentInfo info = new ApplicationDeploymentInfo(getDeploymentName());

	info.setMemory(getMemory());
	info.setStaging(getStaging());
	info.setInstances(getInstances());
	info.setArchive(getArchive());

	if (getServices() != null) {
		info.setServices(new ArrayList<CloudService>(getServices()));
	}

	if (getUris() != null) {
		info.setUris(new ArrayList<String>(getUris()));
	}

	if (getEnvVariables() != null) {
		info.setEnvVariables(new ArrayList<EnvironmentVariable>(getEnvVariables()));
	}

	return info;
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
BaseClientRequest<List<CloudService>> getDeleteServicesRequest(final List<String> services) {
	return new BehaviourRequest<List<CloudService>>(Messages.DockerFoundryServerBehaviour_DELETE_SERVICES) {
		@Override
		protected List<CloudService> doRun(DockerClient client, SubMonitor progress) throws CoreException {

			SubMonitor serviceProgress = SubMonitor.convert(progress, services.size());

			for (String service : services) {
				serviceProgress.subTask(NLS.bind(Messages.DockerFoundryServerBehaviour_DELETING_SERVICE, service));
				// client.deleteService(service);
				serviceProgress.worked(1);
			}
			// return client.getServices();
			return null;
		}
	};
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
BaseClientRequest<List<CloudService>> getCreateServicesRequest(final CloudService[] services) {
	return new BehaviourRequest<List<CloudService>>(Messages.DockerFoundryServerBehaviour_CREATE_SERVICES) {
		@Override
		protected List<CloudService> doRun(DockerClient client, SubMonitor progress) throws CoreException {

			SubMonitor serviceProgress = SubMonitor.convert(progress, services.length);

			for (CloudService service : services) {
				serviceProgress.subTask(NLS.bind(Messages.DockerFoundryServerBehaviour_CREATING_SERVICE,
						service.getName()));
				// client.createService(service);
				serviceProgress.worked(1);
			}
			// return client.getServices();
			return null;
		}
	};
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
@Override
	public int compare(Viewer viewer, Object e1, Object e2) {
		if (e1 instanceof DockerContainerInfo && e1 instanceof DockerContainerInfo) {
//			InstanceStats stats1 = ((DockerContainerInfo) e1).getStats();
//			InstanceStats stats2 = ((InstanceStatsAndInfo) e2).getStats();
//			return stats1.getId().compareTo(stats2.getId());
			DockerContainerInfo d1 = (DockerContainerInfo)e1;
			DockerContainerInfo d2 = (DockerContainerInfo)e2;
			return d1.hashCode() - d2.hashCode();
		}
		if (e1 instanceof CloudService && e2 instanceof CloudService) {
			CloudService service1 = (CloudService) e1;
			CloudService service2 = (CloudService) e2;
			return service1.getName().compareTo(service2.getName());
		}
		if (e1 instanceof IModule && e2 instanceof IModule) {
			IModule m1 = (IModule) e1;
			IModule m2 = (IModule) e2;
			return m1.getName().compareTo(m2.getName());
		}
		return super.compare(viewer, e1, e2);
	}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
public String getColumnText(Object element, int columnIndex) {
	if (element instanceof CloudService) {
		CloudService service = (CloudService) element;
		switch (columnIndex) {
		case 0:
			return service.getName();
		case 1:
			return service.getLabel();
		case 2:
			return service.getPlan();
		case 3:
			return service.getVersion();
		}
	}
	return null;
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
@Override
	public boolean validateDrop(Object target, int operation, TransferData type) {
		overrideOperation(DND.DROP_COPY);
//		if (application == null)
//			return false;

		if (operation == DND.DROP_COPY || operation == DND.DROP_DEFAULT) {
			if (LocalSelectionTransfer.getTransfer().isSupportedType(type)) {
				IStructuredSelection selection = (IStructuredSelection) LocalSelectionTransfer.getTransfer()
						.getSelection();
				Object[] objects = selection.toArray();
				for (Object obj : objects) {
					if (obj instanceof CloudService) {
						return true;
					}
				}
			}
		}
		return false;
	}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
@After
public void tearDown() {
	List<CloudApplication> cloudApps = cfClient.getApplications();
	for (CloudApplication cloudApp : cloudApps) {
		if (cloudApp.getName().contains(getTestAppName())) {
			cfClient.deleteApplication(cloudApp.getName());
		}
	}

	List<CloudService> cloudServices = cfClient.getServices();
	for (CloudService cloudService : cloudServices) {
		if (cloudService.getName().contains(getTestAppName())) {
			cfClient.deleteService(cloudService.getName());
		}
	}

	clearDomain(getTestDomainName(), true);
	clearDomain(getDefaultDomain(), false);

	cfClient.logout();
}
 

import org.cloudfoundry.client.lib.domain.CloudService; //导入依赖的package包/类
/**
 * Creates a new service in Bluemix.
 * Note that you can get the services and plans available in Bluemix through the
 * "cf marketplace" command. 
 * 
 * @param label
 * 			the service's label (e.g. "sqldb"). 
 * @param name
 * 			the service's name.
 * @param plan
 * 			the service's plan.
 * 
 * @throws BluemixClientException
 */
public void createService(String label, String name, String plan)
		throws BluemixClientException {
	
	if (null == label || null == name || null == plan) {
		String message = "Invalid arguments. label, name and plan can not be null.";
		throw new BluemixClientException(message);
	}
	
	LOGGER.info("Creating a new service...");
       CloudService service = new CloudService();
       service.setLabel(label);
       service.setName(name);
       service.setPlan(plan);
       client.createService(service);
}