Java ServiceInstanceExistsException类代码示例

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的package包/类
@Test
public void provisionTest_kerberosEnabled_createsDBAddGrants()
    throws ServiceBrokerException, ServiceInstanceExistsException {
  //given
  when(hiveBindingClient.isKerberosEnabled()).thenReturn(true);
  HiveShared toTest = new HiveShared(hiveBindingClient, jdbcOperations);

  //when
  toTest.provision(getServiceInstance("04d4e5d2-0568-11e6-8d01-00155d3d2c21"));

  //then
  InOrder inOrder = inOrder(jdbcOperations);
  inOrder.verify(jdbcOperations)
      .execute("create database if not exists `04d4e5d2_0568_11e6_8d01_00155d3d2c21`");
  inOrder.verify(jdbcOperations)
      .execute("GRANT ALL ON DATABASE `04d4e5d2_0568_11e6_8d01_00155d3d2c21` "
               + "TO ROLE `f0487d90-fde6-4da1-a933-03f38776115d`");
}
 

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的package包/类
@Override
public ServiceInstance createServiceInstance(CreateServiceInstanceRequest request) throws ServiceInstanceExistsException, ServiceBrokerException {
    DbDumperServiceInstance dbDumperServiceInstance = repository.findOne(request.getServiceInstanceId());
    if (dbDumperServiceInstance != null && !dbDumperServiceInstance.isDeleted()) {
        throw new ServiceInstanceExistsException(new ServiceInstance(request));
    }
    DbDumperPlan dbDumperPlan = dbDumperPlanRepo.findOne(request.getPlanId());
    if (dbDumperPlan == null) {
        throw new ServiceBrokerException("Plan '" + request.getPlanId() + "' is not available.");
    }
    if (dbDumperServiceInstance != null && dbDumperServiceInstance.isDeleted()) {
        dbDumperServiceInstance.setDeleted(false);
    }
    if (dbDumperServiceInstance == null) {
        dbDumperServiceInstance = new DbDumperServiceInstance(
                request.getServiceInstanceId(),
                request.getPlanId(),
                request.getOrganizationGuid(),
                request.getSpaceGuid(),
                appUri + DASHBOARD_ROUTE,
                dbDumperPlan);
    }

    this.createDump(request.getParameters(), dbDumperServiceInstance);
    return new ServiceInstance(request).withDashboardUrl(appUri + DASHBOARD_ROUTE + dbDumperServiceInstance.getServiceInstanceId()).withAsync(true);
}
 

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的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.exception.ServiceInstanceExistsException; //导入依赖的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.exception.ServiceInstanceExistsException; //导入依赖的package包/类
@Override
public void provision(ServiceInstance serviceInstance, Optional<Map<String, Object>> parameters)
    throws ServiceInstanceExistsException, ServiceBrokerException {
  if (!isMapNotNullAndNotEmpty(parameters)) {
    throw new ServiceBrokerException("This plan require parametere uri");
  }
  String uri =
      getParameterUri(parameters.get(), URI_KEY).orElseThrow(
          () -> new ServiceBrokerException("No required parameter uri")).toString();
  LOGGER.info("Detected parameter path: " + uri);

  HdfsBrokerInstancePath instance = HdfsBrokerInstancePath.createInstance(uri);
  credentialsStore.save(
      ImmutableMap.<String, Object>builder()
          .putAll(credentialsStore.get(instance.getInstanceId())).put(URI_KEY, uri).build(),
      UUID.fromString(serviceInstance.getServiceInstanceId()));
}
 

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的package包/类
@Override
public void provision(ServiceInstance serviceInstance)
    throws ServiceInstanceExistsException, ServiceBrokerException {
  operations.execute(String.format("create database if not exists `%s`",
                                   DbNameNormalizer.create().
                                       normalize(serviceInstance.getServiceInstanceId())));

  if (bindingOperations.isKerberosEnabled()) {
    operations.execute(String.format("GRANT ALL ON DATABASE `%s` TO ROLE `%s`",
                                     DbNameNormalizer.create().
                                         normalize(serviceInstance.getServiceInstanceId()),
                                     serviceInstance.getOrganizationGuid()));
  }
}
 

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的package包/类
@Test
public void provisionTest_kerberosDisabled_createsDB()
    throws ServiceBrokerException, ServiceInstanceExistsException {
  //given
  when(hiveBindingClient.isKerberosEnabled()).thenReturn(false);
  HiveShared toTest = new HiveShared(hiveBindingClient, jdbcOperations);

  //when
  toTest.provision(getServiceInstance("04d4e5d2-0568-11e6-8d01-00155d3d2c21"));

  //then
  verify(jdbcOperations, only())
      .execute("create database if not exists `04d4e5d2_0568_11e6_8d01_00155d3d2c21`");
}
 

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的package包/类
@Test
public void when_unsupported_database_type_is_passed_it_should_give_back_a_message_to_say_its_not_supported() throws ServiceInstanceExistsException, ServiceBrokerAsyncRequiredException {
    CreateServiceInstanceRequest instanceRequest = serviceBrokerRequestForge.createNewDumpRequest("hdfs://my.db.com/mydb", "instance-1");
    try {
        this.dbDumperServiceInstanceService.createServiceInstance(instanceRequest);
        fail("It should raise an ServiceBrokerException");
    } catch (ServiceBrokerException e) {
        assertThat(e.getMessage()).contains("The database driver 'hdfs' is not supported");
    }
}
 

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的package包/类
@Test
public void when_a_service_name_passed_not_exists_it_should_give_back_a_message_to_say_it() throws ServiceInstanceExistsException, ServiceBrokerAsyncRequiredException {
    serviceBrokerRequestForge.setOrg("org");
    serviceBrokerRequestForge.setOrgGuid("org-1");
    serviceBrokerRequestForge.setSpace("space");
    serviceBrokerRequestForge.setSpaceGuid("space-1");
    serviceBrokerRequestForge.setUserToken("usertoken");
    CreateServiceInstanceRequest instanceRequest = serviceBrokerRequestForge.createNewDumpRequest(CloudFoundryClientFake.SERVICE_NOT_ACCESSIBLE, "instance-1");
    try {
        this.dbDumperServiceInstanceService.createServiceInstance(instanceRequest);
        fail("It should raise an ServiceBrokerException");
    } catch (ServiceBrokerException e) {
        assertThat(e.getMessage()).contains("User don't have access to service '" + CloudFoundryClientFake.SERVICE_NOT_ACCESSIBLE + "'");
    }
}
 

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的package包/类
@Test
public void when_creating_dump_from_non_existing_service_which_already_exist_it_should_raise_an_exception() {
    when(repository.findOne(anyString())).thenReturn(dbDumperServiceInstance);
    try {
        instanceService.createServiceInstance(createRequest);
        fail("Should throw an ServiceInstanceExistsException");
    } catch (Exception e) {
        assertThat(e).isInstanceOf(ServiceInstanceExistsException.class);
    }
}
 

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的package包/类
@Test
public void when_creating_dump_from_non_existing_service_with_target_parameter_it_should_return_a_service_instance() throws ServiceBrokerException, ServiceInstanceExistsException {
    when(repository.findOne(anyString())).thenReturn(null);
    params.put("db", targetDatabase);
    ServiceInstance serviceInstance = instanceService.createServiceInstance(createRequest);
    assertServiceInstanceCreateRequest(serviceInstance);
}
 

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的package包/类
@Override
public ServiceInstance createServiceInstance(CreateServiceInstanceRequest request)
        throws ServiceInstanceExistsException, ServiceBrokerException {

    PersistableServiceInstance psi = new PersistableServiceInstance(
            request.getServiceDefinitionId(),
            request.getPlanId(), request.getOrganizationGuid(),
            request.getSpaceGuid(), request.getServiceInstanceId());

    return this.serviceInstanceRepository.save(psi);

}
 

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的package包/类
@Override
public ServiceInstance createServiceInstance(
		CreateServiceInstanceRequest request)
		throws ServiceInstanceExistsException, ServiceBrokerException,
		ServiceBrokerAsyncRequiredException {

	String id = request.getServiceInstanceId();
	log(id, "Creating service instance", IN_PROGRESS);
	throwIfDuplicate(id);
	throwIfSync(request);

	ServiceInstance instance = null;

	if (PRODUCTION.equals(request.getPlanId())) {
		instance = new ServiceInstance(request).isAsync(false)
				.withLastOperation(
						new ServiceInstanceLastOperation("Provisioned",
								OperationState.SUCCEEDED));
		instanceManager.saveInstance(instance, sourceInstanceId);
	} else {
		instance = new ServiceInstance(request).isAsync(true)
				.withLastOperation(
						new ServiceInstanceLastOperation(
								"Creating instance",
								OperationState.IN_PROGRESS));
		instanceManager.saveInstance(instance, null);
		provision(request, id, instance);
	}
	return instance;
}
 

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的package包/类
private void throwIfDuplicate(String id)
		throws ServiceInstanceExistsException {
	if (null != instanceManager.getInstance(id)) {
		log(id, "Duplicate service instance requested", FAILED);
		throw new ServiceInstanceExistsException(
				instanceManager.getInstance(id));
	}
}
 

import org.cloudfoundry.community.servicebroker.exception.ServiceInstanceExistsException; //导入依赖的package包/类
@Before
public void setUp() throws ServiceInstanceExistsException,
		ServiceBrokerException {
	MockitoAnnotations.initMocks(this);
	service = new LCServiceInstanceService(copyProvider, dataProvider,
			"source_instance_id", brokerRepo, instanceManager,
			new SyncTaskExecutor(), dataProviderService);

}