public ConstructionPlanService(IConstructionPlanRepo <ConstructionPlan> repo, IAuthHelper authhelper, IServiceDiscoveryProvider consulclient)
{
_repo = repo;
_authhelper = authhelper;
_userID = _authhelper.GetUserId();
_consulclient = consulclient;
}
private static SwaggerServiceDiscoveryProvider CreateProvider(Service service = null)
{
IServiceDiscoveryProviderFactory serviceDiscovery = Substitute.For <IServiceDiscoveryProviderFactory>();
IServiceProviderConfigurationCreator configurationCreator = Substitute.For <IServiceProviderConfigurationCreator>();
IOptionsMonitor <FileConfiguration> options = Substitute.For <IOptionsMonitor <FileConfiguration> >();
IHttpContextAccessor httpContextAccessor = Substitute.For <IHttpContextAccessor>();
IOptions <SwaggerOptions> swaggerOptions = Substitute.For <IOptions <SwaggerOptions> >();
options.CurrentValue.Returns(new FileConfiguration());
IServiceDiscoveryProvider serviceProvider = Substitute.For <IServiceDiscoveryProvider>();
serviceProvider.Get().Returns(new List <Service>()
{
service
});
var response = new OkResponse <IServiceDiscoveryProvider>(serviceProvider);
serviceDiscovery.Get(Arg.Any <ServiceProviderConfiguration>(), Arg.Any <DownstreamRoute>()).Returns(response);
var provider = new SwaggerServiceDiscoveryProvider(
serviceDiscovery, configurationCreator, options, httpContextAccessor, swaggerOptions);
return(provider);
}
public static IServiceDiscoveryBuilder CreateServiceBuilder(this IServiceDiscoveryProvider serviceProvider, Action <IServiceDiscoveryBuilder> config)
{
var builder = new ServiceDiscoveryBuilder(serviceProvider);
config(builder);
return(builder);
}
public WeightRoundRobinLoadBalancer(string service, WeightRoundRobinLoadBalancerConfiguration configuration, IServiceDiscoveryProvider discoveryProvider)
{
Service = service;
Configugration = configuration;
DiscoveryProvider = discoveryProvider;
_services = new List <WeightMicroService>();
}
public Response<ILoadBalancer> Create(DownstreamReRoute reRoute, IServiceDiscoveryProvider serviceProvider)
{
var loadBalancer = new RoundRobin(async () => await serviceProvider.Get());
var bus = new InMemoryBus<StickySession>();
return new OkResponse<ILoadBalancer>(new CookieStickySessions(loadBalancer, reRoute.LoadBalancerOptions.Key,
reRoute.LoadBalancerOptions.ExpiryInMs, bus));
}
public ConsulBridgeRouter(IServiceDiscoveryProvider discovery, ITransportFactory <TMessage> transportFactory, IOptions <ServiceDiscoveryOption> options)
{
_discovery = discovery;
_options = options.Value ?? ServiceDiscoveryOption.Default;
_transportFactory = transportFactory;
Initialize();
}
public async Task <IActionResult> GetServiceDescriptor([FromServices] IServiceDiscoveryProvider serviceDiscoveryProvider, string address, string queryParam)
{
var list = await serviceDiscoveryProvider.GetServiceDescriptorAsync(address, queryParam);
var result = ServiceResult <IEnumerable <ServiceDescriptor> > .Create(true, list);
return(Json(result));
}
public async Task <IActionResult> GetAddress([FromServices] IServiceDiscoveryProvider serviceDiscoveryProvider, string queryParam)
{
var list = await serviceDiscoveryProvider.GetAddressAsync(queryParam);
var result = ServiceResult <IEnumerable <ServiceAddressModel> > .Create(true, list);
return(Json(result));
}
public UserController(IUserService UserService, IServiceDiscoveryProvider serviceProvider)
{
//_logger = logger;
//_mediator = mediator;
//_cache = cache;
_service = UserService;
_serviceProvider = serviceProvider;
}
public LoadBalanceMiddleware(RequestDelegate nextStep,
IServiceDiscoveryProvider serviceDiscoveryProvider,
IServiceLoadBalancer serviceLoadBalancer,
IHttpContextAccessor httpContextAccessor) : base(httpContextAccessor)
{
_nextStep = nextStep;
_serviceLoadBalancer = serviceLoadBalancer;
_serviceDiscoveryProvider = serviceDiscoveryProvider;
}
public DiscoveryServiceRouter(IServiceDiscoveryProvider discoveryProvider, IServiceProvider provider)
{
this._discoveryProvider = discoveryProvider;
var clientOptions = provider.GetService <IOptions <RpcClientOptions> >();
this._appName = clientOptions?.Value != null ?
clientOptions.Value.AppName : new RpcClientOptions().AppName;
}
private static bool MatchProviderName(ServiceProviderConfiguration config, IServiceDiscoveryProvider provider)
{
var configTypeName = config.Type.ToLowerInvariant();
var providerTypeName = provider.GetType().Name.ToLowerInvariant();
return(providerTypeName == configTypeName ||
providerTypeName == string.Concat(configTypeName, "provider") ||
providerTypeName == string.Concat(configTypeName, "discoveryprovider") ||
providerTypeName == string.Concat(configTypeName, "servicediscoveryprovider"));
}
private async Task <string> GetUserAuthorizationJwtAsync(
HttpContext httpContext,
IHttpClientFactory httpClientFactory,
IMemoryCache memoryCache,
IServiceDiscoveryProvider serviceDiscoveryProvider)
{
if (JwtAuthorizationHelper.TryGetTokenValue(httpContext.Request.Headers, out string value))
{
int key = CacheHttpHeadersHelper.TryGetValue(
httpContext.Request.Headers,
_jwtAuthorizationOptions.CacheKeyHttpHeaders,
out string cacheKeyPart)
? GetKey(httpContext, value, cacheKeyPart)
: GetKey(httpContext, value);
if (!memoryCache.TryGetValue(key, out string jwtToken))
{
string authUrl =
_jwtAuthorizationOptions.GetAuthorizationUrl(serviceDiscoveryProvider) + httpContext.Request.Path.Value;
jwtToken = await GetUserAuthorizationJwtAsync(
httpContext,
httpClientFactory,
memoryCache,
value,
key,
authUrl);
}
return(jwtToken);
}
else if (!string.IsNullOrEmpty(_jwtAuthorizationOptions.HashParameterName) &&
httpContext.Request.Query.TryGetValue(_jwtAuthorizationOptions.HashParameterName, out StringValues hashValue))
{
int key = GetKey(httpContext, hashValue.ToString());
if (!memoryCache.TryGetValue(key, out string jwtToken))
{
var uriBuilder = new UriBuilder(_jwtAuthorizationOptions.GetHashAuthorization(serviceDiscoveryProvider));
uriBuilder.Query = QueryString.Create(
_jwtAuthorizationOptions.HashParameterName,
hashValue.ToString()).ToUriComponent();
jwtToken = await GetUserAuthorizationJwtAsync(
httpContext,
httpClientFactory,
memoryCache,
StringValues.Empty,
key,
uriBuilder.Uri.ToString());
}
return(jwtToken);
}
return(string.Empty);
}
public Response <ILoadBalancer> Create(DownstreamReRoute reRoute, IServiceDiscoveryProvider serviceProvider)
{
try
{
return(new OkResponse <ILoadBalancer>(_creatorFunc(reRoute, serviceProvider)));
}
catch (Exception e)
{
return(new ErrorResponse <ILoadBalancer>(new ErrorInvokingLoadBalancerCreator(e)));
}
}
public ConsulServiceRegisterHostedService(
IApplicationLifetime lifetime,
IServiceProvider serviceProvider,
IServiceDiscoveryProvider serviceDiscoveryProvider,
ConsulConfig serviceConfig)
{
_lifetime = lifetime;
_serviceProvider = serviceProvider;
_cancellationTokenSource = new CancellationTokenSource();
_serviceConfig = serviceConfig;
_serviceDiscoveryProvider = serviceDiscoveryProvider;
}
public void RegisterServiceDiscoveryProvider()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton <IConfiguration>(new ConfigurationBuilder().Build());
serviceCollection.AddServiceDiscovery();
IServiceDiscoveryProvider provider = serviceCollection
.BuildServiceProvider()
.GetService <IServiceDiscoveryProvider>();
provider.Should().NotBeNull();
}
/// <summary>
/// 获取所用服务的描述
/// 调试 http://127.0.0.1:729/api/Home/GetServiceDescriptor?address=127.0.0.1:98
/// </summary>
/// <param name="serviceDiscoveryProvider"></param>
/// <param name="address"></param>
/// <param name="queryParam"></param>
/// <returns></returns>
public async Task <IActionResult> GetAddress([FromServices] IServiceDiscoveryProvider serviceDiscoveryProvider, string address, string queryParam)
{
var adlist = await serviceDiscoveryProvider.GetAddressAsync();
IList <object> list = new List <object>();
foreach (ServiceAddressModel item in adlist)
{
var ip = item.Address as IpAddressModel;
string str = ip.Ip + ":" + ip.Port;
var lista = await serviceDiscoveryProvider.GetServiceDescriptorAsync(str);
list.Add(lista);
}
return(Json(new { A = adlist, B = list }));
}
public ConsulServiceRegisterHostedService(
IApplicationLifetime lifetime,
IServiceProvider serviceProvider,
IServiceDiscoveryProvider serviceDiscoveryProvider,
ConsulConfig serviceConfig)
{
_lifetime = lifetime;
_serviceProvider = serviceProvider;
_cancellationTokenSource = new CancellationTokenSource();
_serviceConfig = serviceConfig;
_serviceDiscoveryProvider = serviceDiscoveryProvider;
var interval = int.Parse(_serviceConfig.SERVICE_CHECK_INTERVAL.TrimEnd('s'));
_timer = new System.Timers.Timer((double)(interval * 1000));
}
public void CreateProvider()
{
var services = new ServiceCollection();
var builder = new OcelotBuilder(services, new ConfigurationBuilder().Build());
builder.Services.AddSingleton(new ConfigurationBuilder().Build());
builder.Services.AddMemoryCache();
var factory = AppConfigurationProviderFactory.Get;
IServiceDiscoveryProvider provider = factory(
services.BuildServiceProvider(),
new ServiceProviderConfiguration("", "", "", 1, "", "", 1),
new DownstreamRouteBuilder().WithServiceName("Users").Build());
provider.Should().NotBeNull();
}
public PollConsul(int pollingInterval, IOcelotLoggerFactory factory, IServiceDiscoveryProvider consulServiceDiscoveryProvider)
{
_logger = factory.CreateLogger <PollConsul>();
_consulServiceDiscoveryProvider = consulServiceDiscoveryProvider;
_services = new List <Service>();
_timer = new Timer(async x =>
{
if (_polling)
{
return;
}
_polling = true;
await Poll();
_polling = false;
}, null, pollingInterval, pollingInterval);
}
/// <summary>
/// HttpContext pipeline processing.
/// </summary>
/// <param name="httpContext">Http context.</param>
/// <param name="httpClientFactory">Http client factory.</param>
/// <param name="memoryCache">Cache for caching authorization token.</param>
/// <param name="serviceDiscoveryProvider">The service discovery provider.</param>
public async Task Invoke(
HttpContext httpContext,
IHttpClientFactory httpClientFactory,
IMemoryCache memoryCache,
IServiceDiscoveryProvider serviceDiscoveryProvider)
{
string userJwt = await GetUserAuthorizationJwtAsync(
httpContext,
httpClientFactory,
memoryCache,
serviceDiscoveryProvider);
if (!string.IsNullOrEmpty(userJwt))
{
AddUserProfileClaimsToIdentityAndHttpHeaders(httpContext, userJwt);
}
await _next(httpContext);
}
private void WhenIGetTheServiceProvider()
{
_result = _factory.Get(_serviceConfig);
}
public async Task <IActionResult> EditServiceToken([FromServices] IServiceDiscoveryProvider serviceDiscoveryProvider, IpAddressModel model)
{
await serviceDiscoveryProvider.EditServiceToken(model);
return(Json(ServiceResult.Create(true)));
}
public async Task <IActionResult> EditServiceToken([FromServices] IServiceDiscoveryProvider serviceDiscoveryProvider, string address)
{
var list = await serviceDiscoveryProvider.GetAddressAsync(address);;
return(View(list.FirstOrDefault()));
}
public PollKube(IServiceDiscoveryProvider serviceDiscoveryProvider)
{
this.serviceDiscoveryProvider = serviceDiscoveryProvider;
}
public Response <ILoadBalancer> Create(DownstreamRoute route, IServiceDiscoveryProvider serviceProvider)
{
return(new OkResponse <ILoadBalancer>(new RoundRobin(async() => await serviceProvider.Get())));
}
private string GetUrl(IServiceDiscoveryProvider provider, AuthorizationServiceOptions authorization) => provider.GetPath(authorization.ServiceName, authorization.PathName).ToString();
internal string GetHashAuthorization(IServiceDiscoveryProvider provider) => HashAuthorizationUrl ?? GetUrl(provider, HashAuthorization);
internal string GetAuthorizationUrl(IServiceDiscoveryProvider provider) => AuthorizationUrl ?? GetUrl(provider, Authorization);
public FakeLoadBalancer(DownstreamReRoute reRoute, IServiceDiscoveryProvider serviceDiscoveryProvider)
{
ReRoute = reRoute;
ServiceDiscoveryProvider = serviceDiscoveryProvider;
}
