Java ServiceInstance类代码示例

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void bind_doNothing_returnMultitenantCredentialsMap() throws Exception {
  //given
  String host = "jojoservice";
  String port = "10000";
  String expected = "jdbc:hive2://jojoservice:10000/%{organization};"
                    + "principal=hive/[email protected];auth=kerberos";
  ExternalConfiguration conf = new ExternalConfiguration();
  conf.setHiveServerHost(host);
  conf.setHiveServerPort(port);
  conf.setHiveProvidedZip(hadoopConf);
  HivePlanMultitenant plan = new HivePlanMultitenant(HiveBindingClientFactory.create(conf));

  //when
  ServiceInstance serviceInstance = getServiceInstance();
  Map<String, Object> actualOutputCredentials = plan.bind(serviceInstance);

  //then
  assertThat(actualOutputCredentials, hasEntry("connectionUrl", expected));
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@Override
public ServiceInstance createServiceInstance(CreateServiceInstanceRequest request) throws ServiceInstanceExistsException, ServiceBrokerException, ServiceBrokerAsyncRequiredException {
    ServiceInstance serviceInstance = new ServiceInstance(request);
    serviceInstance.withDashboardUrl(appUri);
    serviceInstance.withAsync(false);
    if (this.oauthRegServiceInstanceRepo.exists(request.getServiceInstanceId())) {
        throw new ServiceInstanceExistsException(serviceInstance);
    }
    OauthRegServiceInstance instance = this.generateOauthRegServiceInstance(serviceInstance);
    Driver driver = this.getDriverFromInstance(instance);
    if (!this.manageGlobalProvider.hasGlobalProviderConfig(driver)) {
        this.loadLoginProviderToInstance(request.getParameters(), instance);
    }
    String authenticationCode = this.getParameter(request.getParameters(), AUTHENTICATION_CODE_PARAMETER, null);
    instance.setAuthenticationCode(authenticationCode);
    this.oauthRegServiceInstanceRepo.save(instance);
    return serviceInstance;
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@Override
public ServiceInstance updateServiceInstance(UpdateServiceInstanceRequest request)
        throws ServiceInstanceUpdateNotSupportedException,
        ServiceBrokerException,
        ServiceInstanceDoesNotExistException {

    PersistableServiceInstance one = this.serviceInstanceRepository.findOne(
            request.getServiceInstanceId());

    PersistableServiceInstance two = new PersistableServiceInstance(
            one.getServiceDefinitionId(),
            request.getPlanId(),
            one.getOrganizationGuid(),
            one.getSpaceGuid(),
            request.getServiceInstanceId(), true);

    return this.serviceInstanceRepository.save(two);
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@Override
public ServiceInstance deleteServiceInstance(
		DeleteServiceInstanceRequest request)
		throws ServiceBrokerException, ServiceBrokerAsyncRequiredException {
	throwIfSync(request);
	String id = request.getServiceInstanceId();
	log(id, "Deleting service instance", IN_PROGRESS);
	ServiceInstance instance = instanceManager.getInstance(id);
	if (null == instance) {
		log(id, "Service instance not found", FAILED);
		return null;
	}
	String copyId = instanceManager.getCopyIdForInstance(id);

	instanceManager.saveInstance(
			instance.withLastOperation(
					new ServiceInstanceLastOperation("deprovisioning",
							OperationState.IN_PROGRESS)).isAsync(true),
			copyId);

	deProvision(request, id, instance);

	return instance;

}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
private void deProvision(DeleteServiceInstanceRequest request, String id,
		ServiceInstance instance) {
	executor.execute(new Runnable() {
		@Override
		public void run() {
			try {
				if (COPY.equals(request.getPlanId())) {
					copyProvider.deleteCopy(instanceManager
							.getCopyIdForInstance(id));
				}
				log(id, "Deleted service instance", COMPLETE);
				instanceManager.removeInstance(id);
			} catch (ServiceBrokerException e) {
				log(id,
						"Failed to delete service instance: "
								+ e.getMessage(), FAILED);
				instance.withLastOperation(new ServiceInstanceLastOperation(
						"failed to delete", OperationState.FAILED));
				String copyId = instanceManager.getCopyIdForInstance(id);
				instanceManager.saveInstance(instance, copyId);
			}
		}
	});
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@Test
public void testCreateInstanceBinding_success_shouldReturnZookeeperNodeInCredentials()
    throws Exception {
  //arrange
  String bindingId = UUID.randomUUID().toString();
  String serviceInstanceId = UUID.randomUUID().toString();
  ServiceInstance instance = getServiceInstance(serviceInstanceId, "fakeBaseGuid-shared-plan");
  CreateServiceInstanceRequest instanceReq = getCreateInstanceRequest(instance);
  CreateServiceInstanceBindingRequest bindReq = getCreateBindingRequest(serviceInstanceId).withBindingId(bindingId);

  //act
  serviceBean.createServiceInstance(getCreateInstanceRequest(instance));
  ServiceInstanceBinding binding = bindingBean.createServiceInstanceBinding(bindReq);
  String namespaceInCredentials = (String) binding.getCredentials().get("zk.node");

  //assert
  assertThat(namespaceInCredentials, equalTo(conf.getBrokerRootNode() + "/" + serviceInstanceId));
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@Test
public void itReturnsTheCorrectListOfServices()
		throws ServiceBrokerException, ServiceInstanceExistsException {

	Collection<Pair<String, ServiceInstance>> instances = createInstances();

	when(instanceManager.getInstances()).thenReturn(instances);

	List<InstancePair> provisionedInstances = service
			.getProvisionedInstances();
	assertThat(provisionedInstances, hasSize(5));
	assertTrue(provisionedInstances.contains(new InstancePair(
			"source_instance_id", "copy_instance2")));
	assertTrue(provisionedInstances.contains(new InstancePair(
			"source_instance_id", "source_instance_id")));
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@Test
public void itShouldSaveTheInstnaceAsFailedIfDeprovisionFails()
		throws Exception {

	ServiceInstance theInstance = new ServiceInstance(
			newCreateServiceInstanceRequest());

	doThrow(new ServiceBrokerException("Problem!")).when(copyProvider)
			.deleteCopy(anyString());

	when(instanceManager.getInstance(anyString())).thenReturn(theInstance);
	when(instanceManager.getCopyIdForInstance(anyString())).thenReturn(
			"copy_id");

	ServiceInstance failedInstance = service
			.deleteServiceInstance(new DeleteServiceInstanceRequest(
					theInstance.getServiceInstanceId(), theInstance
							.getServiceDefinitionId(), COPY, true));

	assertThat(failedInstance.getServiceInstanceLastOperation().getState(),
			is(equalTo("failed")));

	// Once for in progress, once for failed.
	verify(instanceManager, times(2)).saveInstance(any(), anyString());
	assertTrue(failedInstance.isAsync());
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@Override
public ServiceInstance deleteServiceInstance(DeleteServiceInstanceRequest request)
    throws ServiceBrokerException {

    LOGGER.debug(LoggerHelper
        .getParamsAsString("deleteServiceInstance", request.getServiceInstanceId(),
            request.getServiceId(), request.getPlanId()));

    Optional<ServiceInstance> instance;
    try {
        Location storingLocation = Location.newInstance(request.getServiceInstanceId());
        instance = store.deleteById(storingLocation);
    } catch (IOException e) {
        throw new ServiceBrokerException(e.getMessage(), e);
    }
    return instance.orElse(null);
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
public ServiceInstance findServiceInstance(String instanceId) throws SQLException {
    Utils.checkValidUUID(instanceId);

    Map<Integer, String> parameterMap = new HashMap<Integer, String>();
    parameterMap.put(1, instanceId);

    Map<String, String> result = PostgreSQLDatabase.executePreparedSelect("SELECT * FROM service WHERE serviceinstanceid = ?", parameterMap);

    String serviceDefinitionId = result.get("servicedefinitionid");
    String organizationGuid = result.get("organizationguid");
    String planId = result.get("planid");
    String spaceGuid = result.get("spaceguid");

    CreateServiceInstanceRequest wrapper = new CreateServiceInstanceRequest(serviceDefinitionId, planId, organizationGuid, spaceGuid).withServiceInstanceId(instanceId);
    return new ServiceInstance(wrapper);
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@Override
public ServiceInstance createServiceInstance(CreateServiceInstanceRequest createServiceInstanceRequest)
        throws ServiceInstanceExistsException, ServiceBrokerException {
    String serviceInstanceId = createServiceInstanceRequest.getServiceInstanceId();
    String serviceId = createServiceInstanceRequest.getServiceDefinitionId();
    String planId = createServiceInstanceRequest.getPlanId();
    String organizationGuid = createServiceInstanceRequest.getOrganizationGuid();
    String spaceGuid = createServiceInstanceRequest.getSpaceGuid();
    try {
        db.createDatabaseForInstance(serviceInstanceId, serviceId, planId, organizationGuid, spaceGuid);
        role.createRoleForInstance(serviceInstanceId);
    } catch (SQLException e) {
        logger.error("Error while creating service instance '" + serviceInstanceId + "'", e);
        throw new ServiceBrokerException(e.getMessage());
    }
    return new ServiceInstance(createServiceInstanceRequest);
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@Test
public void testCreateServiceInstance_success_shouldReturnCreatedInstanceAndStoreCredentials()
    throws Exception {

  // arrange
  final String INSTANCE_ID = "instanceId0";
  when(h2oProvisionerRestApi.createH2oInstance(INSTANCE_ID, conf.getH2oMapperNodes(),
      conf.getH2oMapperMemory(), true, yarnConfig))
          .thenReturn(new ResponseEntity<>(CREDENTIALS, HttpStatus.OK));

  // act
  CreateServiceInstanceRequest request =
      CfBrokerRequestsFactory.getCreateInstanceRequest(INSTANCE_ID);
  ServiceInstance createdInstance = instanceService.createServiceInstance(request);

  // assert
  assertThat(createdInstance.getServiceInstanceId(), equalTo(INSTANCE_ID));

  freeze().until(() -> credentialsStore.getById(Location.newInstance(INSTANCE_ID)).get(),
      equalTo(CREDENTIALS));

  verify(h2oProvisionerRestApi, times(1)).createH2oInstance(INSTANCE_ID, conf.getH2oMapperNodes(),
      conf.getH2oMapperMemory(), true, yarnConfig);
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@Test
public void testDeleteServiceInstance_success_shouldReturnRemovedInstance() throws Exception {
  // arrange
  final String INSTANCE_ID = "instanceId1";
  when(h2oProvisionerRestApi.createH2oInstance(INSTANCE_ID, conf.getH2oMapperNodes(),
      conf.getH2oMapperMemory(), true, yarnConfig))
          .thenReturn(new ResponseEntity<>(CREDENTIALS, HttpStatus.OK));
  when(h2oProvisionerRestApi.deleteH2oInstance(INSTANCE_ID, yarnConfig))
      .thenReturn(new ResponseEntity<>("test-job-id", HttpStatus.OK));
  ServiceInstance instance = instanceService
      .createServiceInstance(CfBrokerRequestsFactory.getCreateInstanceRequest(INSTANCE_ID));

  // act
  ServiceInstance removedInstance = instanceService
      .deleteServiceInstance(new DeleteServiceInstanceRequest(instance.getServiceInstanceId(),
          instance.getServiceDefinitionId(), instance.getPlanId()));

  // assert
  verify(h2oProvisionerRestApi, times(1)).deleteH2oInstance(INSTANCE_ID, yarnConfig);
  assertThat(instance.getServiceInstanceId(), equalTo(removedInstance.getServiceInstanceId()));
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@Test
public void createServiceInstance_provisionerAndStoreWorks_instanceCreated() throws Exception {
  // arrange
  CreateServiceInstanceRequest request =
      CfBrokerRequestsFactory.getCreateInstanceRequest(INSTANCE_ID);
  ServiceInstance expectedInstance = new ServiceInstance(request);
  H2oCredentials expectedCredentials = new H2oCredentials("a", "b", "c", "d");

  when(delegateMock.createServiceInstance(request)).thenReturn(expectedInstance);
  when(h2oProvisioner.provisionInstance(INSTANCE_ID)).thenReturn(expectedCredentials);
  doNothing().when(credentialsStoreMock).save(Location.newInstance(INSTANCE_ID),
      expectedCredentials);

  // act
  ServiceInstance createdInstance = instanceService.createServiceInstance(request);

  // assert
  assertThat(createdInstance, equalTo(expectedInstance));
  verify(delegateMock, timeout(200)).createServiceInstance(request);
  verify(h2oProvisioner, timeout(200)).provisionInstance(INSTANCE_ID);
  verify(credentialsStoreMock, timeout(200)).save(Location.newInstance(INSTANCE_ID),
      expectedCredentials);
}
 

import org.cloudfoundry.community.servicebroker.model.ServiceInstance; //导入依赖的package包/类
@Test
public void createServiceInstance_provisionerFails_instanceCreated() throws Exception {
  // arrange
  CreateServiceInstanceRequest request =
      CfBrokerRequestsFactory.getCreateInstanceRequest(INSTANCE_ID);
  ServiceInstance expectedInstance = new ServiceInstance(request);

  when(delegateMock.createServiceInstance(request)).thenReturn(expectedInstance);
  when(h2oProvisioner.provisionInstance(INSTANCE_ID)).thenThrow(new ServiceBrokerException(""));

  // act
  ServiceInstance createdInstance = instanceService.createServiceInstance(request);

  // assert
  assertThat(createdInstance, equalTo(expectedInstance));
  verify(delegateMock, timeout(200)).createServiceInstance(request);
  verify(h2oProvisioner, timeout(200)).provisionInstance(INSTANCE_ID);
}