import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
@Test
public void testInstanceRegistrationUsingProvidedEurekaClient() {
    EurekaClient eurekaClient = mock(EurekaClient.class);
    ApplicationInfoManager applicationInfoManager = mock(ApplicationInfoManager.class);
    EurekaInstanceConfig eurekaInstanceConfig = mock(EurekaInstanceConfig.class);

    when(eurekaClient.getApplicationInfoManager()).thenReturn(applicationInfoManager);
    when(eurekaClient.getApplication(anyString())).thenReturn(new Application(APP_NAME));

    when(applicationInfoManager.getEurekaInstanceConfig()).thenReturn(eurekaInstanceConfig);
    when(eurekaInstanceConfig.getAppname()).thenReturn(APP_NAME);

    // use provided EurekaClient
    EurekaOneDiscoveryStrategyFactory.setEurekaClient(eurekaClient);

    HazelcastInstance hz1 = factory.newHazelcastInstance();
    HazelcastInstance hz2 = factory.newHazelcastInstance();
    
    verify(eurekaClient, times(2)).getApplicationInfoManager();
    verify(eurekaClient, times(2)).getApplication(APP_NAME);
    verify(applicationInfoManager, never()).setInstanceStatus(InstanceStatus.UP);
    verify(applicationInfoManager, never()).setInstanceStatus(any(InstanceStatus.class));

    assertClusterSizeEventually(2, hz1);
    assertClusterSizeEventually(2, hz2);
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
public void register() {
    if (isEurekaDisabled()) {
        logger.info("Eureka is disabled, skipping instance's eureka registration.");
        return;
    }

    if (!registered.compareAndSet(false, true)) {
        logger.info("Eureka handler already registered, skipping registration.");
        return;
    }

    EurekaInstanceConfig eurekaInstanceConfig = createEurekaInstanceConfig();

    initDiscoveryManager(eurekaInstanceConfig, new DefaultEurekaClientConfig(eurekaClientNamespace));
    setEurekaInstanceStatus(InstanceInfo.InstanceStatus.UP);
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
@Before
public void beforeMethod() {
    eurekaIsDisabledPropertySupplierMock = mock(Supplier.class);
    datacenterTypePropertySupplierMock = mock(Supplier.class);
    cloudInstanceConfigMock = mock(CloudInstanceConfig.class);

    doReturn(false).when(eurekaIsDisabledPropertySupplierMock).get();
    doReturn(MyOwn.name()).when(datacenterTypePropertySupplierMock).get();

    handlerSpy = spy(new EurekaHandler(eurekaIsDisabledPropertySupplierMock, datacenterTypePropertySupplierMock));

    doNothing().when(handlerSpy).initDiscoveryManager(any(EurekaInstanceConfig.class),
                                                      any(EurekaClientConfig.class));
    doNothing().when(handlerSpy).shutdownDiscoveryManager();
    doNothing().when(handlerSpy).setEurekaInstanceStatus(any(InstanceStatus.class));
    doReturn(cloudInstanceConfigMock).when(handlerSpy).createCloudInstanceConfig(anyString());
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
@Test
public void register_uses_createEurekaInstanceConfig_then_calls_initDiscoveryManager_with_it_and_sets_instance_status_UP() {
    // given
    EurekaInstanceConfig instanceConfigMock = mock(EurekaInstanceConfig.class);
    doReturn(instanceConfigMock).when(handlerSpy).createEurekaInstanceConfig();
    assertThat(handlerSpy.registered.get()).isFalse();

    // when
    handlerSpy.register();

    // then
    assertThat(handlerSpy.registered.get()).isTrue();
    verify(handlerSpy).createEurekaInstanceConfig();

    ArgumentCaptor<EurekaClientConfig> clientConfigCaptor = ArgumentCaptor.forClass(EurekaClientConfig.class);
    verify(handlerSpy).initDiscoveryManager(eq(instanceConfigMock),
                                            clientConfigCaptor.capture());
    EurekaClientConfig clientConfigUsed = clientConfigCaptor.getValue();
    assertThat(clientConfigUsed).isInstanceOf(DefaultEurekaClientConfig.class);
    assertThat(Whitebox.getInternalState(clientConfigUsed, "namespace")).isEqualTo(handlerSpy.eurekaClientNamespace);

    verify(handlerSpy).setEurekaInstanceStatus(InstanceStatus.UP);
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
@DataProvider(value = {
    "null",
    "MyOwn",
    "not-a-real-datacenter-type"
})
@Test
public void createEurekaInstanceConfig_returns_MyDataCenterInstanceConfig_when_datacenterType_is_null_or_MyOwn_or_invalid(
    String datacenterType
) {
    // given
    doReturn(datacenterType).when(datacenterTypePropertySupplierMock).get();

    // when
    EurekaInstanceConfig instanceConfig = handlerSpy.createEurekaInstanceConfig();

    // then
    assertThat(instanceConfig).isInstanceOf(MyDataCenterInstanceConfig.class);
    assertThat(Whitebox.getInternalState(instanceConfig, "namespace")).isEqualTo(handlerSpy.eurekaClientNamespace);
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
@DataProvider(value = {
    "Amazon",
    "Netflix"
})
@Test
public void createEurekaInstanceConfig_returns_CloudInstanceConfig_when_datacenterType_is_amazon_or_netflix(
    String datacenterType
) {
    // given
    doReturn(datacenterType).when(datacenterTypePropertySupplierMock).get();

    // when
    EurekaInstanceConfig instanceConfig = handlerSpy.createEurekaInstanceConfig();

    // then
    verify(handlerSpy).createCloudInstanceConfig(handlerSpy.eurekaNamespace);
    assertThat(instanceConfig).isSameAs(cloudInstanceConfigMock);
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
private ApplicationInfoManager initializeApplicationInfoManager(DiscoveryNode localNode) {
    EurekaInstanceConfig instanceConfig = buildInstanceConfig(localNode);

    InstanceInfo instanceInfo = new EurekaConfigBasedInstanceInfoProvider(instanceConfig).get();
    ApplicationInfoManager manager = new ApplicationInfoManager(instanceConfig, instanceInfo);
    statusChangeStrategy.update(manager, InstanceInfo.InstanceStatus.STARTING);

    return manager;
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
private EurekaInstanceConfig buildInstanceConfig(DiscoveryNode localNode) {
    try {

        String configProperty = DynamicPropertyFactory
                .getInstance()
                .getStringProperty("eureka.client.props", "eureka-client")
                .get();

        String eurekaPropertyFile = String.format("%s.properties", configProperty);
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        URL url = loader.getResource(eurekaPropertyFile);
        if (url == null) {
            throw new IllegalStateException("Cannot locate " + eurekaPropertyFile + " as a classpath resource.");
        }
        Properties props = new Properties();
        props.load(url.openStream());

        String key = String.format("%s.datacenter", this.namespace);
        String value = props.getProperty(key, "");
        if ("cloud".equals(value.trim().toLowerCase())) {
            return new DelegatingInstanceConfig(new CloudInstanceConfig(this.namespace), localNode);
        }
        return new DelegatingInstanceConfig(new MyDataCenterInstanceConfig(this.namespace), localNode);
    } catch (IOException e) {
        throw new IllegalStateException("Cannot build EurekaInstanceInfo", e);
    }
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
@Test
public void register_does_nothing_if_eureka_is_disabled() {
    // given
    doReturn(true).when(eurekaIsDisabledPropertySupplierMock).get();

    // when
    handlerSpy.register();

    // then
    verify(handlerSpy, never()).createEurekaInstanceConfig();
    verify(handlerSpy, never()).initDiscoveryManager(any(EurekaInstanceConfig.class),
                                                     any(EurekaClientConfig.class));
    verify(handlerSpy, never()).setEurekaInstanceStatus(any(InstanceStatus.class));
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
@Test
public void register_does_nothing_if_already_registered() {
    // given
    handlerSpy.registered.set(true);

    // when
    handlerSpy.register();

    // then
    verify(handlerSpy, never()).createEurekaInstanceConfig();
    verify(handlerSpy, never()).initDiscoveryManager(any(EurekaInstanceConfig.class),
                                                     any(EurekaClientConfig.class));
    verify(handlerSpy, never()).setEurekaInstanceStatus(any(InstanceStatus.class));
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
@Override
public void start() throws Exception {
   EurekaClientConfiguration eurekaClientConfiguration = configuration.getEureka();
   ServerFactory serverFactory = configuration.getServerFactory();

   BaseConfiguration baseConfiguration = new BaseConfiguration();
   baseConfiguration.setProperty(eurekaNamespace + "name", eurekaClientConfiguration.getName());
   baseConfiguration.setProperty(eurekaNamespace + "vipAddress", eurekaClientConfiguration.getVipAddress());
   baseConfiguration.setProperty(eurekaNamespace + "serviceUrl.default", eurekaClientConfiguration.getDefaultServiceUrl());
   baseConfiguration.setProperty(eurekaNamespace + "port", eurekaClientConfiguration.getPort());

   Integer port = DropwizardServerHelpers.getPort(serverFactory);
   Integer adminPort = DropwizardServerHelpers.getAdminPort(serverFactory);

   baseConfiguration.setProperty(eurekaNamespace + "healthCheckUrl", String.format("http://${eureka.hostname}:%d/healthcheck", adminPort));
   baseConfiguration.setProperty(eurekaNamespace + "secureHealthCheckUrl", String.format("http://${eureka.hostname}:%d/healthcheck", adminPort));
   baseConfiguration.setProperty(eurekaNamespace + "statusPageUrl", String.format("http://${eureka.hostname}:%d/healthcheck", adminPort));
   ConfigurationManager.loadPropertiesFromConfiguration(baseConfiguration);

   EurekaInstanceConfig eurekaInstanceConfig = createEurekaInstanceConfig(discoveryMetadataProviders);

   DiscoveryManager.getInstance().initComponent(eurekaInstanceConfig, new DefaultEurekaClientConfig(eurekaNamespace));

   DiscoveryManager.getInstance().getDiscoveryClient().registerHealthCheckCallback(healthCheck);

   markAsUp();
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
protected EurekaInstanceConfig createEurekaInstanceConfig(Collection<DiscoveryMetadataProvider> discoveryMetadataProviders) {
   if(datacenterType.toLowerCase().equals("developer")) {
      return new DeveloperMachineDataCenterInstanceConfig(eurekaNamespace, discoveryMetadataProviders);
   }
   if(datacenterType.toLowerCase().equals("amazon")) {
      // return new CloudInstanceConfig(eurekaNamespace);
   }
   // return new MyDataCenterInstanceConfig(eurekaNamespace);
   throw new RuntimeException("TODO: Make other InstanceConfig's work with metadata providers.");
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
public EurekaRibbonClientConfiguration(EurekaClientConfig clientConfig,
		String serviceId, EurekaInstanceConfig eurekaConfig,
		boolean approximateZoneFromHostname) {
	this.clientConfig = clientConfig;
	this.serviceId = serviceId;
	this.eurekaConfig = eurekaConfig;
	this.approximateZoneFromHostname = approximateZoneFromHostname;
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
public EurekaHealthIndicator(EurekaClient eurekaClient,
		EurekaInstanceConfig instanceConfig, EurekaClientConfig clientConfig) {
	super();
	this.eurekaClient = eurekaClient;
	this.instanceConfig = instanceConfig;
	this.clientConfig = clientConfig;
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(value = ApplicationInfoManager.class, search = SearchStrategy.CURRENT)
public ApplicationInfoManager eurekaApplicationInfoManager(
		EurekaInstanceConfig config) {
	InstanceInfo instanceInfo = new InstanceInfoFactory().create(config);
	return new ApplicationInfoManager(config, instanceInfo);
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
@ConditionalOnEnabledHealthIndicator("eureka")
public EurekaHealthIndicator eurekaHealthIndicator(EurekaClient eurekaClient,
												   EurekaInstanceConfig instanceConfig, EurekaClientConfig clientConfig) {
	return new EurekaHealthIndicator(eurekaClient, instanceConfig, clientConfig);
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的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 com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
private DelegatingInstanceConfig(EurekaInstanceConfig instanceConfig, DiscoveryNode localNode) {
    this.instanceConfig = instanceConfig;
    this.localNode = localNode;
    this.uuid = UuidUtil.newSecureUuidString();
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
@SuppressWarnings("deprecation")
protected void initDiscoveryManager(EurekaInstanceConfig eurekaInstanceConfig,
                                    EurekaClientConfig eurekaClientConfig) {
    DiscoveryManager.getInstance().initComponent(eurekaInstanceConfig, eurekaClientConfig);
}
 

import com.netflix.appinfo.EurekaInstanceConfig; //导入依赖的package包/类
/***
 * Initializes Eureka Client Library (aka DiscoveryManager)
 *
 * @return discovery manager bean
 */
@Bean(destroyMethod = "shutdownComponent")
public DiscoveryManager eurekaDiscoveryManager(MetadataCollector metadataCollector) {
    final DiscoveryManager bean = DiscoveryManager.getInstance();
    if (!disableEureka) {
        // set eureka.port via http.port if not already set
        int httpPort = ConfigurationManager.getConfigInstance().getInt("http.port",-1);
        int httpsPort = ConfigurationManager.getConfigInstance().getInt("https.port",-1);
        int eurekaPort = ConfigurationManager.getConfigInstance().getInt("eureka.port",-1);
        int eurekaSecurePort = ConfigurationManager.getConfigInstance().getInt("eureka.securePort",-1);
        boolean httpPortEnabled = ConfigurationManager.getConfigInstance().getBoolean("http.enabled", false);
        boolean httpsPortEnabled = ConfigurationManager.getConfigInstance().getBoolean("https.enabled", false);
        if (httpPort != -1 && eurekaPort == -1) {
            ConfigurationManager.getConfigInstance().setProperty("eureka.port", httpPort);
            ConfigurationManager.getConfigInstance().setProperty("eureka.port.enabled", httpPortEnabled);
        }
        if(httpsPort != -1 && eurekaSecurePort == -1){
            ConfigurationManager.getConfigInstance().setProperty("eureka.securePort", httpsPort);
            ConfigurationManager.getConfigInstance().setProperty("eureka.securePort.enabled", httpsPortEnabled);
        }

        // set eureka.name and eureka.vipAddress with @SpringApp name if not already set
        String appName = ConfigurationManager.getConfigInstance().getString("app.name",null);
        String eurekaName = ConfigurationManager.getConfigInstance().getString("eureka.name",null);
        String eurekaVip = ConfigurationManager.getConfigInstance().getString("eureka.vipAddress",null);
        String eurekaSecureVipAddress = ConfigurationManager.getConfigInstance().getString("eureka.secureVipAddress",null);
        if (appName != null && eurekaName == null) {
            ConfigurationManager.getConfigInstance().setProperty("eureka.name", appName);
        }
        if (appName != null && eurekaVip == null) {
            ConfigurationManager.getConfigInstance().setProperty("eureka.vipAddress", appName);
        }
        if (appName != null && eurekaSecureVipAddress == null) {
            ConfigurationManager.getConfigInstance().setProperty("eureka.secureVipAddress", appName);
        }

        // initialize DiscoveryManager if it hasn't already been done
        if (ApplicationInfoManager.getInstance().getInfo() == null) {
            EurekaInstanceConfig config;
            switch (datacenter.toLowerCase()) {
                case "amazon":
                case "cloud":
                    config = new KixeyeCloudInstanceConfig(metadataCollector);
                    break;
                default:
                    config = new KixeyeMyDataCenterInstanceConfig(metadataCollector);
                    break;
            }
            bean.initComponent(config, new DefaultEurekaClientConfig());
        }
    }
    return bean;
}