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;
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
/**
 * 
 * @return non-null list of Domains.
 */
protected List<String> getDomains() {
	List<String> domains = new ArrayList<String>();
	List<CloudDomain> cloudDomains = lookupService.getDomains();
	if (cloudDomains != null) {
		for (CloudDomain cldm : cloudDomains) {
			domains.add(cldm.getName());
		}
	}
	return domains;
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
protected void updateRoutes() {

			runAsynchWithWizardProgress(new ICoreRunnable() {

				@Override
				public void run(IProgressMonitor monitor) throws CoreException {

					CloudFoundryServerBehaviour behaviour = server.getBehaviour();

					List<CloudDomain> domains = behaviour.getDomainsForSpace(monitor);

					final List<CloudRoute> allRoutes = new ArrayList<CloudRoute>();

					if (domains != null) {
						for (CloudDomain domain : domains) {

							List<CloudRoute> routes = behaviour.getRoutes(domain.getName(), monitor);
							if (routes != null) {
								allRoutes.addAll(routes);

								// Note that fetching routes per domain may be a
								// long running process.
								// Update the UI as routes are fetched to
								// indicate progress to the user (In addition to
								// the progress monitor)
								Display.getDefault().syncExec(new Runnable() {

									public void run() {
										routePart.setInput(allRoutes);
									}

								});
							}
						}
					}

				}

			}, Messages.REFRESHING_DOMAIN_ROUTES);
		}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
public BaseClientRequest<List<CloudDomain>> getDomainsForSpace() throws CoreException {

		return new BehaviourRequest<List<CloudDomain>>(Messages.CloudFoundryServerBehaviour_DOMAINS_FOR_SPACE,
				behaviour) {
			@Override
			protected List<CloudDomain> doRun(CloudFoundryOperations client, SubMonitor progress) throws CoreException {
				return client.getDomains();
			}
		};
	}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
public BaseClientRequest<List<CloudDomain>> getDomainsFromOrgs() throws CoreException {
	return new BehaviourRequest<List<CloudDomain>>("Getting domains for orgs", behaviour) { //$NON-NLS-1$
		@Override
		protected List<CloudDomain> doRun(CloudFoundryOperations client, SubMonitor progress) throws CoreException {
			return client.getDomainsForOrg();
		}
	};
}
 

import org.cloudfoundry.client.lib.domain.CloudDomain; //导入依赖的package包/类
/**
 * Returns cached list of domains. If null or empty, refresh the list of
 * domains separately.
 * @return
 */
public List<CloudDomain> getDomains() {
	synchronized(domainsPerActiveSpaceLock) {
		if(domainsPerActiveSpace == null) {
			try {
				refreshDomains(new NullProgressMonitor());
			}
			catch (CoreException e) {
				// Convert to unchecked exception. 
				throw new RuntimeException(e);
			}
		}
	}
	return domainsPerActiveSpace;
}