import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
@Override
public List<CloudSpace> getSpacesBoundToSecurityGroup(String securityGroupName) {
    Map<String, Object> urlVars = new HashMap<String, Object>();
    // Need to go a few levels out to get the Organization that Spaces needs
    String urlPath = "/v2/security_groups?q=name:{name}&inline-relations-depth=2";
    urlVars.put("name", securityGroupName);
    List<Map<String, Object>> resourceList = getAllResources(urlPath, urlVars);
    List<CloudSpace> spaces = new ArrayList<CloudSpace>();
    if (resourceList.size() > 0) {
        Map<String, Object> resource = resourceList.get(0);

        Map<String, Object> securityGroupResource = CloudEntityResourceMapper.getEntity(resource);
        List<Map<String, Object>> spaceResources = CloudEntityResourceMapper.getEmbeddedResourceList(securityGroupResource, "spaces");
        for (Map<String, Object> spaceResource : spaceResources) {
            spaces.add(resourceMapper.mapResource(spaceResource, CloudSpace.class));
        }
    } else {
        throw new CloudFoundryException(HttpStatus.NOT_FOUND, "Not Found", "Security group '" + securityGroupName + "' not found.");
    }
    return spaces;
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
public void saveToken(URI target, OAuth2AccessToken token, CloudInfo cloudInfo, CloudSpace space) {
    TargetInfos targetInfos = getTokensFromFile();

    if (targetInfos == null) {
        targetInfos = new TargetInfos();
    }

    HashMap<String, String> targetInfo = targetInfos.get(target);

    if (targetInfo == null) {
        targetInfo = new LinkedHashMap<String, String>();
    }

    targetInfos.putToken(targetInfo, token);
    targetInfos.putRefreshToken(targetInfo, token.getRefreshToken());
    targetInfos.putVersion(targetInfo, cloudInfo.getVersion());
    targetInfos.putSpace(targetInfo, space.getMeta().getGuid().toString());
    targetInfos.putOrganization(targetInfo, space.getOrganization().getMeta().getGuid().toString());

    targetInfos.put(target, targetInfo);

    saveTokensToFile(targetInfos);
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
@Test
public void createGetAndDeleteSpaceOnCurrentOrg() throws Exception {
    String spaceName = "dummy space";
    CloudSpace newSpace = connectedClient.getSpace(spaceName);
    assertNull("Space '" + spaceName + "' should not exist before creation", newSpace);
    connectedClient.createSpace(spaceName);
    newSpace = connectedClient.getSpace(spaceName);
    assertNotNull("newSpace should not be null", newSpace);
    assertEquals(spaceName, newSpace.getName());
    boolean foundSpaceInCurrentOrg = false;
    for (CloudSpace aSpace : connectedClient.getSpaces()) {
        if (spaceName.equals(aSpace.getName())) {
            foundSpaceInCurrentOrg = true;
        }
    }
    assertTrue(foundSpaceInCurrentOrg);
    connectedClient.deleteSpace(spaceName);
    CloudSpace deletedSpace = connectedClient.getSpace(spaceName);
    assertNull("Space '" + spaceName + "' should not exist after deletion", deletedSpace);

}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
private CloudSpace attemptToFindSpace(String spaceId) {
    try {
        return new SpaceGetterFactory().createSpaceGetter().getSpace(client, spaceId);
    } catch (CloudFoundryException e) {
        // From our point of view 403 means the same as 404 - the user does not have access to a space, so it is like it does not exist
        // for him.
        if (e.getStatusCode().equals(HttpStatus.FORBIDDEN)) {
            LOGGER.debug(MessageFormat.format("The user does not have access to space with ID {0}!", spaceId));
            return null;
        }
        if (e.getStatusCode().equals(HttpStatus.NOT_FOUND)) {
            LOGGER.debug(MessageFormat.format("Space with ID {0} does not exist!", spaceId));
            return null;
        }
        throw e;
    }
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
private void setUpMocks() {
    DefaultOAuth2AccessToken accessToken = new DefaultOAuth2AccessToken("testTokenValue");
    accessToken.setScope(new HashSet<>());
    CloudSpace space = new CloudSpace(null, SPACE, new CloudOrganization(null, ORG));
    List<CloudSpace> spaces = new ArrayList<>();
    if (hasAccess) {
        spaces.add(space);
    }

    userInfo = new UserInfo(USER_ID, USERNAME, accessToken);
    List<String> spaceDevelopersList = new ArrayList<>();
    if (hasPermissions) {
        spaceDevelopersList.add(USER_ID);
    }
    when(client.getSpaces()).thenReturn(spaces);
    when(client.getSpaceDevelopers2(ORG, SPACE)).thenReturn(spaceDevelopersList);
    when(clientProvider.getCloudFoundryClient(userInfo.getToken())).thenReturn(client);
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
@Bean(name = "cloudFoundryClientAsAdmin")
public CloudFoundryClient getCloudFoundryClientAsAdmin() throws MalformedURLException {
    if (this.cfAdminUser == null
            || this.cfAdminUser.isEmpty()
            || this.cfAdminPassword == null
            || this.cfAdminPassword.isEmpty()
            || this.cloudControllerUrl == null
            || this.cloudControllerUrl.isEmpty()
            || this.noCloudFoundryAccess) {
        return null;
    }
    CloudOrganization cloudOrganization = this.getOrg();
    CloudSpace cloudSpace = this.getSpace();
    if (cloudOrganization == null || cloudSpace == null) {
        return null;
    }
    logger.info(String.format("Creating new CloudFoundry client using admin access with org '%s' and space '%s'", cloudOrganization.getName(), cloudSpace.getName()));
    return cloudFoundryClientFactory.createCloudFoundryClient(this.cfAdminUser, this.cfAdminPassword, this.cloudControllerUrl, cloudOrganization.getName(), cloudSpace.getName());
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
@Bean(name = "cloudFoundryClientAsAdmin")
public CloudFoundryClient getCloudFoundryClientAsAdmin() throws MalformedURLException {
    if (this.cfAdminUser == null
            || this.cfAdminUser.isEmpty()
            || this.cfAdminPassword == null
            || this.cfAdminPassword.isEmpty()
            || this.cloudControllerUrl == null
            || this.cloudControllerUrl.isEmpty()
            || this.noCloudFoundryAccess) {
        return null;
    }
    CloudOrganization cloudOrganization = this.getOrg();
    CloudSpace cloudSpace = this.getSpace();
    if (cloudOrganization == null || cloudSpace == null) {
        return null;
    }
    logger.debug(String.format("Creating new CloudFoundry client using admin access with org '%s' and space '%s'", cloudOrganization.getName(), cloudSpace.getName()));
    return cloudFoundryClientFactory.createCloudFoundryClient(this.cfAdminUser, this.cfAdminPassword, this.cloudControllerUrl, cloudOrganization.getName(), cloudSpace.getName());
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
protected void setCloudSpace(CloudFoundryServer cloudServer, String orgName, String spaceName)
		throws CoreException {
	CloudOrgsAndSpaces spaces = CFUiUtil.getCloudSpaces(cloudServer, cloudServer.getUsername(),
			cloudServer.getPassword(), cloudServer.getUrl(), false, cloudServer.isSelfSigned(), null, false,
			null, null);
	Assert.isTrue(spaces != null, "Failed to resolve orgs and spaces.");
	Assert.isTrue(spaces.getDefaultCloudSpace() != null,
			"No default space selected in cloud space lookup handler.");

	CloudSpace cloudSpace = spaces.getSpace(orgName, spaceName);
	if (cloudSpace == null) {
		throw CloudErrorUtil.toCoreException(
				"Failed to resolve cloud space when running junits: " + orgName + " - " + spaceName);
	}
	cloudServer.setSpace(cloudSpace);
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
protected IStatus validateCurrent(CloudSpace currentSpace) {
	int severity = IStatus.OK;
	String validationMessage = Messages.VALID_ACCOUNT;
	CloudSpacesDescriptor descriptor = getCurrentSpacesDescriptor();
	if (descriptor == null || descriptor.getOrgsAndSpaces() == null) {
		validationMessage = Messages.ERROR_CHECK_CONNECTION_NO_SPACES;
		severity = IStatus.ERROR;
	}
	else if (getSpaceWithNoServerInstance() == null) {
		validationMessage = Messages.ERROR_ALL_SPACES_ASSOCIATED_SERVER_INSTANCES;
		severity = IStatus.ERROR;
	}
	else {
		return validateSpaceSelection(currentSpace);
	}
	return CloudFoundryPlugin.getStatus(validationMessage, severity);
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
CloneServerPage(CloudFoundryServer server) {
	super(server, null);

	cloudServerSpaceDelegate = new CloudSpacesDelegate(cloudServer) {

		@Override
		public void setSelectedSpace(CloudSpace selectedCloudSpace) {

			CloneServerPage.this.selectedSpace = selectedCloudSpace;
			CloneServerPage.this.setServerNameInUI(getSuggestedServerName(selectedCloudSpace));
		}

		@Override
		protected CloudSpace getCurrentCloudSpace() {
			return selectedSpace;
		}
	};
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
protected String getSuggestedServerName(CloudSpace selectedCloudSpace) {

		if (selectedCloudSpace == null) {
			return null;
		}

		String suggestedName = selectedCloudSpace.getName();

		int i = 1;

		while (nameExists(suggestedName)) {
			int openParIndex = suggestedName.indexOf('(');
			int closeParIndex = suggestedName.indexOf(')');
			if (openParIndex > 0 && closeParIndex > openParIndex) {
				suggestedName = suggestedName.substring(0, openParIndex).trim();
			}
			suggestedName += " (" + i++ + ")"; //$NON-NLS-1$ //$NON-NLS-2$
		}
		return suggestedName;
	}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
protected void setValues() {
	orgIDtoSpaces = new HashMap<String, List<CloudSpace>>();
	orgIDtoOrg = new HashMap<String, CloudOrganization>();
	// Parse the orgs and restructure the spaces per org for quick lookup,
	// as the original list of spaces is flat and does
	// not convey the org -> spaces structure.
	for (CloudSpace clSpace : originalSpaces) {
		CloudOrganization org = clSpace.getOrganization();
		List<CloudSpace> spaces = orgIDtoSpaces.get(org.getName());
		if (spaces == null) {
			spaces = new ArrayList<CloudSpace>();
			orgIDtoSpaces.put(org.getName(), spaces);
			orgIDtoOrg.put(org.getName(), org);
		}

		spaces.add(clSpace);
	}
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
public CFClientV1Support(CloudFoundryOperations cfClient, CloudSpace existingSessionConnection, CFInfo cloudInfo,
		HttpProxyConfiguration httpProxyConfiguration, CloudFoundryServer cfServer, boolean trustSelfSigned) {
	this.cloudInfo = cloudInfo;
	this.oauth = getHeaderProvider(cfClient);
	this.existingSessionConnection = existingSessionConnection;

	this.restTemplate = RestUtils.createRestTemplate(httpProxyConfiguration, trustSelfSigned, true);
	ClientHttpRequestFactory requestFactory = restTemplate.getRequestFactory();
	restTemplate.setRequestFactory(authorize(requestFactory));

	this.tokenUrl = cloudInfo.getTokenUrl();
	
	this.authorizationUrl = cloudInfo.getAuthorizationUrl();
	
	this.cfServer = cfServer;
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
public void setSpace(CloudSpace space) {

		secureStoreDirty = true;

		if (space != null) {
			this.cloudSpace = new CloudFoundrySpace(space);
			internalSetOrg(cloudSpace.getOrgName());
			internalSetSpace(cloudSpace.getSpaceName());
		}
		else {
			// Otherwise clear the org and space
			internalSetOrg(null);
			internalSetSpace(null);
			cloudSpace = null;
		}

		updateServerId();
	}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
public CloudFoundryOperations getCloudFoundryOperations(CloudCredentials credentials, URL url, CloudSpace session,
		boolean selfSigned) {

	// Proxies are always updated on each client call by the
	// CloudFoundryServerBehaviour Request as well as the client login
	// handler
	// therefore it is not critical to set the proxy in the client on
	// client
	// creation

	HttpProxyConfiguration proxyConfiguration = getProxy(url);
	//@ TODO tentatively set selfSigned = true
	selfSigned = true;
	return session != null ? new CloudFoundryClient(credentials, url, session, selfSigned)
			: new CloudFoundryClient(credentials, url, proxyConfiguration, selfSigned);
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
public List<CloudSpace> getSpaces() {
	List<CloudSpace> spaces = new ArrayList<CloudSpace>();
	String urlPath = API_BASE+"/spaces?inline-relations-depth=1";
	try {
		List<JSONObject> jspaces = ResponseObject.getResources(urlPath, token);
		for (JSONObject jspace : jspaces) {
			JSONObject entity = jspace.getJSONObject(ENTITY);
			Meta meta = new Meta(jspace.getJSONObject(METADATA));
			JSONObject orgEntity = entity.getJSONObject("organization");
			CloudOrganization org = new CloudOrganization(orgEntity.getJSONObject(METADATA),
					orgEntity.getJSONObject(ENTITY));
			CloudSpace space = new CloudSpace(meta,entity.getString("name"),org);
			spaces.add(space);
		}

	} 
	catch (Throwable e) {
		e.printStackTrace();
	} 
	return spaces;
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
public CloudControllerClientImpl(URL cloudControllerUrl, RestTemplate restTemplate, OauthClient oauthClient,
    LoggregatorClient loggregatorClient, CloudCredentials cloudCredentials, CloudSpace sessionSpace) {
    logger = LogFactory.getLog(getClass().getName());

    initialize(cloudControllerUrl, restTemplate, oauthClient, loggregatorClient, cloudCredentials);

    this.sessionSpace = sessionSpace;
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
@Override
public CloudSpace getSpace(String spaceName, boolean required) {
    Map<String, Object> resource = findSpaceResource(spaceName);
    CloudSpace space = null;
    if (resource != null) {
        space = resourceMapper.mapResource(resource, CloudSpace.class);
    }
    if (space == null && required) {
        throw new CloudFoundryException(HttpStatus.NOT_FOUND, "Not Found", "Space '" + spaceName + "' not found.");
    }
    return space;
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
@Override
public List<CloudSpace> getSpaces() {
    String urlPath = "/v2/spaces?inline-relations-depth=1";
    List<Map<String, Object>> resourceList = getAllResources(urlPath);
    List<CloudSpace> spaces = new ArrayList<CloudSpace>();
    for (Map<String, Object> resource : resourceList) {
        spaces.add(resourceMapper.mapResource(resource, CloudSpace.class));
    }
    return spaces;
}
 

import org.cloudfoundry.client.lib.domain.CloudSpace; //导入依赖的package包/类
private CloudSpace validateSpaceAndOrg(String spaceName, String orgName, CloudControllerClientImpl client) {
    List<CloudSpace> spaces = client.getSpaces();

    for (CloudSpace space : spaces) {
        if (space.getName().equals(spaceName)) {
            CloudOrganization org = space.getOrganization();
            if (orgName == null || org.getName().equals(orgName)) {
                return space;
            }
        }
    }

    throw new IllegalArgumentException("No matching organization and space found for org: " + orgName + " space: " + "" + spaceName);
}