import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
@Test
public void testCreatingRuntimeEnvironmentInfo() {
	RuntimeEnvironmentInfo rei = new RuntimeEnvironmentInfo.Builder()
			.spiClass(AppDeployer.class)
			.implementationName("TestDeployer")
			.implementationVersion("1.0.0")
			.platformClientVersion("1.2.0")
			.platformHostVersion("1.1.0")
			.platformType("Test")
			.platformApiVersion("1")
			.addPlatformSpecificInfo("foo", "bar")
			.build();
	assertThat(rei.getSpiVersion(), is(RuntimeVersionUtils.getVersion(AppDeployer.class)));
	assertThat(rei.getImplementationName(), is("TestDeployer"));
	assertThat(rei.getImplementationVersion(), is("1.0.0"));
	assertThat(rei.getPlatformType(), is("Test"));
	assertThat(rei.getPlatformApiVersion(), is("1"));
	assertThat(rei.getPlatformClientVersion(), is("1.2.0"));
	assertThat(rei.getPlatformHostVersion(), is("1.1.0"));
	assertThat(rei.getJavaVersion(), is(System.getProperty("java.version")));
	assertThat(rei.getSpringVersion(), is(SpringVersion.getVersion()));
	assertThat(rei.getSpringBootVersion(), is(RuntimeVersionUtils.getSpringBootVersion()));
	assertThat(rei.getPlatformSpecificInfo().get("foo"), is("bar"));
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
@Override
public RuntimeEnvironmentInfo environmentInfo() {
	String apiVersion = "v1";
	String hostVersion = "unknown";
	String frameworkId = "unknown";
	String leader = "unknown";
	try {
		GetServerInfoResponse serverInfo = marathon.getServerInfo();
		hostVersion = serverInfo.getVersion();
		frameworkId = serverInfo.getFrameworkId();
		leader = serverInfo.getLeader();
	} catch (MarathonException ignore) {}
	return new RuntimeEnvironmentInfo.Builder()
			.spiClass(AppDeployer.class)
			.implementationName(this.getClass().getSimpleName())
			.implementationVersion(RuntimeVersionUtils.getVersion(this.getClass()))
			.platformType("Mesos")
			.platformApiVersion(apiVersion)
			.platformClientVersion(RuntimeVersionUtils.getVersion(marathon.getClass()))
			.platformHostVersion(hostVersion)
			.addPlatformSpecificInfo("leader", leader)
			.addPlatformSpecificInfo("frameworkId", frameworkId)
			.build();
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
private RuntimeEnvironmentInfo runtimeEnvironmentInfo(Class spiClass, Class implementationClass) {
	CloudFoundryClient client = connectionConfiguration.cloudFoundryClient(
		connectionConfiguration.connectionContext(connectionConfiguration.cloudFoundryConnectionProperties()),
		connectionConfiguration.tokenProvider(connectionConfiguration.cloudFoundryConnectionProperties()));
	Version version = connectionConfiguration.version(client);
	return new RuntimeEnvironmentInfo.Builder()
		.implementationName(implementationClass.getSimpleName())
		.spiClass(spiClass)
		.implementationVersion(RuntimeVersionUtils.getVersion(CloudFoundryAppDeployer.class))
		.platformType("Cloud Foundry")
		.platformClientVersion(RuntimeVersionUtils.getVersion(client.getClass()))
		.platformApiVersion(version.toString())
		.platformHostVersion("unknown")
		.addPlatformSpecificInfo("API Endpoint", connectionConfiguration.cloudFoundryConnectionProperties().getUrl().toString())
		.build();
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
@Override
public RuntimeEnvironmentInfo environmentInfo() {
	AboutResource skipperInfo = skipperClient.info();
	Resources<Deployer> deployers = skipperClient.listDeployers();
	RuntimeEnvironmentInfo.Builder builder = new RuntimeEnvironmentInfo.Builder()
			.implementationName(skipperInfo.getVersionInfo().getServer().getName())
			.implementationVersion(skipperInfo.getVersionInfo().getServer().getVersion())
			.platformApiVersion("")
			.platformClientVersion("")
			.platformHostVersion("")
			.platformType("Skipper Managed")
			.spiClass(SkipperClient.class);
	for (Deployer d : deployers) {
		builder.addPlatformSpecificInfo(d.getName(), d.getType());
	}
	return builder.build();
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
/**
 * Create the RuntimeEnvironmentInfo.
 *
 * @return the Kubernetes runtime environment info
 */
protected RuntimeEnvironmentInfo createRuntimeEnvironmentInfo(Class spiClass, Class implementationClass) {
	return new RuntimeEnvironmentInfo.Builder()
			.spiClass(spiClass)
			.implementationName(implementationClass.getSimpleName())
			.implementationVersion(RuntimeVersionUtils.getVersion(implementationClass))
			.platformType("Kubernetes")
			.platformApiVersion(client.getApiVersion())
			.platformClientVersion(RuntimeVersionUtils.getVersion(client.getClass()))
			.platformHostVersion("unknown")
			.addPlatformSpecificInfo("master-url", String.valueOf(client.getMasterUrl()))
			.addPlatformSpecificInfo("namespace", client.getNamespace())
			.build();
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
/**
 * Tests support for DeployerEnvironmentInfo is implemented.
 */
@Test
public void testEnvironmentInfo() {
	RuntimeEnvironmentInfo info = appDeployer().environmentInfo();
	assertNotNull(info.getImplementationVersion());
	assertNotNull(info.getPlatformType());
	assertNotNull(info.getPlatformClientVersion());
	assertNotNull(info.getPlatformHostVersion());
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
/**
 * Tests support for DeployerEnvironmentInfo is implemented.
 */
@Test
public void testEnvironmentInfo() {
	RuntimeEnvironmentInfo info = taskLauncher().environmentInfo();
	assertNotNull(info.getImplementationVersion());
	assertNotNull(info.getPlatformType());
	assertNotNull(info.getPlatformClientVersion());
	assertNotNull(info.getPlatformHostVersion());
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
@Override
public RuntimeEnvironmentInfo environmentInfo() {
	String apiVersion = "v1";
	String hostVersion = "unknown";
	return new RuntimeEnvironmentInfo.Builder()
			.spiClass(AppDeployer.class)
			.implementationName(this.getClass().getSimpleName())
			.implementationVersion(RuntimeVersionUtils.getVersion(this.getClass()))
			.platformType("Mesos")
			.platformApiVersion(apiVersion)
			.platformClientVersion(RuntimeVersionUtils.getVersion(chronos.getClass()))
			.platformHostVersion(hostVersion)
			.build();
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
public CloudFoundry2630AndLaterTaskLauncher(CloudFoundryClient client,
											CloudFoundryDeploymentProperties deploymentProperties,
											CloudFoundryOperations operations,
										    RuntimeEnvironmentInfo runtimeEnvironmentInfo) {
	super(client, deploymentProperties, runtimeEnvironmentInfo);
	this.client = client;
	this.deploymentProperties = deploymentProperties;
	this.operations = operations;
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
public CloudFoundryAppDeployer(AppNameGenerator applicationNameGenerator,
	CloudFoundryDeploymentProperties deploymentProperties,
	CloudFoundryOperations operations,
	RuntimeEnvironmentInfo runtimeEnvironmentInfo
) {
	super(deploymentProperties, runtimeEnvironmentInfo);
	this.operations = operations;
	this.applicationNameGenerator = applicationNameGenerator;
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
@Bean
public AboutController aboutController(VersionInfoProperties versionInfoProperties, FeaturesProperties featuresProperties) {
	StreamDeployer streamDeployer = mock(StreamDeployer.class);
	TaskLauncher taskLauncher = mock(TaskLauncher.class);
	RuntimeEnvironmentInfo.Builder builder = new RuntimeEnvironmentInfo.Builder();
	RuntimeEnvironmentInfo appDeployerEnvInfo = builder.implementationName("testAppDepImplementationName").
			implementationVersion("testAppDepImplementationVersion").
			platformType("testAppDepPlatformType").
			platformApiVersion("testAppDepPlatformApiVersion").
			platformClientVersion("testAppDepPlatformClientVersion").spiClass(Class.class).
			platformHostVersion("testAppDepPlatformHostVersion").build();
	RuntimeEnvironmentInfo taskDeployerEnvInfo = builder.implementationName("testTaskDepImplementationName").
			implementationVersion("testTaskDepImplementationVersion").
			platformType("testTaskDepPlatformType").
			platformApiVersion("testTaskDepPlatformApiVersion").
			platformClientVersion("testTaskDepPlatformClientVersion").spiClass(Class.class).
			platformHostVersion("testTaskDepPlatformHostVersion").build();
	if (!featuresProperties.isSkipperEnabled()) {
		when(streamDeployer.environmentInfo()).thenReturn(appDeployerEnvInfo);
	}
	else {
		when(streamDeployer.environmentInfo()).thenThrow(new UnsupportedOperationException());
	}
	when(taskLauncher.environmentInfo()).thenReturn(taskDeployerEnvInfo);
	return new AboutController(streamDeployer, taskLauncher,
			mock(FeaturesProperties.class), versionInfoProperties,
			mock(SecurityStateBean.class));
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
@Override
public RuntimeEnvironmentInfo environmentInfo() {
	return super.createRuntimeEnvironmentInfo(AppDeployer.class, this.getClass());
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
@Override
public RuntimeEnvironmentInfo environmentInfo() {
	return super.createRuntimeEnvironmentInfo(TaskLauncher.class, this.getClass());
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
@Override
public RuntimeEnvironmentInfo environmentInfo() {
	return wrapped.environmentInfo();
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
AbstractCloudFoundryDeployer(CloudFoundryDeploymentProperties deploymentProperties, RuntimeEnvironmentInfo runtimeEnvironmentInfo) {
	this.deploymentProperties = deploymentProperties;
	this.runtimeEnvironmentInfo = runtimeEnvironmentInfo;
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
public RuntimeEnvironmentInfo environmentInfo() {
	return runtimeEnvironmentInfo;
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
public UnsupportedVersionTaskLauncher(Version actualVersion, RuntimeEnvironmentInfo info) {
	this.actualVersion = actualVersion;
	this.info = info;
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
@Override
public RuntimeEnvironmentInfo environmentInfo() {
	return info;
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
AbstractCloudFoundryTaskLauncher(CloudFoundryClient client,
	CloudFoundryDeploymentProperties deploymentProperties,
	RuntimeEnvironmentInfo runtimeEnvironmentInfo) {
	super(deploymentProperties, runtimeEnvironmentInfo);
	this.client = client;
}
 

import org.springframework.cloud.deployer.spi.core.RuntimeEnvironmentInfo; //导入依赖的package包/类
@Override
public RuntimeEnvironmentInfo environmentInfo() {
	return appDeployer.environmentInfo();
}