/// <summary>
/// Gets the description of the discovery option.
/// </summary>
/// <param name="source"></param>
/// <returns>The discovery option description.</returns>
public static string GetDescription(this DiscoveryOptions source)
{
return(lookupTable[source]);
}
public static string ToDisplayString(this DiscoveryOptions source)
{
var value = lookupTable[source];
return(string.Format("{0} ({1})", value, (byte)source));
}
/// <summary>
/// Gets the value of the discovery option.
/// </summary>
/// <param name="source"></param>
/// <returns>The value of the discovery option.</returns>
public static int GetValue(this DiscoveryOptions source)
{
return((int)source);
}
public Task StartDiscoveryAsync(String p0, EndpointDiscoveryCallback p1, DiscoveryOptions p2)
{
return(StartDiscovery(p0, p1, p2).AsAsync());
}
public BootstrapApi(IConfigApi configApi, DiscoveryOptions discoveryOptions)
{
_configApi = configApi;
_discoveryOptions = discoveryOptions;
}
public static async Task <Statuses> StartDiscoveryAsync(this IConnections api, GoogleApiClient apiClient, string serviceId, EndpointDiscoveryCallback endpointDiscoveryCallback, DiscoveryOptions options)
{
return((await api.StartDiscovery(apiClient, serviceId, endpointDiscoveryCallback, options)).JavaCast <Statuses>());
}
public void Constructor_ConfiguresEurekaDiscovery_Correctly()
{
// Arrange
var appsettings = @"
{
'eureka': {
'client': {
'eurekaServer': {
'proxyHost': 'proxyHost',
'proxyPort': 100,
'proxyUserName': '******',
'proxyPassword': '******',
'shouldGZipContent': true,
'connectTimeoutSeconds': 100
},
'allowRedirects': true,
'shouldDisableDelta': true,
'shouldFilterOnlyUpInstances': true,
'shouldFetchRegistry': true,
'registryRefreshSingleVipAddress':'registryRefreshSingleVipAddress',
'shouldOnDemandUpdateStatusChange': true,
'shouldRegisterWithEureka': true,
'registryFetchIntervalSeconds': 100,
'instanceInfoReplicationIntervalSeconds': 100,
'serviceUrl': 'http://localhost:8761/eureka/'
},
'instance': {
'hostName': 'myHostName',
'instanceId': 'instanceId',
'appName': 'appName',
'appGroup': 'appGroup',
'instanceEnabledOnInit': true,
'port': 100,
'securePort': 100,
'nonSecurePortEnabled': true,
'securePortEnabled': true,
'leaseExpirationDurationInSeconds':100,
'leaseRenewalIntervalInSeconds': 100,
'secureVipAddress': 'secureVipAddress',
'vipAddress': 'vipAddress',
'asgName': 'asgName',
'metadataMap': {
'foo': 'bar',
'bar': 'foo'
},
'statusPageUrlPath': 'statusPageUrlPath',
'statusPageUrl': 'statusPageUrl',
'homePageUrlPath':'homePageUrlPath',
'homePageUrl': 'homePageUrl',
'healthCheckUrlPath': 'healthCheckUrlPath',
'healthCheckUrl':'healthCheckUrl',
'secureHealthCheckUrl':'secureHealthCheckUrl'
}
}
}";
var path = TestHelpers.CreateTempFile(appsettings);
string directory = Path.GetDirectoryName(path);
string fileName = Path.GetFileName(path);
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.SetBasePath(directory);
configurationBuilder.AddJsonFile(fileName);
var config = configurationBuilder.Build();
var options = new DiscoveryOptions(config);
Assert.Equal(DiscoveryClientType.EUREKA, options.ClientType);
var co = options.ClientOptions as EurekaClientOptions;
Assert.NotNull(co);
Assert.Equal("proxyHost", co.ProxyHost);
Assert.Equal(100, co.ProxyPort);
Assert.Equal("proxyPassword", co.ProxyPassword);
Assert.Equal("proxyUserName", co.ProxyUserName);
Assert.True(co.AllowRedirects);
Assert.Equal(100, co.InstanceInfoReplicationIntervalSeconds);
Assert.Equal(100, co.EurekaServerConnectTimeoutSeconds);
Assert.Equal("http://localhost:8761/eureka/", co.EurekaServerServiceUrls);
Assert.Equal(100, co.RegistryFetchIntervalSeconds);
Assert.Equal("registryRefreshSingleVipAddress", co.RegistryRefreshSingleVipAddress);
Assert.True(co.ShouldDisableDelta);
Assert.True(co.ShouldFetchRegistry);
Assert.True(co.ShouldFilterOnlyUpInstances);
Assert.True(co.ShouldGZipContent);
Assert.True(co.ShouldOnDemandUpdateStatusChange);
Assert.True(co.ShouldRegisterWithEureka);
var ro = options.RegistrationOptions as EurekaInstanceOptions;
Assert.NotNull(ro);
Assert.Equal("instanceId", ro.InstanceId);
Assert.Equal("appName", ro.AppName);
Assert.Equal("appGroup", ro.AppGroupName);
Assert.True(ro.IsInstanceEnabledOnInit);
Assert.Equal(100, ro.NonSecurePort);
Assert.Equal(100, ro.SecurePort);
Assert.True(ro.IsNonSecurePortEnabled);
Assert.True(ro.SecurePortEnabled);
Assert.Equal(100, ro.LeaseExpirationDurationInSeconds);
Assert.Equal(100, ro.LeaseRenewalIntervalInSeconds);
Assert.Equal("secureVipAddress", ro.SecureVirtualHostName);
Assert.Equal("vipAddress", ro.VirtualHostName);
Assert.Equal("asgName", ro.ASGName);
Assert.Equal("statusPageUrlPath", ro.StatusPageUrlPath);
Assert.Equal("statusPageUrl", ro.StatusPageUrl);
Assert.Equal("homePageUrlPath", ro.HomePageUrlPath);
Assert.Equal("homePageUrl", ro.HomePageUrl);
Assert.Equal("healthCheckUrlPath", ro.HealthCheckUrlPath);
Assert.Equal("healthCheckUrl", ro.HealthCheckUrl);
Assert.Equal("secureHealthCheckUrl", ro.SecureHealthCheckUrl);
Assert.Equal("myHostName", ro.GetHostName(false));
Assert.Equal("myHostName", ro.HostName);
var map = ro.MetadataMap;
Assert.NotNull(map);
Assert.Equal(2, map.Count);
Assert.Equal("bar", map["foo"]);
Assert.Equal("foo", map["bar"]);
}
public void Constructor_Initializes_ClientType_Unknown()
{
var option = new DiscoveryOptions();
Assert.Equal(DiscoveryClientType.UNKNOWN, option.ClientType);
}
public static DiscoveryOptions UseEureka(this DiscoveryOptions options)
{
options.RegisterPlugin(new EurekaPlugin());
return(options);
}
public static DiscoveryOptions UseEureka(this DiscoveryOptions options, Action <EurekaOptions> configure)
{
options.RegisterPlugin(new EurekaPlugin(configure));
return(options);
}
