org.cloudfoundry.client.lib.domain.CloudDomain Java Examples

public CloudRoute mapRouteResource(Map<String, Object> resource) {
    @SuppressWarnings("unchecked")
    List<Object> apps = getResourceAttribute(resource, "apps", List.class);
    String host = getResourceAttribute(resource, "host", String.class);
    String path = getResourceAttribute(resource, "path", String.class);
    boolean hasBoundService = getResourceAttribute(resource, "service_instance_guid", String.class) != null;
    CloudDomain domain = mapDomainResource(getEmbeddedResource(resource, "domain"));
    return ImmutableCloudRoute.builder()
                              .metadata(getMetadata(resource))
                              .host(host)
                              .domain(domain)
                              .path(path)
                              .appsUsingRoute(apps.size())
                              .hasServiceUsingRoute(hasBoundService)
                              .build();
}
 

@Override
protected StepPhase executeStep(ProcessContext context) {
    List<String> customDomains = context.getVariable(Variables.CUSTOM_DOMAINS);
    getStepLogger().debug("Custom domains: " + customDomains);
    if (customDomains.isEmpty()) {
        return StepPhase.DONE;
    }

    getStepLogger().debug(Messages.ADDING_DOMAINS);

    CloudControllerClient client = context.getControllerClient();

    List<CloudDomain> existingDomains = client.getDomains();
    List<String> existingDomainNames = getDomainNames(existingDomains);
    getStepLogger().debug("Existing domains: " + existingDomainNames);

    addDomains(client, customDomains, existingDomainNames);

    getStepLogger().debug(Messages.DOMAINS_ADDED);
    return StepPhase.DONE;
}
 

/**
 * Delete routes that do not have any application which is assigned to them.
 *
 * @return deleted routes or an empty list if no routes have been found
 */
@Override
public List<CloudRoute> deleteOrphanedRoutes() {
    List<CloudRoute> orphanRoutes = new ArrayList<>();
    for (CloudDomain domain : getDomainsForOrganization()) {
        orphanRoutes.addAll(fetchOrphanRoutes(domain.getName()));
    }

    List<CloudRoute> deletedRoutes = new ArrayList<>();
    for (CloudRoute orphanRoute : orphanRoutes) {
        deleteRoute(orphanRoute.getHost(), orphanRoute.getDomain()
                                                      .getName(),
                    orphanRoute.getPath());
        deletedRoutes.add(orphanRoute);
    }
    return deletedRoutes;
}
 

@Override
public CloudDomain derive() {
    Domain resource = getResource();
    return ImmutableCloudDomain.builder()
                               .metadata(parseResourceMetadata(resource))
                               .name(resource.getName())
                               .build();
}
 

private List<CloudDomain> getExistingDomainsList() {
    List<CloudDomain> result = new ArrayList<>();
    for (String existingDomain : existingDomains) {
        result.add(ImmutableCloudDomain.builder()
                                       .name(existingDomain)
                                       .build());
    }
    return result;
}
 

private static CloudRoute createCloudRoute(String host, CloudDomain domain, String path) {
    return ImmutableCloudRoute.builder()
                              .host(host)
                              .domain(domain)
                              .path(path)
                              .build();
}
 

private Mono<Derivable<CloudRoute>> zipWithAuxiliaryRouteContent(Tuple2<? extends Resource<RouteEntity>, CloudDomain> routeTuple) {
    UUID routeGuid = getGuid(routeTuple.getT1());
    return getRouteMappingResourcesByRouteGuid(routeGuid).collectList()
                                                         .map(routeMappingResources -> ImmutableRawCloudRoute.builder()
                                                                                                             .resource(routeTuple.getT1())
                                                                                                             .domain(routeTuple.getT2())
                                                                                                             .routeMappingResources(routeMappingResources)
                                                                                                             .build());
}
 

@Override
public void deleteDomain(String domainName) {
    assertSpaceProvided("delete domain");
    CloudDomain domain = findDomainByName(domainName, true);
    List<CloudRoute> routes = findRoutes(domain);
    if (!routes.isEmpty()) {
        throw new IllegalStateException("Unable to remove domain that is in use --" + " it has " + routes.size() + " routes.");
    }
    doDeleteDomain(getGuid(domain));
}
 

@Override
public void addDomain(String domainName) {
    assertSpaceProvided("add domain");
    CloudDomain domain = findDomainByName(domainName);
    if (domain == null) {
        doCreateDomain(domainName);
    }
}
 

@Override
public CloudDomain derive() {
    Resource<PrivateDomainEntity> resource = getResource();
    PrivateDomainEntity entity = resource.getEntity();
    return ImmutableCloudDomain.builder()
                               .metadata(parseResourceMetadata(resource))
                               .name(entity.getName())
                               .build();
}
 

public CloudDomain derive() {
    Resource<SharedDomainEntity> resource = getResource();
    SharedDomainEntity entity = resource.getEntity();
    return ImmutableCloudDomain.builder()
                               .metadata(parseResourceMetadata(resource))
                               .name(entity.getName())
                               .build();
}
 

@Override
public CloudDomain derive() {
    Resource<DomainEntity> resource = getResource();
    DomainEntity entity = resource.getEntity();
    return ImmutableCloudDomain.builder()
                               .metadata(parseResourceMetadata(resource))
                               .name(entity.getName())
                               .build();
}
 

private Map<String, UUID> getDomainGuids() {
    List<CloudDomain> availableDomains = new ArrayList<>();
    availableDomains.addAll(getDomainsForOrganization());
    availableDomains.addAll(getSharedDomains());
    Map<String, UUID> domains = new HashMap<>(availableDomains.size());
    for (CloudDomain availableDomain : availableDomains) {
        domains.put(availableDomain.getName(), availableDomain.getMetadata()
                                                              .getGuid());
    }
    return domains;
}
 

private CloudDomain mockDefaultDomain() {
    CloudDomain domain = mock(CloudDomain.class);
    when(domain.getName()).thenReturn(DEFAULT_DOMAIN);
    when(domain.getMetadata()).thenReturn(ImmutableCloudMetadata.builder()
                                                                .guid(DEFAULT_DOMAIN_GUID)
                                                                .build());
    return domain;
}
 

private CloudDomain findDomainByName(String name, boolean required) {
    CloudDomain domain = findDomainByName(name);
    if (domain == null && required) {
        throw new CloudOperationException(HttpStatus.NOT_FOUND, "Not Found", "Domain " + name + " not found.");
    }
    return domain;
}
 

protected void prepareClient() {
    CloudDomain defaultDomain = mockDefaultDomain();
    CloudInfo info = mockInfo();

    when(client.getDefaultDomain()).thenReturn(defaultDomain);
    when(client.getCloudInfo()).thenReturn(info);
}
 

@Override
public List<CloudDomain> getDomains() {
    logger.debug(Messages.GETTING_DOMAINS);
    return delegate.getDomains();
}
 

@Override
public CloudDomain getDefaultDomain() {
    return executeWithRetry(delegate::getDefaultDomain);
}
 

@Override
public List<CloudDomain> getPrivateDomains() {
    return executeWithRetry(delegate::getPrivateDomains, HttpStatus.NOT_FOUND);
}
 

@Override
public List<CloudDomain> getDomains() {
    return executeWithRetry(delegate::getDomains, HttpStatus.NOT_FOUND);
}
 

@Override
public List<CloudDomain> getDomainsForOrganization() {
    return executeWithRetry(delegate::getDomainsForOrganization, HttpStatus.NOT_FOUND);
}
 

private static CloudDomain buildTestDomain() {
    return ImmutableCloudDomain.builder()
                               .metadata(RawCloudEntityTest.EXPECTED_METADATA)
                               .name(DOMAIN_NAME)
                               .build();
}
 

@Override
public CloudDomain getDefaultDomain() {
    logger.debug(Messages.GETTING_DEFAULT_DOMAIN);
    return delegate.getDefaultDomain();
}
 

private List<String> getDomainNames(List<CloudDomain> domains) {
    return domains.stream()
                  .map(CloudDomain::getName)
                  .collect(Collectors.toList());
}
 

public Map<String, UUID> getDomainsAsMap() {
    return getDomains().stream()
                       .collect(Collectors.toMap(CloudDomain::getName, domain -> domain.getMetadata()
                                                                                       .getGuid()));
}
 

public List<CloudDomain> getDomains() {
    return domains;
}
 

private static CloudDomain buildExpectedDomain() {
    return ImmutableCloudDomain.builder()
                               .metadata(RawCloudEntityTest.EXPECTED_METADATA_PARSED_FROM_V3_RESOURCE)
                               .name(DOMAIN_NAME)
                               .build();
}
 

private static CloudDomain buildExpectedDomain() {
    return ImmutableCloudDomain.builder()
                               .metadata(RawCloudEntityTest.EXPECTED_METADATA)
                               .name(DOMAIN_NAME)
                               .build();
}
 

private static CloudDomain buildExpectedDomain() {
    return ImmutableCloudDomain.builder()
                               .metadata(RawCloudEntityTest.EXPECTED_METADATA)
                               .name(DOMAIN_NAME)
                               .build();
}
 

@Override
public CloudDomain getDefaultDomain() {
    return handleExceptions(() -> delegate.getDefaultDomain());
}