public ApplicationLifecycle(IApplicationLifetime lifeCycle, IDiscoveryClient client)
{
ApplicationStopping = lifeCycle.ApplicationStopping;
// hook things up so that that things are unregistered when the application terminates
ApplicationStopping.Register(() => { client.ShutdownAsync().GetAwaiter().GetResult(); });
}
static void ServicesList(IDiscoveryClient discoveryClient)
{
foreach(var service in discoveryClient.KnownServices())
{
Logger.Info(string.Format("Service:{0}", service));
}
}
public TestController(ILogger <TestController> logger, IHttpClientFactory clientFactory,
IDiscoveryClient discoveryClient)
{
_httpClient = clientFactory.CreateClient("CURRRENCY");
_logger = logger;
_handler = new DiscoveryHttpClientHandler(discoveryClient);
}
protected void Application_Start()
{
var config = GlobalConfiguration.Configuration;
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
// Build application configuration
ConfigServerConfig.RegisterConfig("test");
// Create IOC container builder
var builder = new ContainerBuilder();
// Register your Web API controllers.
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
// Register IDiscoveryClient, etc.
builder.RegisterDiscoveryClient(ConfigServerConfig.Configuration);
var container = builder.Build();
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
// Start the Discovery client background thread
_client = container.Resolve <IDiscoveryClient>();
}
public ServicesController(
ILogger <ServicesController> logger,
IOptionsSnapshot <FortuneServiceOptions> config,
IOptionsSnapshot <ConfigServerData> configServerData,
FortuneServiceCommand fortunes,
IOptions <CloudFoundryApplicationOptions> appOptions,
IOptions <CloudFoundryServicesOptions> servOptions,
IConfiguration configApp,
IConfigurationRoot configRoot,
IDistributedCache cache,
[FromServices] IDiscoveryClient client
)
{
if (configServerData != null)
{
IConfigServerData = configServerData;
}
_logger = logger;
if (fortunes != null)
{
_fortunes = fortunes;
}
CloudFoundryServices = servOptions.Value;
CloudFoundryApplication = appOptions.Value;
_fortunesConfig = config;
discoveryClient = client;
RedisCacheStore = cache;
Config = configApp;
ConfigRoot = configRoot;
}
public Feign(IDiscoveryClient client, ILoggerFactory factory)
{
Handler = new DiscoveryHttpClientHandler(client, factory.CreateLogger <DiscoveryHttpClientHandler>());
Logger = factory.CreateLogger <TollRateServiceClient>();
Operations = BuildOperations();
}
public async Task <string> Ping([FromServices] IDiscoveryClient discoveryClient, string targets)
{
var pong = string.Empty;
if (!string.IsNullOrEmpty(targets))
{
var httpClient = new HttpClient(new DiscoveryHttpClientHandler(discoveryClient));
_log.LogTrace($"Ping received. Remaining targets: {targets}");
var allTargets = targets.Split(",").Where(x => x != _app.Value.Name).ToList();
if (allTargets.Any())
{
var nextTarget = allTargets.First();
var remainingTargets = string.Join(",", allTargets.Skip(1));
try
{
_log.LogDebug($"Sending ping request to {nextTarget}");
pong = await httpClient.GetStringAsync($"https://{nextTarget}/ping/?targets={remainingTargets}");
}
catch (Exception e)
{
_log.LogError(e, $"Call to {nextTarget} failed");
pong = $"{nextTarget} failed to answer";
}
}
}
return(pong.Insert(0, $"Pong from {_app.Value.Name}\n"));
}
public PerRequestMessagehandler(Uri serviceUri, IDiscoveryClient client)
{
_serviceUri = serviceUri;
_discoveryClient = client;
InnerHandler = new HttpClientHandler();
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
ServerConfig.RegisterConfig("development");
var builder = new ContainerBuilder();
// Register all the controllers with Autofac
builder.RegisterControllers(typeof(MvcApplication).Assembly);
// Register IDiscoveryClient, etc.
builder.RegisterDiscoveryClient(ServerConfig.Configuration);
// Register FortuneService
builder.RegisterType <FortuneService>().As <IFortuneService>().SingleInstance();
// Create the Autofac container
var container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
// Start the Discovery client background thread
_client = container.Resolve <IDiscoveryClient>();
}
/// <summary>
/// Get请求
/// </summary>
/// <param name="client"></param>
/// <param name="url"></param>
/// <returns></returns>
public static async Task <string> DoGetAsync(this IDiscoveryClient client, string url)
{
_handler = new DiscoveryHttpClientHandler(client);
HttpClient httpClient = new HttpClient(_handler);
return(await httpClient.GetStringAsync(url));
}
/// <summary>
/// Get请求
/// </summary>
/// <param name="client"></param>
/// <param name="url"></param>
/// <returns></returns>
public static string DoGetSync(this IDiscoveryClient client, string url)
{
_handler = new DiscoveryHttpClientHandler(client);
HttpClient httpClient = new HttpClient(_handler);
return(httpClient.GetStringAsync(url).Result);
}
public ProductService(IHystrixCommandOptions options, IDiscoveryClient client, ILogger <ProductService> logger) :
base(options)
{
_logger = logger;
_handler = new DiscoveryHttpClientHandler(client);
IsFallbackUserDefined = true;
}
public AbstractService(IDiscoveryClient client, ILogger logger, IHttpContextAccessor context)
{
_handler = new DiscoveryHttpClientHandler(client);
_handler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => true;
_logger = logger;
_context = context;
}
// Create a discovery client to be used (hopefully only) during startup
internal void SetupDiscoveryClient()
{
var services = new ServiceCollection();
if (_logFactory != null)
{
services.AddSingleton(_logFactory);
services.TryAdd(ServiceDescriptor.Singleton(typeof(ILogger <>), typeof(Logger <>)));
}
// force settings to make sure we don't register the app here
var cfgBuilder = new ConfigurationBuilder()
.AddConfiguration(_configuration)
.AddInMemoryCollection(
new Dictionary <string, string>
{
{ "Eureka:Client:ShouldRegisterWithEureka", "false" },
{ "Consul:Discovery:Register", "false" }
});
services.AddSingleton <IConfiguration>(cfgBuilder.Build());
services.AddDiscoveryClient(_configuration);
using var startupServiceProvider = services.BuildServiceProvider();
_discoveryClient = startupServiceProvider.GetRequiredService <IDiscoveryClient>();
_logger.LogDebug("Found Discovery Client of type {DiscoveryClientType}", _discoveryClient.GetType());
}
/// <summary>
/// 请求url
/// </summary>
/// <param name="client"></param>
/// <param name="url"></param>
/// <param name="httpMethod"></param>
/// <returns></returns>
private static string DoRequest(IDiscoveryClient client, string url, HttpMethod httpMethod)
{
string result = "";
try
{
Uri uri = client.LookupService(new Uri(url));
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
request.Method = httpMethod.Method;
try
{
using (Stream stream = ((HttpWebResponse)request.GetResponse()).GetResponseStream())
{
result = new StreamReader(stream, Encoding.UTF8).ReadToEnd();
}
}
catch (WebException exception1)
{
using (Stream stream2 = ((HttpWebResponse)exception1.Response).GetResponseStream())
{
result = new StreamReader(stream2).ReadToEnd();
}
}
}
catch (Exception exception)
{
result = exception.Message;
}
return(result);
}
protected void Application_Start()
{
GlobalConfiguration.Configure(WebApiConfig.Register);
var config = GlobalConfiguration.Configuration;
// Build application configuration
ServerConfig.RegisterConfig("development");
// Create IOC container builder
var builder = new ContainerBuilder();
// Register your Web API controllers.
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
// Register IDiscoveryClient, etc.
builder.RegisterDiscoveryClient(ServerConfig.Configuration);
// Initialize and Register FortuneContext
builder.RegisterInstance(SampleData.InitializeFortunes()).SingleInstance();
// Register FortuneRepository
builder.RegisterType <FortuneRepository>().As <IFortuneRepository>().SingleInstance();
var container = builder.Build();
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
// Start the Discovery client background thread
_client = container.Resolve <IDiscoveryClient>();
}
public void CreateClient_NullOptions_ReturnsUnknownClient()
{
IDiscoveryClient result = DiscoveryClientFactory.CreateClient(null) as IDiscoveryClient;
Assert.NotNull(result);
Assert.Equal("Unknown", result.Description);
}
public HomeController(IDiscoveryClient client, ILoggerFactory logFactory)
{
_handler = new DiscoveryHttpClientHandler(client, logFactory.CreateLogger <DiscoveryHttpClientHandler>());
// Remove comment to use SSL communications with Self-Signed Certs
// _handler.ServerCertificateCustomValidationCallback = (a,b,c,d) => {return true;};
_logger = logFactory.CreateLogger <HomeController>();
}
/// <summary>
/// 程序开始
/// </summary>
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
//全局配置
var config = GlobalConfiguration.Configuration;
// Build application configuration
ApplicationConfig.RegisterConfig("development");
// /autofac IoC容器
var builder = new ContainerBuilder();
// Register your Web API controllers.
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
// Register IDiscoveryClient, etc.
builder.RegisterDiscoveryClient(ApplicationConfig.Configuration, null);
//设置全局依赖注入解析器
var container = builder.Build();
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
// Start the Discovery client background thread
_client = container.Resolve <IDiscoveryClient>();
}
// Lab08 End
public FortuneServiceClient(IDiscoveryClient client, IOptionsSnapshot <FortuneServiceConfig> config, ILogger <FortuneServiceClient> logger)
{
// Lab08 Start
_handler = new DiscoveryHttpClientHandler(client);
// Lab08 End
_logger = logger;
_config = config;
}
public void Constructor_ThrowsIfClientNull()
{
IDiscoveryClient client = null;
var ex = Assert.Throws <ArgumentNullException>(() => new DiscoveryHttpClientHandlerBase(client));
Assert.Contains(nameof(client), ex.Message);
}
public FortuneService(IHystrixCommandOptions options, IDiscoveryClient client, ILoggerFactory logFactory) : base(options)
{
_handler = new DiscoveryHttpClientHandler(client, logFactory.CreateLogger <DiscoveryHttpClientHandler>());
// Remove comment to use SSL communications with Self-Signed Certs
// _handler.ServerCertificateCustomValidationCallback = (a,b,c,d) => {return true;};
IsFallbackUserDefined = true;
this._logger = logFactory.CreateLogger <FortuneService>();
}
public AutoTestWithLoadBalanceService(IDiscoveryClient discoveryClient)
{
_discoveryClient = discoveryClient;
_loadBalancer = new RandomLoadBalancer(_discoveryClient);
_handler = new LoadBalancerHttpClientHandler(_loadBalancer);
}
public HttpRpcService(IConfiguration configuration, IDiscoveryClient client, ILogService _LogService)
{
_handler = new DiscoveryHttpClientHandler(client);
httpClient = new HttpClient(_handler);
serviceAddress = configuration.GetSection("gateway")["serviceAddress"];
oldWebApi = configuration.GetSection("OldWebApi").Value;
logService = _LogService;
}
public void CreateDiscoveryClient_MissingOptions_ReturnsNull()
{
IServiceProvider provider = new MyServiceProvier(null);
IDiscoveryClient result = DiscoveryClientFactory.CreateDiscoveryClient(provider) as IDiscoveryClient;
Assert.NotNull(result);
Assert.Equal("Unknown", result.Description);
}
public FlowClient(
IDiscoveryClient discoveryClient,
ILogger <IFlowClient> logger)
{
this.discoveryClient = discoveryClient;
this.discoveryClientHandler = new DiscoveryHttpClientHandler(this.discoveryClient, logger);
this.logger = logger;
}
public FrontendController(IDiscoveryClient client, IConfiguration configuration)
{
string backendName = configuration.GetSection("c2c:backend").Get <string>();
// The .NET Eureka handler automatically replaces the backend app name, so just provide it here:
_backendBaseUrl = "http://" + backendName;
_handler = new DiscoveryHttpClientHandler(client);
}
public BaseDiscoveryService(IDiscoveryClient client, ILogger <BaseDiscoveryService> logger, IHttpContextAccessor context)
{
_handler = new SkynetDiscoveryHttpClientHandler(client)
{
ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => true
};
_logger = logger;
_context = context;
}
public EurekaService(IDiscoveryClient client)
{
var handler = new DiscoveryHttpClientHandler(client);
this.http = new HttpClient(handler, false)
{
BaseAddress = new Uri("http://tas-steeltoe-core-eureka-api/app")
};
}
public HttpDiscoveryClientHttpRequester(IOcelotLoggerFactory loggerFactory,
IHttpClientCache cacheHandlers,
IDelegatingHandlerHandlerHouse house, IDiscoveryClient discoveryClient)
{
_logger = loggerFactory.CreateLogger <HttpClientHttpRequester>();
_cacheHandlers = cacheHandlers;
_house = house;
_discoveryClient = discoveryClient;
}
public DiscoveryHttpClientHandler(IDiscoveryClient client) : base()
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
_client = client;
}
public IActionResult Index([FromServices] IDiscoveryClient discoveryClient)
{
var omsUrl = discoveryClient.GetInstances("ORDERMANAGER")?.FirstOrDefault()?.Uri?.ToString() ?? "http://localhost:8080";
omsUrl = omsUrl.Replace("https://", "http://"); // need to force http due to self signed cert
ViewBag.OMS = omsUrl;
ViewBag.MDS = discoveryClient.GetInstances("MDS")?.FirstOrDefault()?.Uri?.ToString() ?? "http://localhost:53809";
return(View());
}
static void RequestOn(string serviceUri, IDiscoveryClient discoveryClient, int requestCount = 10)
{
var httpClient = new HttpClient(new PerRequestMessagehandler(new Uri(serviceUri), discoveryClient))
{
BaseAddress = discoveryClient.Discover(new Uri(serviceUri))
};
for(int i = 0; i < requestCount; i++)
{
var result = httpClient.GetStringAsync("Hello").Result;
Logger.Info(string.Format("Result:{0}", result));
}
}
