import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Before
public void setup() {
	eurekaHttpClient = new RestTemplateTransportClientFactory()
			.newClient(new DefaultEndpoint(serviceUrl));

	EurekaInstanceConfigBean config = new EurekaInstanceConfigBean(inetUtils);

	String appname = "customapp";
	config.setIpAddress("127.0.0.1");
	config.setHostname("localhost");
	config.setAppname(appname);
	config.setVirtualHostName(appname);
	config.setSecureVirtualHostName(appname);
	config.setNonSecurePort(4444);
	config.setSecurePort(8443);
	config.setInstanceId("127.0.0.1:customapp:4444");

	info = new EurekaConfigBasedInstanceInfoProvider(config).get();
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Override
   public ManagementMetadata get(EurekaInstanceConfigBean instance, int serverPort,
                                 String serverContextPath, String managementContextPath,
                                 Integer managementPort) {
	if (isRandom(managementPort)) {
		return null;
	}
	if (managementPort == null && isRandom(serverPort)) {
		return null;
	}
       String healthCheckUrl = getHealthCheckUrl(instance, serverPort, serverContextPath,
               managementContextPath, managementPort);
       String statusPageUrl = getStatusPageUrl(instance, serverPort, serverContextPath,
               managementContextPath, managementPort);

       return new ManagementMetadata(healthCheckUrl, statusPageUrl, managementPort == null ? serverPort : managementPort);
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Test
@Ignore
public void basicConfigurationCreatedForLoadBalancer() {
	EurekaClientConfigBean client = new EurekaClientConfigBean();
	EurekaInstanceConfigBean configBean = getEurekaInstanceConfigBean();
	client.getAvailabilityZones().put(client.getRegion(), "foo");
	SpringClientFactory clientFactory = new SpringClientFactory();
	EurekaRibbonClientConfiguration clientPreprocessor = new EurekaRibbonClientConfiguration(
			client, "service", configBean, false);
	clientPreprocessor.preprocess();
	ILoadBalancer balancer = clientFactory.getLoadBalancer("service");
	assertNotNull(balancer);
	@SuppressWarnings("unchecked")
	ZoneAwareLoadBalancer<DiscoveryEnabledServer> aware = (ZoneAwareLoadBalancer<DiscoveryEnabledServer>) balancer;
	assertTrue(aware.getServerListImpl() instanceof DomainExtractingServerList);
	assertEquals("foo",
			ConfigurationManager.getDeploymentContext().getValue(ContextKey.zone));
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Test
public void testSetProp() {
	EurekaClientConfigBean client = new EurekaClientConfigBean();
	EurekaInstanceConfigBean configBean = getEurekaInstanceConfigBean();
	EurekaRibbonClientConfiguration preprocessor = new EurekaRibbonClientConfiguration(
			client, "myService", configBean, false);
	String serviceId = "myService";
	String suffix = "mySuffix";
	String value = "myValue";
	DynamicStringProperty property = getProperty(getRibbonKey(serviceId, suffix));
	assertEquals("property doesn't have default value", VALUE_NOT_SET,
			property.get());
	setRibbonProperty(serviceId, suffix, value);
	assertEquals("property has wrong value", value, property.get());
	setRibbonProperty(serviceId, suffix, value);
	assertEquals("property has wrong value", value, property.get());
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Test
public void eurekaClientNotShutdownInDeregister() {
	EurekaServiceRegistry registry = new EurekaServiceRegistry();

	CloudEurekaClient eurekaClient = mock(CloudEurekaClient.class);
	ApplicationInfoManager applicationInfoManager = mock(ApplicationInfoManager.class);

	when(applicationInfoManager.getInfo()).thenReturn(mock(InstanceInfo.class));

	EurekaRegistration registration = EurekaRegistration.builder(new EurekaInstanceConfigBean(new InetUtils(new InetUtilsProperties())))
			.with(eurekaClient)
			.with(applicationInfoManager)
			.with(new EurekaClientConfigBean(), mock(ApplicationEventPublisher.class))
			.build();

	registry.deregister(registration);

	verifyZeroInteractions(eurekaClient);
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@RequestMapping(path = "/register", method = POST)
public String register() {
	EurekaInstanceConfigBean config = new EurekaInstanceConfigBean(inetUtils);
	String appname = "customapp";
	config.setIpAddress("127.0.0.1");
	config.setHostname("localhost");
	config.setAppname(appname);
	config.setVirtualHostName(appname);
	config.setSecureVirtualHostName(appname);
	config.setNonSecurePort(4444);
	config.setInstanceId("127.0.0.1:customapp:4444");

	this.registration = EurekaRegistration.builder(config)
			.with(this.clientConfig, this.context)
			.build();

	this.serviceRegistry.register(this.registration);
	return config.getInstanceId();
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Bean
/**
 * Dynamically assign the hosts IP address to this instances of the Eureka Client
 *
 * @param  inetUtils  Java Networks Utilities
 * @return	An instance of a EurekaInstanceConfigBean with dynamically configured IP address
 */
public EurekaInstanceConfigBean eurekaInstanceConfig(InetUtils inetUtils){
    EurekaInstanceConfigBean config = new EurekaInstanceConfigBean(inetUtils);

    String ip = null;
    String urlPattern = "http://{0}:{1}{2}";

    try {
        // Get the IP address of the current host using Java Network Utils
        ip = InetAddress.getLocalHost().getHostAddress();
    } catch (UnknownHostException e) {
        e.printStackTrace();
    }

    config.setIpAddress(ip);
    config.setPreferIpAddress(true);

    // Build the Status Page URL specific to this instances IP Address
    String statusPageUrl = MessageFormat.format(urlPattern,
            config.getIpAddress(),
            port,
            config.getStatusPageUrlPath());
    config.setStatusPageUrl(statusPageUrl);

    // Build the Health Page URL specific to this instances IP Address
    String healthPageUrl = MessageFormat.format(urlPattern,
            config.getIpAddress(),
            port,
            config.getHealthCheckUrlPath());
    config.setHealthCheckUrl(healthPageUrl);

    return config;
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
public LoggingConfiguration(@Value("${spring.application.name}") String appName, @Value("${server.port}") String serverPort,
    EurekaInstanceConfigBean eurekaInstanceConfigBean, JHipsterProperties jHipsterProperties, @Value("${info.project.version}") String version) {
    this.appName = appName;
    this.serverPort = serverPort;
    this.eurekaInstanceConfigBean = eurekaInstanceConfigBean;
    this.jHipsterProperties = jHipsterProperties;
    this.version = version;
    if (jHipsterProperties.getLogging().getLogstash().isEnabled()) {
        addLogstashAppender(context);
        addContextListener(context);
    }
    if (jHipsterProperties.getMetrics().getLogs().isEnabled()) {
        setMetricsMarkerLogbackFilter(context);
    }
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
public InstanceInfo getInstanceInfo(Application application) {
	EurekaInstanceConfigBean instanceConfig = new EurekaInstanceConfigBean(inetUtils);
	instanceConfig.setInstanceEnabledOnit(true);
	instanceConfig.setAppname(application.getName());
	instanceConfig.setVirtualHostName(application.getName());
	instanceConfig.setInstanceId(application.getInstance_id());
	instanceConfig.setHostname(application.getHostname());
	instanceConfig.setNonSecurePort(application.getPort());

	return new InstanceInfoFactory().create(instanceConfig);
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
private String getHealthCheckUrl(EurekaInstanceConfigBean instance, int serverPort, String serverContextPath,
                                 String managementContextPath, Integer managementPort) {
    String healthCheckUrlPath = instance.getHealthCheckUrlPath();
    String healthCheckUrl = getUrl(instance, serverPort, serverContextPath, managementContextPath,
            managementPort, healthCheckUrlPath);
    log.debug("Constructed eureka meta-data healthcheckUrl: " + healthCheckUrl);
    return healthCheckUrl;
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
public String getStatusPageUrl(EurekaInstanceConfigBean instance, int serverPort, String serverContextPath,
                               String managementContextPath, Integer managementPort) {
    String statusPageUrlPath = instance.getStatusPageUrlPath();
    String statusPageUrl = getUrl(instance, serverPort, serverContextPath, managementContextPath,
            managementPort, statusPageUrlPath);
    log.debug("Constructed eureka meta-data statusPageUrl: " + statusPageUrl);
    return statusPageUrl;
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
private String getUrl(EurekaInstanceConfigBean instance, int serverPort,
                      String serverContextPath, String managementContextPath,
                      Integer managementPort, String urlPath) {
    managementContextPath = refineManagementContextPath(serverContextPath, managementContextPath, managementPort);
    if (managementPort == null) {
        managementPort = serverPort;
    }
    String scheme = instance.getSecurePortEnabled() ? "https" : "http";
    return constructValidUrl(scheme, instance.getHostname(), managementPort, managementContextPath, urlPath);
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Test
public void testExplicitZone() {
	EurekaClientConfigBean client = new EurekaClientConfigBean();
	EurekaInstanceConfigBean configBean = getEurekaInstanceConfigBean();
	configBean.getMetadataMap().put("zone", "myZone");
	EurekaRibbonClientConfiguration preprocessor = new EurekaRibbonClientConfiguration(
			client, "myService", configBean, false);
	preprocessor.preprocess();
	assertEquals("myZone",
			ConfigurationManager.getDeploymentContext().getValue(ContextKey.zone));
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Test
public void testDefaultZone() {
	EurekaClientConfigBean client = new EurekaClientConfigBean();
	EurekaInstanceConfigBean configBean = getEurekaInstanceConfigBean();
	EurekaRibbonClientConfiguration preprocessor = new EurekaRibbonClientConfiguration(
			client, "myService", configBean, false);
	preprocessor.preprocess();
	assertEquals("defaultZone",
			ConfigurationManager.getDeploymentContext().getValue(ContextKey.zone));
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Test
public void testApproximateZone() {
	EurekaClientConfigBean client = new EurekaClientConfigBean();
	EurekaInstanceConfigBean configBean = getEurekaInstanceConfigBean();
	configBean.setHostname("this.is.a.test.com");
	EurekaRibbonClientConfiguration preprocessor = new EurekaRibbonClientConfiguration(
			client, "myService", configBean, true);
	preprocessor.preprocess();
	assertEquals("is.a.test.com",
			ConfigurationManager.getDeploymentContext().getValue(ContextKey.zone));
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Test
public void eurekaClientGetStatus() {
	EurekaServiceRegistry registry = new EurekaServiceRegistry();

	EurekaInstanceConfigBean config = new EurekaInstanceConfigBean(new InetUtils(new InetUtilsProperties()));
	config.setAppname("myapp");
	config.setInstanceId("1234");

	CloudEurekaClient eurekaClient = mock(CloudEurekaClient.class);

	InstanceInfo instanceInfo = InstanceInfo.Builder.newBuilder()
			.setAppName("myapp")
			.setInstanceId("1234")
			.setStatus(DOWN)
			.setOverriddenStatus(UNKNOWN)
			.build();
	when(eurekaClient.getInstanceInfo("myapp", "1234"))
			.thenReturn(instanceInfo);

	EurekaRegistration registration = EurekaRegistration.builder(config)
			.with(eurekaClient)
			.with(mock(ApplicationInfoManager.class))
			.with(new EurekaClientConfigBean(), mock(ApplicationEventPublisher.class))
			.build();

	Object status = registry.getStatus(registration);

	assertThat(status).isInstanceOf(Map.class);

	Map<Object, Object> map = (Map<Object, Object>) status;

	assertThat(map).hasSize(2)
			.containsEntry("status", DOWN.toString())
			.containsEntry("overriddenStatus", UNKNOWN.toString());
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Test
public void eurekaClientGetStatusNoInstance() {
	EurekaServiceRegistry registry = new EurekaServiceRegistry();

	EurekaInstanceConfigBean config = new EurekaInstanceConfigBean(new InetUtils(new InetUtilsProperties()));
	config.setAppname("myapp");
	config.setInstanceId("1234");

	CloudEurekaClient eurekaClient = mock(CloudEurekaClient.class);

	when(eurekaClient.getInstanceInfo("myapp", "1234"))
			.thenReturn(null);

	EurekaRegistration registration = EurekaRegistration.builder(config)
			.with(eurekaClient)
			.with(mock(ApplicationInfoManager.class))
			.with(new EurekaClientConfigBean(), mock(ApplicationEventPublisher.class))
			.build();

	Object status = registry.getStatus(registration);

	assertThat(status).isInstanceOf(Map.class);

	Map<Object, Object> map = (Map<Object, Object>) status;

	assertThat(map).hasSize(1)
			.containsEntry("status", UNKNOWN.toString());
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Test
public void offByDefault() {
	new ApplicationContextRunner().withConfiguration(
		AutoConfigurations.of(EurekaClientConfigServerAutoConfiguration.class))
		.run(c -> {
			assertEquals(0,
				c.getBeanNamesForType(EurekaInstanceConfigBean.class).length);
		});
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Test
public void onWhenRequested() {
	new ApplicationContextRunner()
		.withConfiguration(AutoConfigurations.of(
			EurekaClientConfigServerAutoConfiguration.class,
			ConfigServerProperties.class, EurekaInstanceConfigBean.class))
		.withPropertyValues("spring.cloud.config.server.prefix=/config")
		.run(c -> {
			assertEquals(1,
				c.getBeanNamesForType(EurekaInstanceConfig.class).length);
			EurekaInstanceConfig instance = c.getBean(EurekaInstanceConfig.class);
			assertEquals("/config", instance.getMetadataMap().get("configPath"));
		});
}
 

import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; //导入依赖的package包/类
@Bean
public EurekaInstanceConfigBean eurekaInstanceConfigBean() {
	EurekaInstanceConfigBean config = new EurekaInstanceConfigBean(inetUtils);
	String springAppName = this.env.getProperty("spring.application.name", "");
	int port = this.sidecarProperties.getPort();
	config.setNonSecurePort(port);
	config.setInstanceId(getDefaultInstanceId(this.env));
	if (StringUtils.hasText(springAppName)) {
		config.setAppname(springAppName);
		config.setVirtualHostName(springAppName);
		config.setSecureVirtualHostName(springAppName);
	}
	String hostname = this.sidecarProperties.getHostname();
	String ipAddress = this.sidecarProperties.getIpAddress();
	if (!StringUtils.hasText(hostname) && StringUtils.hasText(this.hostname)) {
		hostname = this.hostname;
	}
	if (StringUtils.hasText(hostname)) {
		config.setHostname(hostname);
	}
	if (StringUtils.hasText(ipAddress)) {
		config.setIpAddress(ipAddress);
	}
	String scheme = config.getSecurePortEnabled() ? "https" : "http";
	config.setStatusPageUrl(scheme + "://" + config.getHostname() + ":"
			+ this.managementPort + config.getStatusPageUrlPath());
	config.setHealthCheckUrl(scheme + "://" + config.getHostname() + ":"
			+ this.managementPort + config.getHealthCheckUrlPath());
	config.setHomePageUrl(scheme + "://" + config.getHostname() + ":" + port
			+ config.getHomePageUrlPath());
	return config;
}