Java ServiceDefinition类代码示例

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
@Bean
public Catalog catalog() {
	return new Catalog(Collections.singletonList(
			new ServiceDefinition(
					"mongodb-service-broker",
					"MongoDB",
					"MongoDB service broker implementation for Community Edition",
					true,
					true,
					Collections.singletonList(
							new Plan("mongo-plan",
									"Default Mongo Plan",
									"This is a default mongo plan.  All services are created equally.",
									getPlanMetadata())),
					Arrays.asList("mongodb", "document"),
					getServiceDefinitionMetadata(),
					null,
					null)));
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
private ServiceDefinition getSD(JsonElement json) {
    JsonObject jo = json.getAsJsonObject();

    String id = jo.get("catalogItemId").getAsString();
    String name = jo.get("name").getAsString();
    String description = jo.get("description").getAsString();

    List<Plan> plans = new ArrayList<Plan>();
    plans.add(gson.fromJson(jo, Plan.class));

    Map<String, Object> sdMetadata = new HashMap<String, Object>();
    sdMetadata.put("displayName", name);
    sdMetadata.put("longDescription", description);
    sdMetadata.put("providerDisplayName", "vRealize");

    List<String> tags = new ArrayList<String>();
    tags.add(name);
    tags.add("vRealize");

    return new ServiceDefinition(id, name, description,
            true, false, plans, tags, sdMetadata, null, null);
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
@Test
public void map_service_metadata() {
    //GIVEN
    ServiceMetadataProperties serviceMetadataProperties = new ServiceMetadataProperties();
    serviceMetadataProperties.setDisplayName("aDisplayName");
    serviceMetadataProperties.setLongDescription("a long description");
    serviceMetadataProperties.setProviderDisplayName("a provider");
    serviceMetadataProperties.setDocumentationUrl("http://localhost/doc");
    serviceMetadataProperties.setImageUrl("http://localhost/image.png");
    serviceMetadataProperties.setSupportUrl("http://localhost/support");

    ServiceProperties serviceProperties = new ServiceProperties(SERVICE_ID);
    serviceProperties.setMetadata(serviceMetadataProperties);

    //WHEN
    final ServiceDefinition res = ServiceMapper.toServiceDefinition(serviceProperties);
    //THEN
    assertThat(res.getMetadata()).as("toServiceDefinition serviceProperties metadata").hasSize(6).includes(
            entry("displayName", "aDisplayName"),
            entry("longDescription", "a long description"),
            entry("providerDisplayName", "a provider"),
            entry("documentationUrl", "http://localhost/doc"),
            entry("imageUrl", "http://localhost/image.png"),
            entry("supportUrl", "http://localhost/support"));
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
@Test
public void testEcsBucketPlans() {
    // Service Definition Plans
    ServiceDefinition service = catalog.getServiceDefinitions().get(1);
    List<Plan> ecsBucketPlans = service.getPlans();
    Plan plan0 = ecsBucketPlans.get(0);

    testPlan(plan0, "8e777d49-0a78-4cf4-810a-b5f5173b019d", "5gb",
            "Free Trial", 0.0, "MONTHLY",
            Arrays.asList("Shared object storage", "5 GB Storage",
                    "S3 protocol access"));

    Plan plan1 = ecsBucketPlans.get(1);
    testPlan(plan1, "89d20694-9ab0-4a98-bc6a-868d6d4ecf31", "unlimited",
            "Pay per GB for Month", 0.03, "PER GB PER MONTH",
            Arrays.asList("Shared object storage", "Unlimited Storage",
                    "S3 protocol access"));
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
@Test
public void catalogWithRequiresIsRetrievedCorrectly() throws Exception {
	when(catalogService.getCatalog()).thenReturn(getCatalogWithRequires());

	ServiceDefinition service = ServiceFixture.getServiceWithRequires();

	this.mockMvc.perform(get("/v2/catalog")
			.accept(MediaType.APPLICATION_JSON))
			.andDo(print())
			.andExpect(status().isOk())
			.andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
			.andExpect(jsonPath("$.services", hasSize(1)))
			.andExpect(jsonPath("$.services[*].id", contains(service.getId())))
			.andExpect(jsonPath("$.services[*].name", contains(service.getName())))
			.andExpect(jsonPath("$.services[*].description", contains(service.getDescription())))
			.andExpect(jsonPath("$.services[*].bindable", contains(service.isBindable())))
			.andExpect(jsonPath("$.services[*].plan_updateable", contains(service.isPlanUpdateable())))
			.andExpect(jsonPath("$.services[*].requires[*]", containsInAnyOrder(
					SERVICE_REQUIRES_SYSLOG_DRAIN.toString(),
					SERVICE_REQUIRES_ROUTE_FORWARDING.toString())
			));
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
@Test
@SuppressWarnings("unchecked")
public void catalogIsRetrievedCorrectlyWithCfInstanceId() throws Exception {
	when(catalogService.getCatalog()).thenReturn(getCatalog());

	ServiceDefinition service = ServiceFixture.getSimpleService();
	Plan[] plans = PlanFixture.getAllPlans();

	this.mockMvc.perform(get("/123/v2/catalog")
			.accept(MediaType.APPLICATION_JSON))
			.andDo(print())
			.andExpect(status().isOk())
			.andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
			.andExpect(jsonPath("$.services", hasSize(1)))
			.andExpect(jsonPath("$.services[*].id", contains(service.getId())))
			.andExpect(jsonPath("$.services[*].name", contains(service.getName())))
			.andExpect(jsonPath("$.services[*].description", contains(service.getDescription())))
			.andExpect(jsonPath("$.services[*].bindable", contains(service.isBindable())))
			.andExpect(jsonPath("$.services[*].plan_updateable", contains(service.isPlanUpdateable())))
			.andExpect(jsonPath("$.services[*].requires[*]", empty()))
			.andExpect(jsonPath("$.services[*].plans[*].id", containsInAnyOrder(plans[0].getId(), plans[1].getId())))
			.andExpect(jsonPath("$.services[*].plans[*].name", containsInAnyOrder(plans[0].getName(), plans[1].getName())))
			.andExpect(jsonPath("$.services[*].plans[*].description", containsInAnyOrder(plans[0].getDescription(), plans[1].getDescription())))
			.andExpect(jsonPath("$.services[*].plans[1].metadata", contains(plans[1].getMetadata())))
			.andExpect(jsonPath("$.services[*].plans[*].free", containsInAnyOrder(plans[0].isFree(), plans[1].isFree())));
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
@PutMapping(value = {
		"/{cfInstanceId}/v2/service_instances/{instanceId}",
		"/v2/service_instances/{instanceId}"
})
public ResponseEntity<?> createServiceInstance(@PathVariable Map<String, String> pathVariables,
											   @PathVariable("instanceId") String serviceInstanceId,
											   @RequestParam(value = ASYNC_REQUEST_PARAMETER, required = false) boolean acceptsIncomplete,
											   @RequestHeader(value = API_INFO_LOCATION_HEADER, required = false) String apiInfoLocation,
											   @RequestHeader(value = ORIGINATING_IDENTITY_HEADER, required = false) String originatingIdentityString,
											   @Valid @RequestBody CreateServiceInstanceRequest request) {
	ServiceDefinition serviceDefinition = getRequiredServiceDefinition(request.getServiceDefinitionId());

	request.setServiceInstanceId(serviceInstanceId);
	request.setServiceDefinition(serviceDefinition);
	setCommonRequestFields(request, pathVariables.get("cfInstanceId"), apiInfoLocation,
			originatingIdentityString, acceptsIncomplete);

	log.debug("Creating a service instance: request={}", request);

	CreateServiceInstanceResponse response = service.createServiceInstance(request);

	log.debug("Creating a service instance succeeded: serviceInstanceId={}, response={}",
			serviceInstanceId, response);

	return new ResponseEntity<>(response, getCreateResponseCode(response));
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
@PatchMapping(value = {
		"/{cfInstanceId}/v2/service_instances/{instanceId}",
		"/v2/service_instances/{instanceId}"
})
public ResponseEntity<?> updateServiceInstance(@PathVariable Map<String, String> pathVariables,
											   @PathVariable("instanceId") String serviceInstanceId,
											   @RequestParam(value = ASYNC_REQUEST_PARAMETER, required = false) boolean acceptsIncomplete,
											   @RequestHeader(value = API_INFO_LOCATION_HEADER, required = false) String apiInfoLocation,
											   @RequestHeader(value = ORIGINATING_IDENTITY_HEADER, required = false) String originatingIdentityString,
											   @Valid @RequestBody UpdateServiceInstanceRequest request) {
	ServiceDefinition serviceDefinition = getServiceDefinition(request.getServiceDefinitionId());

	request.setServiceInstanceId(serviceInstanceId);
	request.setServiceDefinition(serviceDefinition);
	setCommonRequestFields(request, pathVariables.get("cfInstanceId"), apiInfoLocation,
			originatingIdentityString, acceptsIncomplete);

	log.debug("Updating a service instance: request={}", request);

	UpdateServiceInstanceResponse response = service.updateServiceInstance(request);

	log.debug("Updating a service instance succeeded: serviceInstanceId={}, response={}",
			serviceInstanceId, response);

	return new ResponseEntity<>(response, response.isAsync() ? HttpStatus.ACCEPTED : HttpStatus.OK);
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
@VisibleForTesting
  public String createBlueprint(ServiceDefinition serviceDefinition, CreateServiceInstanceRequest request) {
      String location = "localhost"; // default
      Plan selectedPlan = null;
      for(Plan p : serviceDefinition.getPlans()){
          if(p.getId().equals(request.getPlanId())){
              selectedPlan = p;
          }
      }

      Map<String, Object> metadata = serviceDefinition.getMetadata();
      String brooklynCatalogId = (String) metadata.get("brooklynCatalogId");
String blueprint = ((BlueprintPlan)selectedPlan).toBlueprint(brooklynCatalogId, location, request);
      LOG.info("launching from blueprint: [blueprint={}]", blueprint);
return blueprint;
  }
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
@Override
public ServiceDefinition getServiceDefinition(String serviceId) {
       try {
           cacheLock.lock();
           if (catalogCache == null) catalogCache = getCatalog();
           for (ServiceDefinition def : catalogCache.getServiceDefinitions()) {
               if (def.getId().equals(serviceId)) {
                   return def;
               }
           }
       } finally {
           cacheLock.unlock();
       }

	return null;
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
@Test
public void testMetadataFromBlueprint() {
    when(admin.getCatalogApplications(Mockito.anyBoolean())).thenReturn(new AsyncResult<>(Arrays.asList(TEST_SUMMARY_WITH_METADATA)));
    when(brooklynConfig.includesAllCatalogVersions()).thenReturn(false);
    List<ServiceDefinition> serviceDefinitions = catalogPlanStrategy.makeServiceDefinitions();
    String expectedKey = "test";
    String expectedValue = "test value";
    Map<String, Object> metadata = serviceDefinitions.get(1).getMetadata();
    assertTrue(metadata.containsKey(expectedKey));
    assertEquals(expectedValue, metadata.get(expectedKey));

    expectedKey = "brooklynCatalogId";
    expectedValue = TEST_SUMMARY_WITH_METADATA.getId();
    assertTrue(metadata.containsKey(expectedKey));
    assertEquals(expectedValue, metadata.get(expectedKey));
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
@Bean
public Catalog catalog() {
	return new Catalog(Collections.singletonList(
			new ServiceDefinition(
					"mongodb-service-broker",
					"mongodb",
					"A simple MongoDB service broker implementation",
					true,
					false,
					Collections.singletonList(
							new Plan("mongo-plan",
									"default",
									"This is a default mongo plan.  All services are created equally.",
									getPlanMetadata())),
					Arrays.asList("mongodb", "document"),
					getServiceDefinitionMetadata(),
					null,
					null)));
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
public ServiceDefinition unproxy() {
    List<Plan> realPlans = null;
    if (plans != null)
        realPlans = plans.stream().map(p -> p.unproxy())
                .collect(Collectors.toList());

    DashboardClient realDashboardClient = null;
    if (dashboardClient != null)
        realDashboardClient = dashboardClient.unproxy();

    return new ServiceDefinition(id, name, description, bindable,
            planUpdatable, realPlans, tags, metadata, requires,
            realDashboardClient);
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
private ServiceDefinition toSuffixedServiceDefinition(ServiceDefinition serviceDefinition) {
    return new ServiceDefinition(withSuffix(serviceDefinition.getId(), serviceOfferingSuffix),
            withSuffix(serviceDefinition.getName(), serviceOfferingSuffix),
            serviceDefinition.getDescription(),
            serviceDefinition.isBindable(),
            serviceDefinition.isPlanUpdateable(),
            serviceDefinition.getPlans()
                    .stream()
                    .map(this::toPlan)
                    .collect(Collectors.toList()),
            serviceDefinition.getTags(),
            serviceDefinition.getMetadata(),
            serviceDefinition.getRequires(),
            serviceDefinition.getDashboardClient());
}
 

import org.springframework.cloud.servicebroker.model.ServiceDefinition; //导入依赖的package包/类
private Catalog expectedCatalog() {
    ArrayList plans = new ArrayList();
    HashMap metadata = new HashMap();
    metadata.put("key1", "value1");
    metadata.put("key2", "value2");
    plans.add(new Plan("plan-one-id-suffix", "Plan One-suffix", "Description for Plan One"));
    plans.add(new Plan("plan-two-id-suffix", "Plan Two-suffix", "Description for Plan Two", metadata));
    List services = Collections.singletonList(new ServiceDefinition("service-one-id-suffix", "Service One-suffix", "Description for Service One", true, plans));
    return new Catalog(services);
}