Java DeleteServiceInstanceRequest类代码示例

import org.cloudfoundry.community.servicebroker.model.DeleteServiceInstanceRequest; //导入依赖的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.DeleteServiceInstanceRequest; //导入依赖的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.DeleteServiceInstanceRequest; //导入依赖的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.DeleteServiceInstanceRequest; //导入依赖的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.DeleteServiceInstanceRequest; //导入依赖的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.DeleteServiceInstanceRequest; //导入依赖的package包/类
@Test
public void deleteServiceInstancePlanShared_instanceCreated_getReturnsNull() throws Exception {
  //arrange
  String serviceInstanceId = UUID.randomUUID().toString();
  ServiceInstance instance = getServiceInstance(serviceInstanceId, "fakeBaseGuid-shared-plan");
  CreateServiceInstanceRequest request = getCreateInstanceRequest(instance);
  serviceBean.createServiceInstance(request);

  //act
  DeleteServiceInstanceRequest deleteRequest = getDeleteInstanceRequest(instance);
  serviceBean.deleteServiceInstance(deleteRequest);

  //assert
  ServiceInstance serviceInstance = serviceBean.getServiceInstance(serviceInstanceId);
  assertThat(serviceInstance, is(nullValue()));
}
 

import org.cloudfoundry.community.servicebroker.model.DeleteServiceInstanceRequest; //导入依赖的package包/类
@Test
public void testDeleteServiceInstance_success_shouldReturnRemovedInstance() throws Exception {
  ServiceInstance instance =
      instanceService.createServiceInstance(getCreateInstanceRequest("instanceId3",
                                                                     "multitenant-plan"));
  ServiceInstance removedInstance =
      instanceService.deleteServiceInstance(
          new DeleteServiceInstanceRequest(instance.getServiceInstanceId(),
                                           instance.getServiceDefinitionId(),
                                           instance.getPlanId())
      );
  assertThat(instance.getServiceInstanceId(), equalTo(removedInstance.getServiceInstanceId()));
}
 

import org.cloudfoundry.community.servicebroker.model.DeleteServiceInstanceRequest; //导入依赖的package包/类
@Override
public ServiceInstance deleteServiceInstance(DeleteServiceInstanceRequest request) throws ServiceBrokerException, ServiceBrokerAsyncRequiredException {
    ServiceInstance serviceInstance = new ServiceInstance(request);
    serviceInstance.withAsync(false);
    serviceInstance.withDashboardUrl(appUri);
    if (!this.oauthRegServiceInstanceRepo.exists(request.getServiceInstanceId())) {
        logger.warn("The service instance '" + request.getServiceInstanceId() + "' doesn't exist. Defaulting to say to cloud controller that instance is deleted.");
    }
    this.oauthRegServiceInstanceRepo.delete(request.getServiceInstanceId());
    return serviceInstance;
}
 

import org.cloudfoundry.community.servicebroker.model.DeleteServiceInstanceRequest; //导入依赖的package包/类
@Override
public ServiceInstance deleteServiceInstance(DeleteServiceInstanceRequest request)
        throws ServiceBrokerException {
    PersistableServiceInstance instance = this.serviceInstanceRepository
            .findOne(request.getServiceInstanceId());
    if (null != instance)
        this.serviceInstanceRepository.delete(instance);
    return instance;
}
 

import org.cloudfoundry.community.servicebroker.model.DeleteServiceInstanceRequest; //导入依赖的package包/类
private void throwIfSync(DeleteServiceInstanceRequest request)
		throws ServiceBrokerAsyncRequiredException {
	if (!request.hasAsyncClient()) {
		throw new ServiceBrokerAsyncRequiredException(
				"Lifecycle broker requires an async CloudController");
	}
}
 

import org.cloudfoundry.community.servicebroker.model.DeleteServiceInstanceRequest; //导入依赖的package包/类
@Test
public void itDeletesWhatItShould() throws Exception {
	createServiceInstance();
	String id = instance.getServiceInstanceId();
	when(instanceManager.getInstance(id)).thenReturn(instance);
	when(instanceManager.removeInstance(id)).thenReturn(instance);
	when(instanceManager.getCopyIdForInstance(id)).thenReturn(
			"copy_instance");
	assertThat(
			service.deleteServiceInstance(new DeleteServiceInstanceRequest(
					id, instance.getServiceDefinitionId(), instance
							.getPlanId(), true)), is(equalTo(instance)));
	verify(copyProvider).deleteCopy("copy_instance");
	verify(instanceManager).removeInstance(instance.getServiceInstanceId());
}
 

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

	createServiceInstance();
	String id = instance.getServiceInstanceId();
	when(instanceManager.getInstance(id)).thenReturn(instance);
	when(instanceManager.removeInstance(id)).thenReturn(instance);

	assertNotNull(service
			.deleteServiceInstance(new DeleteServiceInstanceRequest(id,
					"serviceId", PRODUCTION, true)));
	verifyZeroInteractions(copyProvider);
}
 

import org.cloudfoundry.community.servicebroker.model.DeleteServiceInstanceRequest; //导入依赖的package包/类
@Test
public void itShouldDocumentItsInFlightDeleteActions() throws Exception {
	createServiceInstance();
	service.deleteServiceInstance(new DeleteServiceInstanceRequest(instance
			.getServiceInstanceId(), "serviceId", PRODUCTION, true));
	verify(brokerRepo, times(3)).save(any(BrokerAction.class));
}
 

import org.cloudfoundry.community.servicebroker.model.DeleteServiceInstanceRequest; //导入依赖的package包/类
@Override
public ServiceInstance deleteServiceInstance(DeleteServiceInstanceRequest deleteServiceInstanceRequest)
        throws ServiceBrokerException {
    String serviceInstanceId = deleteServiceInstanceRequest.getServiceInstanceId();
    ServiceInstance instance = getServiceInstance(serviceInstanceId);

    try {
        db.deleteDatabase(serviceInstanceId);
        role.deleteRole(serviceInstanceId);
    } catch (SQLException e) {
        logger.error("Error while deleting service instance '" + serviceInstanceId + "'", e);
        throw new ServiceBrokerException(e.getMessage());
    }
    return instance;
}
 

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

  String killedJob = h2oProvisioner.deprovisionInstance(serviceInstanceId);
  LOGGER.info("Killed YARN job: " + killedJob + " for H2O instance " + serviceInstanceId
      + ". H2O deleted.");
  return serviceInstance;
}