Java CloudDomain类代码示例

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
/**
 * 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 cloudDomain : getDomainsForOrg()) {
        orphanRoutes.addAll(fetchOrphanRoutes(cloudDomain.getName()));
    }

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

    return deletedCloudRoutes;
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
private void prepareClient() throws Exception {
    CloudDomain domain = mock(CloudDomain.class);
    CloudInfo info;
    if (input.portBasedRouting) {
        info = mock(CloudInfoExtended.class);
        when(((CloudInfoExtended) info).isPortBasedRouting()).thenReturn(true);
    } else {
        info = mock(CloudInfo.class);
    }

    if (info instanceof CloudInfoExtended)
        when(((CloudInfoExtended) info).getDeployServiceUrl()).thenReturn(input.deployServiceUrl);

    when(clientProvider.getPortAllocator(any(), anyString())).thenReturn(portAllocator);

    when(info.getAuthorizationEndpoint()).thenReturn(input.authorizationEndpoint);
    when(domain.getName()).thenReturn(input.defaultDomain);
    when(domain.getMeta()).thenReturn(new Meta(CLOUD_DOMAIN_GUID, null, null));

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

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
/**
 * Either returns a valid, available Cloud Application URL with the given
 * subdomain, or throws {@link CoreException} if unable to generate valid
 * URL.
 * @param subDomain
 * @return Non-null, valid Cloud Application URL using an existing domain.
 */
public CloudApplicationURL getDefaultApplicationURL(String subDomain) throws CoreException {

	List<CloudDomain> domains = getDomains();
	if (domains == null || domains.isEmpty()) {

		throw CloudErrorUtil.toCoreException(NLS.bind(
				Messages.ApplicationUrlLookupService_ERROR_GETDEFAULT_APP_URL,
				cloudServer.getServerId(), subDomain));
	}

	CloudApplicationURL appURL = validateCloudApplicationUrl(new CloudApplicationURL(subDomain, domains.get(0)
			.getName()));

	return appURL;
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
public List<CloudDomain> getDomainsForOrg(CloudOrganization org) {
	List<CloudDomain> domains = new ArrayList<CloudDomain>();
	String urlPath = API_BASE+"/organizations/"+org.getMeta().getGuid().toString()+"/domains";
	try {
		List<JSONObject> ja = ResponseObject.getResources(urlPath, token);
		for (JSONObject resource : ja) {
			JSONObject meta = resource.getJSONObject(METADATA);
			JSONObject entity = resource.getJSONObject(ENTITY);
			domains.add(new CloudDomain(new Meta(meta),entity.getString("name"),org));
		}
	}
	catch (Throwable t) {
		t.printStackTrace();
	}
	return domains;
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
@Override
public CloudDomain getDefaultDomain() {
    List<CloudDomain> sharedDomains = getSharedDomains();
    if (sharedDomains.isEmpty()) {
        return null;
    } else {
        return sharedDomains.get(0);
    }
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
private List<CloudDomain> doGetDomains(CloudOrganization org) {
    Map<String, Object> urlVars = new HashMap<String, Object>();
    String urlPath = "/v2";
    if (org != null) {
        urlVars.put("org", org.getMeta().getGuid());
        urlPath = urlPath + "/organizations/{org}";
    }
    urlPath = urlPath + "/domains";
    return doGetDomains(urlPath, urlVars);
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
private CloudRoute mapRouteResource(Map<String, Object> resource) {
    @SuppressWarnings("unchecked")
    List<Object> apps = getEntityAttribute(resource, "apps", List.class);
    String host = getEntityAttribute(resource, "host", String.class);
    CloudDomain domain = mapDomainResource(getEmbeddedResource(resource, "domain"));
    return new CloudRoute(getMeta(resource), host, domain, apps.size());
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
@Test
public void getDomains() {
    connectedClient.addDomain(TEST_DOMAIN);

    List<CloudDomain> allDomains = connectedClient.getDomains();

    assertNotNull(getDomainNamed(defaultDomainName, allDomains));
    assertNotNull(getDomainNamed(TEST_DOMAIN, allDomains));
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
private void clearTestDomainAndRoutes() {
    CloudDomain domain = getDomainNamed(TEST_DOMAIN, connectedClient.getDomains());
    if (domain != null) {
        List<CloudRoute> routes = connectedClient.getRoutes(domain.getName());
        for (CloudRoute route : routes) {
            connectedClient.deleteRoute(route.getHost(), route.getDomain().getName());
        }
        connectedClient.deleteDomain(domain.getName());
    }
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
private CloudDomain getDomainNamed(String domainName, List<CloudDomain> domains) {
    for (CloudDomain domain : domains) {
        if (domain.getName().equals(domainName)) {
            return domain;
        }
    }
    return null;
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
private String getDefaultDomain(CloudFoundryOperations client) {
    CloudDomain defaultDomain = client.getDefaultDomain();
    if (defaultDomain != null) {
        return defaultDomain.getName();
    }
    return null;
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
private List<String> getDomainNames(List<CloudDomain> domains) {
    List<String> domainNames = new ArrayList<>();
    for (CloudDomain domain : domains) {
        domainNames.add(domain.getName());
    }
    return domainNames;
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
private List<CloudDomain> getExistingDomainsList() {
    List<CloudDomain> result = new ArrayList<>();
    for (String existingDomain : existingDomains) {
        result.add(new CloudDomain(null, existingDomain, null));
    }
    return result;
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
@Test
public void testDeleteAllocatedRoutes1() throws Exception {
    Mockito.when(clientProvider.getCloudFoundryClient(USER, ORG, SPACE, null)).thenReturn(client);
    Mockito.when(client.getDefaultDomain()).thenReturn(new CloudDomain(null, DEFAULT_DOMAIN, null));
    Mockito.doThrow(CloudFoundryException.class).when(client).deleteRoute(Integer.toString(1), DEFAULT_DOMAIN);
    Mockito.doThrow(CloudFoundryException.class).when(client).deleteRoute(Integer.toString(3), DEFAULT_DOMAIN);

    allocatedPorts = new TreeSet<>(Arrays.asList(1, 2, 3, 4));

    abortListener.deleteAllocatedRoutes(mock(HistoryService.class), PROCESS_INSTANCE_ID);

    Mockito.verify(client).deleteRoute(Integer.toString(2), DEFAULT_DOMAIN);
    Mockito.verify(client).deleteRoute(Integer.toString(4), DEFAULT_DOMAIN);
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
protected String getDomain() throws CoreException {
	if (applicationDomain == null) {

		List<CloudDomain> domains = getBehaviour().getDomainsForSpace(new NullProgressMonitor());

		// Get a default domain
		applicationDomain = domains.get(0).getName();
		applicationDomain = applicationDomain.replace("http://", "");
	}
	return applicationDomain;
}