static void Main(string[] args)
{
// Build application configuration
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.SetBasePath(Environment.CurrentDirectory);
builder.AddJsonFile("appsettings.json");
var configuration = builder.Build();
// Setup logging
var factory = new LoggerFactory();
factory.AddConsole(configuration.GetSection("Logging"));
// Build Eureka clients config from configuration
var clientConfig = new EurekaClientConfig();
ConfigurationBinder.Bind(configuration.GetSection("eureka:client"), clientConfig);
// Build Eureka instance info config from configuration
var instConfig = new EurekaInstanceConfig();
ConfigurationBinder.Bind(configuration.GetSection("eureka:instance"), instConfig);
// Initialize ApplicationManager with instance configuration
ApplicationInfoManager.Instance.Initialize(instConfig, factory);
// Create the Eureka client, the Application is registered and renewed with registry
var client = new DiscoveryClient(clientConfig, null, factory);
// Hang and keep renewing the registration
Console.ReadLine();
}
public async void SendHeartBeatAsync_InvokesServer_ReturnsStatusCodeAndHeaders()
{
var startup = new TestConfigServerStartup("", 200);
var server = TestServer.Create(startup.Configure);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
EurekaInstanceConfig config = new EurekaInstanceConfig()
{
AppName = "foo",
InstanceId = "id1"
};
InstanceInfo info = InstanceInfo.FromInstanceConfig(config);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
EurekaHttpResponse <InstanceInfo> resp = await client.SendHeartBeatAsync("foo", "id1", info, InstanceStatus.UNKNOWN);
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.NotNull(resp.Headers);
Assert.Equal("PUT", startup.LastRequest.Method);
Assert.Equal("localhost:8888", startup.LastRequest.Host.Value);
Assert.Equal("/apps/FOO/id1", startup.LastRequest.Path.Value);
var time = DateTimeConversions.ToJavaMillis(new DateTime(info.LastDirtyTimestamp, DateTimeKind.Utc));
Assert.Equal("?status=STARTING&lastDirtyTimestamp=" + time, startup.LastRequest.QueryString.Value);
}
public async void RegisterAsync_InvokesServer_ReturnsStatusCodeAndHeaders()
{
IHostingEnvironment envir = new HostingEnvironment();
TestConfigServerStartup.Response = "";
TestConfigServerStartup.ReturnStatus = 204;
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
EurekaInstanceConfig config = new EurekaInstanceConfig();
InstanceInfo info = InstanceInfo.FromInstanceConfig(config);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
EurekaHttpResponse resp = await client.RegisterAsync(info);
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.NoContent, resp.StatusCode);
Assert.NotNull(resp.Headers);
}
public void FromConfig_Correct()
{
EurekaInstanceConfig config = new EurekaInstanceConfig();
LeaseInfo info = LeaseInfo.FromConfig(config);
Assert.Equal(config.LeaseRenewalIntervalInSeconds, info.RenewalIntervalInSecs);
Assert.Equal(config.LeaseExpirationDurationInSeconds, info.DurationInSecs);
}
public void StatusChanged_ChangesStatus()
{
EurekaInstanceConfig config = new EurekaInstanceConfig();
ApplicationInfoManager.Instance.Initialize(config);
Assert.Equal(InstanceStatus.STARTING, ApplicationInfoManager.Instance.InstanceStatus);
ApplicationInfoManager.Instance.InstanceStatus = InstanceStatus.UP;
}
public void Initialize_Initializes_InstanceInfo()
{
EurekaInstanceConfig config = new EurekaInstanceConfig();
ApplicationInfoManager.Instance.Initialize(config);
Assert.NotNull(ApplicationInfoManager.Instance.InstanceConfig);
Assert.Equal(config, ApplicationInfoManager.Instance.InstanceConfig);
Assert.NotNull(ApplicationInfoManager.Instance.InstanceInfo);
}
public void ToJsonInstance_DefaultInstanceConfig_Correct()
{
EurekaInstanceConfig config = new EurekaInstanceConfig();
InstanceInfo info = InstanceInfo.FromInstanceConfig(config);
Assert.NotNull(info);
JsonInstanceInfo jinfo = info.ToJsonInstance();
// Verify
Assert.Equal(config.GetHostName(false), jinfo.InstanceId);
Assert.Equal(EurekaInstanceConfig.Default_Appname.ToUpperInvariant(), jinfo.AppName);
Assert.Null(jinfo.AppGroupName);
Assert.Equal(config.IpAddress, jinfo.IpAddr);
Assert.Equal("na", jinfo.Sid);
Assert.NotNull(jinfo.Port);
Assert.Equal(80, jinfo.Port.Port);
Assert.True(Boolean.Parse(jinfo.Port.Enabled));
Assert.NotNull(jinfo.SecurePort);
Assert.Equal(443, jinfo.SecurePort.Port);
Assert.False(Boolean.Parse(jinfo.SecurePort.Enabled));
Assert.Equal("http://" + config.GetHostName(false) + ":" + 80 + "/", jinfo.HomePageUrl);
Assert.Equal("http://" + config.GetHostName(false) + ":" + 80 + "/Status", jinfo.StatusPageUrl);
Assert.Equal("http://" + config.GetHostName(false) + ":" + 80 + "/healthcheck", jinfo.HealthCheckUrl);
Assert.Null(jinfo.SecureHealthCheckUrl);
Assert.Equal(config.GetHostName(false) + ":" + 80, jinfo.VipAddress);
Assert.Equal(config.GetHostName(false) + ":" + 443, jinfo.SecureVipAddress);
Assert.Equal(1, jinfo.CountryId);
Assert.NotNull(jinfo.DataCenterInfo);
Assert.Equal("MyOwn", jinfo.DataCenterInfo.Name);
Assert.Equal("com.netflix.appinfo.InstanceInfo$DefaultDataCenterInfo", jinfo.DataCenterInfo.ClassName);
Assert.Equal(config.GetHostName(false), jinfo.HostName);
Assert.Equal(InstanceStatus.STARTING, jinfo.Status);
Assert.Equal(InstanceStatus.UNKNOWN, jinfo.OverriddenStatus);
Assert.NotNull(jinfo.LeaseInfo);
Assert.Equal(30, jinfo.LeaseInfo.RenewalIntervalInSecs);
Assert.Equal(90, jinfo.LeaseInfo.DurationInSecs);
Assert.Equal(0, jinfo.LeaseInfo.RegistrationTimestamp);
Assert.Equal(0, jinfo.LeaseInfo.LastRenewalTimestamp);
Assert.Equal(0, jinfo.LeaseInfo.LastRenewalTimestampLegacy);
Assert.Equal(0, jinfo.LeaseInfo.EvictionTimestamp);
Assert.Equal(0, jinfo.LeaseInfo.ServiceUpTimestamp);
Assert.False(jinfo.IsCoordinatingDiscoveryServer);
Assert.NotNull(jinfo.Metadata);
Assert.Equal(1, jinfo.Metadata.Count);
Assert.True(jinfo.Metadata.ContainsKey("@class"));
Assert.True(jinfo.Metadata.ContainsValue("java.util.Collections$EmptyMap"));
Assert.Equal(jinfo.LastDirtyTimestamp, jinfo.LastUpdatedTimestamp);
Assert.Equal(ActionType.ADDED, jinfo.Actiontype);
Assert.Null(jinfo.AsgName);
}
public static void RegisterDiscoveryClient(this Container container, IConfiguration configuration)
{
var clientConfig = new EurekaClientConfig();
ConfigurationBinder.Bind(configuration.GetSection("eureka:client"), clientConfig);
// Build Eureka instance info config from configuration
var instConfig = new EurekaInstanceConfig();
ConfigurationBinder.Bind(configuration.GetSection("eureka:instance"), instConfig);
container.Register <IEurekaHttpClient>(() => new EurekaHttpClient(clientConfig), Lifestyle.Scoped);
container.Register <IEurekaClient>(() => new EurekaClient.Net.EurekaClient(container.GetInstance <IEurekaHttpClient>(), instConfig), Lifestyle.Singleton);
}
public void TestRegister()
{
var tmp = Uri.EscapeDataString("AA-BB:DD CC?");
var clientConfig = new EurekaClientConfig();
ConfigurationBinder.Bind(Configuration.GetSection("eureka:client"), clientConfig);
// Build Eureka instance info config from configuration
var instConfig = new EurekaInstanceConfig();
ConfigurationBinder.Bind(Configuration.GetSection("eureka:instance"), instConfig);
IEurekaHttpClient eurekaHttpClient = new EurekaHttpClient(clientConfig);
var result = eurekaHttpClient.RegisterAsync(InstanceInfo.FromInstanceConfig(instConfig)).ConfigureAwait(false).GetAwaiter().GetResult();
}
public void StatusChanged_ChangesStatus_SendsEvents()
{
EurekaInstanceConfig config = new EurekaInstanceConfig();
ApplicationInfoManager.Instance.Initialize(config);
Assert.Equal(InstanceStatus.STARTING, ApplicationInfoManager.Instance.InstanceStatus);
// Check event sent
ApplicationInfoManager.Instance.StatusChangedEvent += Instance_StatusChangedEvent;
ApplicationInfoManager.Instance.InstanceStatus = InstanceStatus.UP;
Assert.NotNull(eventArg);
Assert.Equal(InstanceStatus.STARTING, eventArg.Previous);
Assert.Equal(InstanceStatus.UP, eventArg.Current);
Assert.Equal(ApplicationInfoManager.Instance.InstanceInfo.InstanceId, eventArg.InstanceId);
ApplicationInfoManager.Instance.StatusChangedEvent -= Instance_StatusChangedEvent;
}
public void FromInstanceConfig_NonSecurePortFalse_SecurePortTrue_Correct()
{
EurekaInstanceConfig config = new EurekaInstanceConfig
{
SecurePortEnabled = true,
IsNonSecurePortEnabled = false
};
InstanceInfo info = InstanceInfo.FromInstanceConfig(config);
Assert.NotNull(info);
// Verify
Assert.Equal(config.GetHostName(false), info.InstanceId);
Assert.Equal(EurekaInstanceConfig.Default_Appname.ToUpperInvariant(), info.AppName);
Assert.Null(info.AppGroupName);
Assert.Equal(config.IpAddress, info.IpAddr);
Assert.Equal("na", info.Sid);
Assert.Equal(80, info.Port);
Assert.False(info.IsUnsecurePortEnabled);
Assert.Equal(443, info.SecurePort);
Assert.True(info.IsSecurePortEnabled);
Assert.Equal("https://" + config.GetHostName(false) + ":" + 443 + "/", info.HomePageUrl);
Assert.Equal("https://" + config.GetHostName(false) + ":" + 443 + "/Status", info.StatusPageUrl);
Assert.Equal("https://" + config.GetHostName(false) + ":" + 443 + "/healthcheck", info.HealthCheckUrl);
Assert.Null(info.SecureHealthCheckUrl);
Assert.Equal(config.GetHostName(false) + ":" + 80, info.VipAddress);
Assert.Equal(config.GetHostName(false) + ":" + 443, info.SecureVipAddress);
Assert.Equal(1, info.CountryId);
Assert.Equal("MyOwn", info.DataCenterInfo.Name.ToString());
Assert.Equal(config.GetHostName(false), info.HostName);
Assert.Equal(InstanceStatus.STARTING, info.Status);
Assert.Equal(InstanceStatus.UNKNOWN, info.OverriddenStatus);
Assert.NotNull(info.LeaseInfo);
Assert.Equal(30, info.LeaseInfo.RenewalIntervalInSecs);
Assert.Equal(90, info.LeaseInfo.DurationInSecs);
Assert.Equal(0, info.LeaseInfo.RegistrationTimestamp);
Assert.Equal(0, info.LeaseInfo.LastRenewalTimestamp);
Assert.Equal(0, info.LeaseInfo.LastRenewalTimestampLegacy);
Assert.Equal(0, info.LeaseInfo.EvictionTimestamp);
Assert.Equal(0, info.LeaseInfo.ServiceUpTimestamp);
Assert.False(info.IsCoordinatingDiscoveryServer);
Assert.NotNull(info.Metadata);
Assert.Empty(info.Metadata);
Assert.Equal(info.LastDirtyTimestamp, info.LastUpdatedTimestamp);
Assert.Equal(ActionType.ADDED, info.Actiontype);
Assert.Null(info.AsgName);
}
public async void RegisterAsync_SendsValidPOSTData()
{
IHostingEnvironment envir = new HostingEnvironment();
TestConfigServerStartup.Response = "";
TestConfigServerStartup.ReturnStatus = 204;
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
EurekaInstanceConfig config = new EurekaInstanceConfig()
{
AppName = "foobar"
};
InstanceInfo info = InstanceInfo.FromInstanceConfig(config);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
EurekaHttpResponse resp = await client.RegisterAsync(info);
Assert.NotNull(TestConfigServerStartup.LastRequest);
Assert.Equal("POST", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/apps/FOOBAR", TestConfigServerStartup.LastRequest.Path.Value);
// Check JSON payload
JsonInstanceInfoRoot recvJson = JsonInstanceInfoRoot.Deserialize(TestConfigServerStartup.RequestBody);
Assert.NotNull(recvJson);
Assert.NotNull(recvJson.Instance);
// Compare a few random values
JsonInstanceInfo sentJsonObj = info.ToJsonInstance();
Assert.Equal(sentJsonObj.Actiontype, recvJson.Instance.Actiontype);
Assert.Equal(sentJsonObj.AppName, recvJson.Instance.AppName);
Assert.Equal(sentJsonObj.HostName, recvJson.Instance.HostName);
}
public void Initialize_WithBothConfigs_InitializesAll()
{
EurekaInstanceConfig instanceConfig = new EurekaInstanceConfig();
EurekaClientConfig clientConfig = new EurekaClientConfig()
{
ShouldRegisterWithEureka = false,
ShouldFetchRegistry = false
};
DiscoveryManager.Instance.Initialize(clientConfig, instanceConfig);
Assert.NotNull(DiscoveryManager.Instance.InstanceConfig);
Assert.Equal(instanceConfig, DiscoveryManager.Instance.InstanceConfig);
Assert.NotNull(DiscoveryManager.Instance.ClientConfig);
Assert.Equal(clientConfig, DiscoveryManager.Instance.ClientConfig);
Assert.NotNull(DiscoveryManager.Instance.Client);
Assert.Equal(instanceConfig, ApplicationInfoManager.Instance.InstanceConfig);
}
public void StatusChanged_RemovesEventHandler()
{
var config = new EurekaInstanceConfig();
ApplicationInfoManager.Instance.Initialize(config);
Assert.Equal(InstanceStatus.STARTING, ApplicationInfoManager.Instance.InstanceStatus);
// Check event sent
ApplicationInfoManager.Instance.StatusChangedEvent += Instance_StatusChangedEvent;
ApplicationInfoManager.Instance.InstanceStatus = InstanceStatus.UP;
Assert.NotNull(eventArg);
Assert.Equal(InstanceStatus.STARTING, eventArg.Previous);
Assert.Equal(InstanceStatus.UP, eventArg.Current);
Assert.Equal(ApplicationInfoManager.Instance.InstanceInfo.InstanceId, eventArg.InstanceId);
eventArg = null;
ApplicationInfoManager.Instance.StatusChangedEvent -= Instance_StatusChangedEvent;
ApplicationInfoManager.Instance.InstanceStatus = InstanceStatus.DOWN;
Assert.Null(eventArg);
}
public void RefreshLeaseInfo_UpdatesLeaseInfo()
{
EurekaInstanceConfig config = new EurekaInstanceConfig();
ApplicationInfoManager.Instance.Initialize(config);
ApplicationInfoManager.Instance.RefreshLeaseInfo();
InstanceInfo info = ApplicationInfoManager.Instance.InstanceInfo;
Assert.False(info.IsDirty);
Assert.Equal(config.LeaseExpirationDurationInSeconds, info.LeaseInfo.DurationInSecs);
Assert.Equal(config.LeaseRenewalIntervalInSeconds, info.LeaseInfo.RenewalIntervalInSecs);
config.LeaseRenewalIntervalInSeconds = config.LeaseRenewalIntervalInSeconds + 100;
config.LeaseExpirationDurationInSeconds = config.LeaseExpirationDurationInSeconds + 100;
ApplicationInfoManager.Instance.RefreshLeaseInfo();
Assert.True(info.IsDirty);
Assert.Equal(config.LeaseExpirationDurationInSeconds, info.LeaseInfo.DurationInSecs);
Assert.Equal(config.LeaseRenewalIntervalInSeconds, info.LeaseInfo.RenewalIntervalInSecs);
}
public FortuneService()
{
EurekaClientConfig clientConfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = "http://localhost:8761/eureka/"
};
EurekaInstanceConfig instanceConfig = new EurekaInstanceConfig()
{
AppName = "my.Net Service",
InstanceId = "Some_ID",
IsInstanceEnabledOnInit = true
};
// Register services and fetch the registry
DiscoveryManager.Instance.Initialize(clientConfig, instanceConfig);
_manager = DiscoveryManager.Instance.Client;
//Test _manager
getBuzzgraphResult();
}
public void RefreshInstanceInfo_CallsHealthCheckHandler_UpdatesInstanceStatus()
{
var config = new EurekaClientConfig()
{
ShouldFetchRegistry = false,
ShouldRegisterWithEureka = false
};
var iconfig = new EurekaInstanceConfig();
ApplicationInfoManager.Instance.Initialize(iconfig);
var client = new DiscoveryClient(config);
var myHandler = new MyHealthCheckHandler(InstanceStatus.DOWN);
client.HealthCheckHandler = myHandler;
client.RefreshInstanceInfo();
Assert.True(myHandler.Called);
Assert.Equal(InstanceStatus.DOWN, ApplicationInfoManager.Instance.InstanceInfo.Status);
}
public async void RegisterAsync_InvokesServer_ReturnsStatusCodeAndHeaders()
{
var startup = new TestConfigServerStartup("", 204);
var server = TestServer.Create(startup.Configure);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
EurekaInstanceConfig config = new EurekaInstanceConfig();
InstanceInfo info = InstanceInfo.FromInstanceConfig(config);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
EurekaHttpResponse resp = await client.RegisterAsync(info);
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.NoContent, resp.StatusCode);
Assert.NotNull(resp.Headers);
}
public void AddHeartbeatStatus_AddsExpected()
{
EurekaServerHealthContributor contrib = new EurekaServerHealthContributor();
HealthCheckResult results = new HealthCheckResult();
contrib.AddHeartbeatStatus(null, null, results, 0);
Assert.Contains("heartbeatStatus", results.Details.Keys);
Assert.Equal("Not registering", results.Details["heartbeatStatus"]);
results = new HealthCheckResult();
EurekaClientConfig clientconfig = new EurekaClientConfig()
{
ShouldRegisterWithEureka = true
};
EurekaInstanceConfig instconfig = new EurekaInstanceConfig();
contrib.AddHeartbeatStatus(clientconfig, instconfig, results, 0);
Assert.Contains("heartbeat", results.Details.Keys);
Assert.Contains("Not yet successfully connected", (string)results.Details["heartbeat"]);
Assert.Contains("heartbeatTime", results.Details.Keys);
Assert.Contains("UNKNOWN", (string)results.Details["heartbeatTime"]);
Assert.Contains("heartbeatStatus", results.Details.Keys);
Assert.Equal("UNKNOWN", results.Details["heartbeatStatus"]);
results = new HealthCheckResult();
long ticks = DateTime.UtcNow.Ticks - (TimeSpan.TicksPerSecond * instconfig.LeaseRenewalIntervalInSeconds * 10);
DateTime dateTime = new DateTime(ticks);
contrib.AddHeartbeatStatus(clientconfig, instconfig, results, ticks);
Assert.Contains("heartbeat", results.Details.Keys);
Assert.Contains("Reporting failures", (string)results.Details["heartbeat"]);
Assert.Contains("heartbeatTime", results.Details.Keys);
Assert.Equal(dateTime.ToString("s"), (string)results.Details["heartbeatTime"]);
Assert.Contains("heartbeatFailures", results.Details.Keys);
Assert.Equal(10, (long)results.Details["heartbeatFailures"]);
Assert.Contains("heartbeatStatus", results.Details.Keys);
Assert.Equal("DOWN", results.Details["heartbeatStatus"]);
}
public async System.Threading.Tasks.Task SendHeartBeatAsync_InvokesServer_ReturnsStatusCodeAndHeaders()
{
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = string.Empty;
TestConfigServerStartup.ReturnStatus = 200;
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var config = new EurekaInstanceConfig()
{
AppName = "foo",
InstanceId = "id1"
};
var info = InstanceInfo.FromInstanceConfig(config);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var resp = await client.SendHeartBeatAsync("foo", "id1", info, InstanceStatus.UNKNOWN);
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.NotNull(resp.Headers);
Assert.Equal("PUT", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/apps/FOO/id1", TestConfigServerStartup.LastRequest.Path.Value);
var time = DateTimeConversions.ToJavaMillis(new DateTime(info.LastDirtyTimestamp, DateTimeKind.Utc));
Assert.Equal("?status=STARTING&lastDirtyTimestamp=" + time, TestConfigServerStartup.LastRequest.QueryString.Value);
}
public void DefaultConstructor_InitializedWithDefaults()
{
EurekaInstanceConfig config = new EurekaInstanceConfig();
var thisHostName = config.GetHostName(false);
var thisHostAddress = config.GetHostAddress(false);
Assert.False(config.IsInstanceEnabledOnInit);
Assert.Equal(EurekaInstanceConfig.Default_NonSecurePort, config.NonSecurePort);
Assert.Equal(EurekaInstanceConfig.Default_SecurePort, config.SecurePort);
Assert.True(config.IsNonSecurePortEnabled);
Assert.False(config.SecurePortEnabled);
Assert.Equal(EurekaInstanceConfig.Default_LeaseRenewalIntervalInSeconds, config.LeaseRenewalIntervalInSeconds);
Assert.Equal(EurekaInstanceConfig.Default_LeaseExpirationDurationInSeconds, config.LeaseExpirationDurationInSeconds);
Assert.Equal(thisHostName + ":" + config.SecurePort, config.SecureVirtualHostName);
Assert.Equal(thisHostAddress, config.IpAddress);
Assert.Equal(EurekaInstanceConfig.Default_Appname, config.AppName);
Assert.Equal(EurekaInstanceConfig.Default_StatusPageUrlPath, config.StatusPageUrlPath);
Assert.Equal(EurekaInstanceConfig.Default_HomePageUrlPath, config.HomePageUrlPath);
Assert.Equal(EurekaInstanceConfig.Default_HealthCheckUrlPath, config.HealthCheckUrlPath);
Assert.NotNull(config.MetadataMap);
Assert.Empty(config.MetadataMap);
Assert.Equal(DataCenterName.MyOwn, config.DataCenterInfo.Name);
}
/// <summary>
/// 将应用设置为下线状态
/// </summary>
/// <param name="instanceConfig">instanceConfig 实例配置</param>
public void SetAppOutOfService(EurekaInstanceConfig instanceConfig)
{
this.SetAppStatus(InstanceStatus.OUT_OF_SERVICE, this.InitializeApplicationInfoManager(instanceConfig));
}
/// <summary>
/// 将应用设置为down的状态
/// </summary>
/// <param name="instanceConfig">instanceConfig 实例配置</param>
public void SsetAppDown(EurekaInstanceConfig instanceConfig)
{
this.SetAppStatus(InstanceStatus.DOWN, this.InitializeApplicationInfoManager(instanceConfig));
}
