public static IServiceHostClientBuilder UseConsulForDiscovery(this IServiceHostClientBuilder serviceHostBuilder, RegisterServer registerServer, params ServerAddress[] address)
{
serviceHostBuilder.RegisterService(cb =>
{
cb.RegisterType <ConsulClientDiscovery>().As <IClientServiceDiscovery>().WithParameter("registerServer", registerServer).SingleInstance();
});
serviceHostBuilder.AddInitializer(container =>
{
IClientServiceDiscovery clientDiscovery = container.Resolve <IClientServiceDiscovery>();
foreach (ServerAddress addr in address)
{
clientDiscovery.AddRoutesGetter(() =>
{
ServerDesc serverDesc = new ServerDesc
{
ServerAddress = addr
};
return(Task.FromResult(serverDesc));
});
}
});
return(serviceHostBuilder);
}
/// <summary>
/// 选择负载均衡
/// </summary>
/// <param name="serviceHostBuilder"></param>
/// <returns></returns>
public static IServiceHostClientBuilder UsePollingAddressSelector(this IServiceHostClientBuilder serviceHostBuilder, BalanceType balanceType)
{
serviceHostBuilder.RegisterService(containerBuilder =>
{
switch (balanceType)
{
case BalanceType.RoundRobin:
containerBuilder.RegisterType <RoundRobin>().As <ILoadBalanceStrategy>().SingleInstance();
break;
case BalanceType.WeightRandom:
containerBuilder.RegisterType <WeightRandom>().As <ILoadBalanceStrategy>().SingleInstance();
break;
default:
containerBuilder.RegisterType <RoundRobin>().As <ILoadBalanceStrategy>().SingleInstance();
break;
}
containerBuilder.RegisterType <DefaultAddressSelector>().As <IAddressSelector>().WithParameter("balanceType", balanceType).SingleInstance();
});
serviceHostBuilder.AddInitializer(container =>
{
ILogger logger = container.Resolve <ILogger>();
logger.Info($"采用默认的地址选择器");
});
return(serviceHostBuilder);
}
public static IServiceHostClientBuilder UseServiceProxy(this IServiceHostClientBuilder serviceHostBuilder, string[] assemblyNames)
{
serviceHostBuilder.RegisterService(containerBuilder =>
{
containerBuilder.RegisterType <ServiceProxyGenerator>().As <IServiceProxyGenerator>().SingleInstance();
containerBuilder.RegisterType <ServiceProxy>().As <IServiceProxy>().SingleInstance();
containerBuilder.RegisterType <RemoteServiceCaller>().As <IRemoteServiceCaller>().SingleInstance();
});
var assemblies = new List <Assembly>();
foreach (var assemblyName in assemblyNames)
{
var assembly = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(assemblyName));
assemblies.Add(assembly);
}
var serviceTypes = assemblies.SelectMany(x => x.ExportedTypes).Where(x => x.GetMethods().Any(y => y.GetCustomAttribute <JimuServiceAttribute>() != null)).ToList();
serviceHostBuilder.AddInitializer(componentRegister =>
{
var serviceProxyGenerator = componentRegister.Resolve <IServiceProxyGenerator>();
var serviceProxyTypes = serviceProxyGenerator.GenerateProxy(serviceTypes);
var serviceProxy = componentRegister.Resolve <IServiceProxy>();
var logger = componentRegister.Resolve <ILogger>();
logger.Info($"[config]use service proxy");
});
return(serviceHostBuilder);
}
public static IServiceHostClientBuilder UseAutofacForMvc(this IServiceHostClientBuilder serviceHostBuilder, IServiceCollection services)
{
serviceHostBuilder.RegisterService(cb =>
{
cb.Populate(services);
});
return(serviceHostBuilder);
}
public static IServiceHostClientBuilder UseRemoteCache(this IServiceHostClientBuilder serviceHostBuilder, int capacity)
{
serviceHostBuilder.RegisterService(cb =>
{
cb.RegisterType <LRUCache <string, List <ServerAddress> > >().As <ICache <string, List <ServerAddress> > >().WithParameter("capacity", capacity).SingleInstance();
});
return(serviceHostBuilder);
}
/// <summary>
/// using polling load balancing to select server
/// </summary>
/// <param name="serviceHostBuilder"></param>
/// <returns></returns>
public static IServiceHostClientBuilder UsePollingAddressSelector(
this IServiceHostClientBuilder serviceHostBuilder)
{
serviceHostBuilder.RegisterService(containerBuilder =>
{
containerBuilder.RegisterType <PollingAddressSelector>().As <IAddressSelector>().SingleInstance();
});
serviceHostBuilder.AddInitializer(container =>
{
var logger = container.Resolve <ILogger>();
logger.Info($"[config]use polling address selector");
});
return(serviceHostBuilder);
}
public static IServiceHostClientBuilder UseServerHealthCheck(this IServiceHostClientBuilder serviceHostBuilder, int intervalMinute)
{
serviceHostBuilder.RegisterService(container =>
{
container.RegisterType <QuartzHealthCheck>().As <IHealthCheck>().WithParameter("intervalMinute", intervalMinute).SingleInstance();
});
serviceHostBuilder.AddInitializer(container =>
{
var healthCheck = container.Resolve <IHealthCheck>();
var logger = container.Resolve <ILogger>();
logger.Info($"[config]use server health check, checked job interval: {intervalMinute} min");
healthCheck.RunAsync();
});
return(serviceHostBuilder);
}
public static IServiceHostClientBuilder SetRemoteCallerRetryTimes(
this IServiceHostClientBuilder serviceHostBuilder, int retryTimes)
{
serviceHostBuilder.RegisterService(containerBuilder =>
{
containerBuilder.RegisterType <RemoteServiceCaller>().As <IRemoteServiceCaller>().WithParameter("retryTimes", retryTimes).SingleInstance();
});
serviceHostBuilder.AddInitializer(container =>
{
var logger = container.Resolve <ILogger>();
logger.Info($"[config]remote service call failure retry times: {retryTimes}");
});
return(serviceHostBuilder);
}
public static IServiceHostClientBuilder SetDiscoveryAutoUpdateJobInterval(
this IServiceHostClientBuilder serviceHostBuilder, int updateJobIntervalMinute)
{
serviceHostBuilder.RegisterService(containerBuilder =>
{
containerBuilder.RegisterType <ClientServiceDiscovery>().As <IClientServiceDiscovery>().WithParameter("updateJobIntervalMinute", updateJobIntervalMinute).SingleInstance();
});
serviceHostBuilder.AddInitializer(container =>
{
ILogger logger = container.Resolve <ILogger>();
logger.Info($"[config]services discovery auto update job interval: {updateJobIntervalMinute} min");
});
return(serviceHostBuilder);
}
public static IServiceHostClientBuilder UseIdentityServer(this IServiceHostClientBuilder serviceHostBuilder, Func <string, string, IDictionary <string, object> > getIdentityServerContext)
{
serviceHostBuilder.RegisterService(containerBuilder =>
{
containerBuilder.RegisterType <AuthorizationHandler>().As <IAuthorizationHandler>().SingleInstance();
});
serviceHostBuilder.AddInitializer(componentRegister =>
{
IAuthorizationHandler context = componentRegister.Resolve <IAuthorizationHandler>();
context.GetAuthorizationContext = getIdentityServerContext;
ILogger logger = componentRegister.Resolve <ILogger>();
logger.Info($"[config]identityserverExtension is set");
});
return(serviceHostBuilder);
}
public static IServiceHostClientBuilder UseToken(this IServiceHostClientBuilder serviceHostBuilder, Func <string> getToken)
{
serviceHostBuilder.RegisterService(containerBuilder =>
{
containerBuilder.RegisterType <ServiceTokenGetter>().As <IServiceTokenGetter>().SingleInstance();
});
serviceHostBuilder.AddInitializer(componentRegister =>
{
IServiceTokenGetter tokenGetter = componentRegister.Resolve <IServiceTokenGetter>();
tokenGetter.GetToken = getToken;
ILogger logger = componentRegister.Resolve <ILogger>();
logger.Info($"[config]get token has been set");
});
return(serviceHostBuilder);
}
public static IServiceHostClientBuilder UseInServerForDiscovery(this IServiceHostClientBuilder serviceHostBuilder, params ServerAddress[] address)
{
serviceHostBuilder.RegisterService(cb =>
{
cb.RegisterType <ClientServiceDiscovery>().As <IClientServiceDiscovery>().SingleInstance();
});
serviceHostBuilder.AddInitializer(container =>
{
IClientServiceDiscovery clientDiscovery = container.Resolve <IClientServiceDiscovery>();
IRemoteServiceExecutor remoteExecutor = container.Resolve <IRemoteServiceExecutor>();
ISerializer serializer = container.Resolve <ISerializer>();
ITypeConvertProvider typeConverter = container.Resolve <ITypeConvertProvider>();
ILogger logger = container.Resolve <ILogger>();
StringBuilder sb = new StringBuilder();
foreach (ServerAddress addr in address)
{
sb.AppendFormat(addr.Code + ",");
clientDiscovery.AddRoutesGetter(async() =>
{
RemoteCallBackData result = await remoteExecutor.InvokeAsync(new List <ServerAddress>()
{
addr
}, "Lamp.ServiceDiscovery.InServer.GetRoutesDescAsync".ToLower(), null, null);
if (result == null || result.HasError)
{
return(null);
}
List <ServiceRouteDesc> routesDesc = (List <ServiceRouteDesc>)typeConverter.Convert(result.Result, typeof(List <ServiceRouteDesc>));
ServerDesc server = new ServerDesc
{
ServerAddress = addr,
ServiceDescriptor = new List <ServiceDesc>()
};
server.ServerAddress.IsHealth = true;
foreach (ServiceRouteDesc desc in routesDesc)
{
ServiceDesc item = (ServiceDesc)desc.ServiceDescriptor.Clone();
server.ServiceDescriptor.Add(item);
}
return(server);
});
}
if (sb.Length > 0)
{
logger.Info($"[config]用服务端发现服务 {sb.ToString()}");
}
});
serviceHostBuilder.AddRunner(container =>
{
ClientServiceDiscovery clientServiceDiscovery = (ClientServiceDiscovery)container.Resolve <IClientServiceDiscovery>();
clientServiceDiscovery?.RunInInit().Wait();
});
return(serviceHostBuilder);
}
