public RunbookConfigurationHandler(IDiscoverRunbooks runbookHandler,
IResolveRunbookDependencies runbookDependencyHandler, ILoadBalance loadBalancer)
{
_runbookHandler = runbookHandler;
_runbookDependencyHandler = runbookDependencyHandler;
_loadBalancer = loadBalancer;
}
public ConsulHttpClient(IServiceDiscovery serviceDiscovery,
ILoadBalance loadBalance, HttpClient httpClient)
{
this.serviceDiscovery = serviceDiscovery;
this.loadBalance = loadBalance;
this.httpClient = httpClient;
}
/// <summary>
/// 使用loadbalance选择invoker.</br>
/// a)先lb选择，如果在selected列表中 或者 不可用且做检验时，进入下一步(重选),否则直接返回</br>
/// b)重选验证规则：selected > available .保证重选出的结果尽量不在select中，并且是可用的
/// </summary>
/// <param name="loadbalance"></param>
/// <param name="invocation"></param>
/// <param name="invokers"></param>
/// <param name="selected"> 已选过的invoker.注意：输入保证不重复</param>
/// <returns></returns>
protected URL select(ILoadBalance loadbalance, IInvocation invocation, IList <URL> invokers, IList <URL> selected)
{
if (invokers == null || invokers.Count == 0)
{
return(null);
}
string methodName = invocation == null ? "" : invocation.MethodInfo.Name;
var sticky = invokers[0].GetMethodParameter <bool>(methodName, CLUSTER_STICKY_KEY, DEFAULT_CLUSTER_STICKY);
{
//ignore overloaded method
if (invokers != null && !invokers.Contains(stickyInvoker))
{
stickyInvoker = null;
}
//ignore cucurrent problem
if (sticky && stickyInvoker != null && (selected == null || !selected.Contains(stickyInvoker)))
{
if (availablecheck)//&& stickyInvoker.IsAvailable()
{
return(stickyInvoker);
}
}
}
var invoker = doselect(loadbalance, invocation, invokers, selected);
if (sticky)
{
stickyInvoker = invoker;
}
return(invoker);
}
public RemoteSequence(IManageInfrastructureSequence infrastructureSequence, PreOpsSequence preOpsSequence, IEnumerable <ServerConfig> servers, ILoadBalance loadBalancer)
{
_infrastructureSequence = infrastructureSequence;
_preOpsSequence = preOpsSequence;
_servers = servers;
_loadBalancer = loadBalancer;
}
public ArtifactConfigurationHandler(IDiscoverArtifacts artifactHandler, IResolveArtifactDependencies artifactDependencyHandler, IDiscoverServers serverHandler, ILoadBalance loadBalancer)
{
_artifactHandler = artifactHandler;
_artifactDependencyHandler = artifactDependencyHandler;
_serverHandler = serverHandler;
_loadBalancer = loadBalancer;
}
public RemoteSequence(IManageInfrastructureSequence infrastructureSequence, PreOpsSequence preOpsSequence, IEnumerable<ServerConfig> servers, ILoadBalance loadBalancer)
{
_infrastructureSequence = infrastructureSequence;
_preOpsSequence = preOpsSequence;
_servers = servers;
_loadBalancer = loadBalancer;
}
public IList <BandMailboxRebalanceData> LoadBalanceForest(ILoadBalance loadBalancer, bool startMoves, ILogger logger, TimeSpan timeout)
{
RebalancingRequestMoveStarter moveStarter = new RebalancingRequestMoveStarter(this.context.ClientFactory, logger, this.context.QueueManager);
LoadContainer loadTopology = this.context.HeatMap.GetLoadTopology();
if (this.context.Settings.SoftDeletedCleanupEnabled)
{
int softDeletedCleanupThreshold = this.context.Settings.SoftDeletedCleanupThreshold;
SoftDeletedCleanUpRequest request = new SoftDeletedCleanUpRequest(loadTopology, this.context.ClientFactory, softDeletedCleanupThreshold, logger);
this.context.QueueManager.MainProcessingQueue.EnqueueRequest(request);
}
long aggregateConsumedLoad = loadTopology.GetAggregateConsumedLoad(InProgressLoadBalancingMoveCount.Instance);
if (aggregateConsumedLoad > this.context.Settings.MaximumPendingMoveCount)
{
logger.LogWarning("Did not start load balancing run because current number of pending moves {0} is greater than MaximumPendingMoveCount {1}", new object[]
{
aggregateConsumedLoad,
this.context.Settings.MaximumPendingMoveCount
});
return(Array <BandMailboxRebalanceData> .Empty);
}
ForestLoadBalanceRequest forestLoadBalanceRequest = new ForestLoadBalanceRequest(loadBalancer, startMoves, logger, moveStarter, loadTopology, new PartitionExtractor());
this.context.QueueManager.MainProcessingQueue.EnqueueRequest(forestLoadBalanceRequest);
forestLoadBalanceRequest.WaitExecutionAndThrowOnFailure(timeout);
return(forestLoadBalanceRequest.Results);
}
public ReadWriteDbConnectionFactory(ILoadBalance loadBalance)
{
var config = ConfigurationManager.GetSection("databases") as DatabaseConfig;
_databases = new ConcurrentDictionary <string, DatabaseSetting>(config.DatabaseSettings);
_loadBalance = loadBalance;
}
public ConsulHttpClient(IServiceDiscovery serviceDiscovery,
ILoadBalance loadBalance,
IHttpClientFactory httpClientFactory)
{
this.serviceDiscovery = serviceDiscovery;
this.loadBalance = loadBalance;
this.httpClientFactory = httpClientFactory;
}
protected LoadBalanceState GetServerState(ServerConfig server, ILoadBalance loadBalancer)
{
if (loadBalancer == null)
{
throw new ArgumentException("Missing loadbalancer");
}
return(loadBalancer.GetServerState(server.Name, server.LoadBalancerFarm));
}
public override IClusterResult DoInvoke(IClientPool pool, ILoadBalance loadbalance, URL address, IList <URL> urls, IInvocation invocation)
{
var goodUrls = new List <URL>();
var badUrls = new List <BadUrl>();
IResult result = null;
Exception exception = null;
var isThrow = false;
checkInvokers(urls, invocation);
var invoker = base.select(loadbalance, invocation, urls, null);
try
{
var client = pool.GetClient(invoker);
try
{
var refer = client.Refer();
result = refer.Invoke(invocation);
pool.Recovery(client);
goodUrls.Add(invoker);
}
catch (Exception ex)
{
pool.Recovery(client);
throw ex;
}
}
catch (Exception e)
{
isThrow = true;
if (e is RpcException && ((RpcException)e).Biz)
{ // biz exception.
exception = e;
//throw (RpcException)e;
}
else
{
exception = new RpcException(e is RpcException ? ((RpcException)e).Code : 0, "Failfast invoke providers "
+ invoker + " " + loadbalance.GetType().Name
+ " select from all providers " + string.Join(",", urls)
+ " for service " + invocation.TargetType.FullName
+ " method " + invocation.MethodInfo.Name
//+ " on consumer " + NetUtils.getLocalHost()
//+ " use zooyard version " + Version.getVersion()
+ ", but no luck to perform the invocation. Last error is: " + e.Message, e.InnerException != null ? e.InnerException : e);
}
badUrls.Add(new BadUrl {
Url = invoker, BadTime = DateTime.Now, CurrentException = exception
});
}
return(new ClusterResult(result, goodUrls, badUrls, exception, isThrow));
}
protected void BringOnline(ServerConfig server, IReportStatus status, ConDepSettings settings, ILoadBalance loadBalancer, CancellationToken token)
{
if (settings.Config.LoadBalancer == null) return;
if (server.LoadBalancerState.CurrentState == LoadBalanceState.Online) return;
Logger.WithLogSection(string.Format("Taking server [{0}] online in load balancer.", server.Name), () =>
{
loadBalancer.BringOnline(server.Name, server.LoadBalancerFarm, status);
server.LoadBalancerState.CurrentState = LoadBalanceState.Online;
});
}
public ForestLoadBalanceRequest(ILoadBalance loadBalancer, bool startMoves, ILogger logger, IRebalancingRequestProcessor moveStarter, LoadContainer forestTopology, PartitionExtractor partitionExtractor)
{
AnchorUtil.ThrowOnNullArgument(loadBalancer, "loadBalancer");
AnchorUtil.ThrowOnNullArgument(logger, "logger");
this.loadBalancer = loadBalancer;
this.startMoves = startMoves;
this.logger = logger;
this.moveStarter = moveStarter;
this.forestTopology = forestTopology;
this.partitionExtractor = partitionExtractor;
}
/// <summary>
/// 重选，先从非selected的列表中选择，没有在从selected列表中选择.
/// </summary>
/// <param name="loadbalance"></param>
/// <param name="invocation"></param>
/// <param name="invokers"></param>
/// <param name="selected"></param>
/// <param name="availablecheck"></param>
/// <returns></returns>
private URL reselect(ILoadBalance loadbalance, IInvocation invocation, IList <URL> invokers, IList <URL> selected, bool availablecheck)
{
//预先分配一个，这个列表是一定会用到的.
List <URL> reselectInvokers = new List <URL>(invokers.Count > 1 ? (invokers.Count - 1) : invokers.Count);
//先从非select中选
if (availablecheck)
{ //选isAvailable 的非select
foreach (var invoker in invokers)
{
if (selected == null || !selected.Contains(invoker))
{
reselectInvokers.Add(invoker);
}
}
if (reselectInvokers.Count > 0)
{
return(loadbalance.Select(reselectInvokers, invocation));
}
}
else
{ //选全部非select
foreach (var invoker in invokers)
{
if (selected == null || !selected.Contains(invoker))
{
reselectInvokers.Add(invoker);
}
}
if (reselectInvokers.Count > 0)
{
return(loadbalance.Select(reselectInvokers, invocation));
}
}
//最后从select中选可用的.
{
if (selected != null)
{
foreach (var invoker in selected)
{
if (!reselectInvokers.Contains(invoker))
{
reselectInvokers.Add(invoker);
}
}
}
if (reselectInvokers.Count > 0)
{
return(loadbalance.Select(reselectInvokers, invocation));
}
}
return(null);
}
public ServiceInfo GetServiceInfo(string serviceName, ILoadBalance loadBalance)
{
var infos = _consulServiceRefresh.GetServiceInfos(serviceName);
if (infos == null || infos.Count() < 1)
{
return(null);
}
ServiceInfo result = loadBalance.ChoseOne(infos);
return(result);
}
public ServiceInvokerBase(IRegistery registery, string groupPath, ILoadBalance loadBalance, IWeightCalculator <ServiceMetadata> weightCalculator)
{
_serviceIdentity = typeof(TService).Name;
_loadBalance = loadBalance;
_weightCalculator = weightCalculator;
_groupPath = groupPath;
_listener = new NotifyListener();
_listener.OnMetadataChanged += (metas) => _metadatas = metas;
_registery = registery;
_registery.Subscribe(_groupPath, _listener, true);
}
public MsgClient(ILoadBalance loadBalance)
{
LoadBalance = loadBalance;
var grpcUrl = LoadBalance.GetGrpcService("GrpcService");
if (!grpcUrl.Equals(""))
{
Console.WriteLine($"Grpc Service:{grpcUrl}");
GrpcChannel = new Channel(grpcUrl, ChannelCredentials.Insecure);
GrpcClient = new MsgService.MsgServiceClient(GrpcChannel);
}
}
private URL doselect(ILoadBalance loadbalance, IInvocation invocation, IList <URL> invokers, IList <URL> selected)
{
if (invokers == null || invokers.Count == 0)
{
return(null);
}
if (invokers.Count == 1)
{
return(invokers[0]);
}
// 如果只有两个invoker，退化成轮循
if (invokers.Count == 2 && selected?.Count > 0)
{
return(selected[0] == invokers[0] ? invokers[1] : invokers[0]);
}
var invoker = loadbalance.Select(invokers, invocation);
//如果 selected中包含（优先判断） 或者 不可用&&availablecheck=true 则重试.
if ((selected != null && selected.Contains(invoker)) || availablecheck)
{
try
{
var rinvoker = reselect(loadbalance, invocation, invokers, selected, availablecheck);
if (rinvoker != null)
{
invoker = rinvoker;
}
else
{
//看下第一次选的位置，如果不是最后，选+1位置.
int index = invokers.IndexOf(invoker);
try
{
//最后在避免碰撞
invoker = index < invokers.Count - 1 ? invokers[index + 1] : invoker;
}
catch (Exception e)
{
Logger().LogWarning(e, e.Message + " may because invokers list dynamic change, ignore.");
}
}
}
catch (Exception t)
{
Logger().LogError(t, $"clustor relselect fail reason is :{t.Message} if can not slove ,you can set cluster.availablecheck=false in url");
}
}
return(invoker);
}
public AbstractConsumer(IMessageHandler handler, ClientCacheContainer cacheContainer, ILoadBalance loadBalance, ISerializer serializer)
{
_handler = handler;
_handler.Recieved += Message_Recieved;
_cacheContainer = cacheContainer;
_loadBalance = loadBalance;
_serializer = serializer;
_transportProvider = new TransportProvider(_cacheContainer, serializer);
_connector = _transportProvider.GetConnector(_handler);
}
protected void BringOnline(ServerConfig server, ConDepSettings settings, ILoadBalance loadBalancer, CancellationToken token)
{
if (settings.Config.LoadBalancer == null)
{
return;
}
if (server.LoadBalancerState.CurrentState == LoadBalanceState.Online)
{
return;
}
Logger.WithLogSection($"Taking server [{server.Name}] online in load balancer.", () =>
{
loadBalancer.BringOnline(server.Name, server.LoadBalancerFarm);
server.LoadBalancerState.CurrentState = LoadBalanceState.Online;
});
}
public override IClusterResult DoInvoke(IClientPool pool, ILoadBalance loadbalance, URL address, IList <URL> urls, IInvocation invocation)
{
checkInvokers(urls, invocation);
RpcContext.GetContext().SetInvokers(urls);
Exception exception = null;
var goodUrls = new List <URL>();
var badUrls = new List <BadUrl>();
var isThrow = false;
IResult result = null;
foreach (var invoker in urls)
{
try
{
var client = pool.GetClient(invoker);
try
{
var refer = client.Refer();
result = refer.Invoke(invocation);
pool.Recovery(client);
goodUrls.Add(invoker);
}
catch (Exception ex)
{
pool.Recovery(client);
throw ex;
}
}
catch (Exception e)
{
exception = e;
badUrls.Add(new BadUrl {
Url = invoker, BadTime = DateTime.Now, CurrentException = exception
});
logger.Warn(e.Message, e);
}
}
if (exception != null)
{
isThrow = true;
}
var clusterResult = new ClusterResult(result, goodUrls, badUrls, exception, isThrow);
return(clusterResult);
}
protected override LoadBalanceDiagnosableResult ProcessDiagnostic()
{
LoadBalanceDiagnosableResult result = default(LoadBalanceDiagnosableResult);
if (base.Arguments.ShowQueues)
{
result.QueueManager = this.anchorContext.QueueManager.GetDiagnosticData(base.Arguments.ShowQueuedRequests, base.Arguments.Verbose);
}
if (base.Arguments.CleanQueues)
{
this.anchorContext.QueueManager.Clean();
}
if (base.Arguments.ShowLoadBalancerResults)
{
ILoadBalance loadBalancer = this.anchorContext.CreateLoadBalancer(base.Logger);
result.RebalanceResults = new AutomaticLoadBalancer(this.anchorContext).LoadBalanceForest(loadBalancer, base.Arguments.StartLoadBalance, base.Logger, TimeSpan.FromMinutes(5.0));
}
if (base.Arguments.RemoveSoftDeletedMailbox)
{
result.SoftDeletedMailboxRemovalResult = new SoftDeletedMailboxRemovalResult();
result.SoftDeletedMailboxRemovalResult.MailboxGuid = base.Arguments.MailboxGuid;
result.SoftDeletedMailboxRemovalResult.DatabaseGuid = base.Arguments.DatabaseGuid;
Exception ex;
result.SoftDeletedMailboxRemovalResult.Success = this.anchorContext.TryRemoveSoftDeletedMailbox(base.Arguments.MailboxGuid, base.Arguments.DatabaseGuid, out ex);
}
if (base.Arguments.GetMoveHistory)
{
result.SoftDeletedMoveHistoryResult = new SoftDeletedMoveHistoryResult();
result.SoftDeletedMoveHistoryResult.MailboxGuid = base.Arguments.MailboxGuid;
result.SoftDeletedMoveHistoryResult.TargetDatabaseGuid = base.Arguments.TargetDatabaseGuid;
result.SoftDeletedMoveHistoryResult.SourceDatabaseGuid = base.Arguments.SourceDatabaseGuid;
result.SoftDeletedMoveHistoryResult.MoveHistory = this.anchorContext.RetrieveSoftDeletedMailboxMoveHistory(base.Arguments.MailboxGuid, base.Arguments.TargetDatabaseGuid, base.Arguments.SourceDatabaseGuid);
}
if (base.Arguments.IsDrainingDatabase)
{
DirectoryDatabase database = this.anchorContext.Directory.GetDatabase(base.Arguments.DatabaseToDrainGuid);
BatchName drainBatchName = this.anchorContext.DrainControl.BeginDrainDatabase(database);
result.DatabaseToDrain = database.Identity;
result.DrainBatchName = drainBatchName;
}
return(result);
}
private void TurnRoundRobinServersAround(ILoadBalance loadBalancer, IEnumerable <ServerConfig> servers, int roundRobinMaxOfflineServers, ServerConfig testServer, IReportStatus status)
{
if (testServer != null)
{
loadBalancer.BringOnline(testServer.Name, testServer.LoadBalancerFarm, status);
}
var numberOfServers = roundRobinMaxOfflineServers - (testServer == null ? 0 : 1);
var serversToBringOnline = servers.Take(numberOfServers);
foreach (var server in serversToBringOnline)
{
loadBalancer.BringOnline(server.Name, server.LoadBalancerFarm, status);
}
var serversToBringOffline = servers.Skip(numberOfServers);
foreach (var server in serversToBringOffline)
{
loadBalancer.BringOffline(server.Name, server.LoadBalancerFarm, LoadBalancerSuspendMethod.Suspend, status);
}
}
public override IClusterResult DoInvoke(IClientPool pool, ILoadBalance loadbalance, URL address, IList <URL> urls, IInvocation invocation)
{
var goodUrls = new List <URL>();
var badUrls = new List <BadUrl>();
IResult result = null;
Exception exception = null;
checkInvokers(urls, invocation);
var invoker = base.select(loadbalance, invocation, urls, null);
try
{
var client = pool.GetClient(invoker);
try
{
var refer = client.Refer();
result = refer.Invoke(invocation);
pool.Recovery(client);
goodUrls.Add(invoker);
}
catch (Exception ex)
{
pool.Recovery(client);
throw ex;
}
}
catch (Exception e)
{
logger.Error("Failback to invoke method " + invocation.MethodInfo.Name + ", wait for retry in background. Ignored exception: " + e.Message + ", ", e);
addFailed(pool, invocation, invoker);
result = new RpcResult(); // ignore
exception = e;
badUrls.Add(new BadUrl {
Url = invoker, BadTime = DateTime.Now, CurrentException = exception
});
}
return(new ClusterResult(result, goodUrls, badUrls, exception, false));
}
public override IClusterResult DoInvoke(IClientPool pool, ILoadBalance loadbalance, URL address, IList <URL> urls, IInvocation invocation)
{
IResult result = null;
var goodUrls = new List <URL>();
var badUrls = new List <BadUrl>();
Exception exception = null;
checkInvokers(urls, invocation);
var invoker = base.select(loadbalance, invocation, urls, null);
try
{
var client = pool.GetClient(invoker);
try
{
var refer = client.Refer();
result = refer.Invoke(invocation);
pool.Recovery(client);
goodUrls.Add(invoker);
return(new ClusterResult(result, goodUrls, badUrls, exception, false));
}
catch (Exception ex)
{
pool.Recovery(client);
throw ex;
}
}
catch (Exception e)
{
exception = e;
badUrls.Add(new BadUrl {
Url = invoker, BadTime = DateTime.Now, CurrentException = exception
});
logger.Error("Failsafe ignore exception: " + e.Message, e);
result = new RpcResult(e); // ignore
}
return(new ClusterResult(result, goodUrls, badUrls, exception, false));
}
//public Int32 DefaultTopicQueueNums { get; set; } = 4;
//public Int32 SendMsgTimeout { get; set; } = 3_000;
//public Int32 CompressMsgBodyOverHowmuch { get; set; } = 4096;
//public Int32 RetryTimesWhenSendFailed { get; set; } = 2;
//public Int32 RetryTimesWhenSendAsyncFailed { get; set; } = 2;
//public Boolean RetryAnotherBrokerWhenNotStoreOK { get; set; }
//public Int32 MaxMessageSize { get; set; } = 4 * 1024 * 1024;
#endregion
#region 基础方法
/// <summary>启动</summary>
/// <returns></returns>
public override Boolean Start()
{
if (!base.Start())
{
return(false);
}
if (LoadBalance == null)
{
LoadBalance = new WeightRoundRobin();
}
if (_NameServer != null)
{
_NameServer.OnBrokerChange += (s, e) =>
{
_brokers = null;
//_robin = null;
LoadBalance.Ready = false;
};
}
return(true);
}
public static void Register(ILoadBalance loadBalance)
{
if (!LoadBalance.ContainsKey(loadBalance.Name())) {
LoadBalance.Add(loadBalance.Name(),loadBalance);
}
}
public override async Task <IClusterResult <T> > DoInvoke <T>(IClientPool pool, ILoadBalance loadbalance, URL address, IList <URL> urls, IInvocation invocation)
{
var goodUrls = new List <URL>();
var badUrls = new List <BadUrl>();
IResult <T> result = null;
Exception exception = null;
var isThrow = false;
checkInvokers(urls, invocation, address);
var invoker = base.select(loadbalance, invocation, urls, null);
try
{
var client = await pool.GetClient(invoker);
try
{
var refer = await client.Refer();
_source.WriteConsumerBefore(refer.Instance, invoker, invocation);
result = await refer.Invoke <T>(invocation);
_source.WriteConsumerAfter(invoker, invocation, result);
await pool.Recovery(client);
goodUrls.Add(invoker);
}
catch (Exception ex)
{
await pool.DestoryClient(client);
_source.WriteConsumerError(invoker, invocation, ex);
throw ex;
}
}
catch (Exception e)
{
isThrow = true;
if (e is RpcException eBiz && eBiz.Biz)
{
// biz exception.
exception = e;
//throw (RpcException)e;
}
public OfflinePriorityLoadBalancerExecutor(ILoadBalance loadBalancer) : base(loadBalancer)
{
_loadBalancer = loadBalancer;
}
public ExecutionSequenceManager(ILoadBalance loadBalancer)
{
_loadBalancer = loadBalancer;
}
private void TurnRoundRobinServersAround(ILoadBalance loadBalancer, IEnumerable<ServerConfig> servers, int roundRobinMaxOfflineServers, ServerConfig testServer, IReportStatus status)
{
if(testServer != null)
{
loadBalancer.BringOnline(testServer.Name, testServer.LoadBalancerFarm, status);
}
var numberOfServers = roundRobinMaxOfflineServers - (testServer == null ? 0 : 1);
var serversToBringOnline = servers.Take(numberOfServers);
foreach (var server in serversToBringOnline)
{
loadBalancer.BringOnline(server.Name, server.LoadBalancerFarm, status);
}
var serversToBringOffline = servers.Skip(numberOfServers);
foreach (var server in serversToBringOffline)
{
loadBalancer.BringOffline(server.Name, server.LoadBalancerFarm, LoadBalancerSuspendMethod.Suspend, status);
}
}
private IReportStatus ExecuteOnServer(ServerConfig server, IReportStatus status, ConDepOptions options, ILoadBalance loadBalancer, bool bringServerOfflineBeforeExecution, bool bringServerOnlineAfterExecution)
{
var errorDuringLoadBalancing = false;
try
{
Logger.LogSectionStart(server.Name);
if (bringServerOfflineBeforeExecution)
{
Logger.Info(string.Format("Taking server [{0}] offline in load balancer.", server.Name));
loadBalancer.BringOffline(server.Name, server.LoadBalancerFarm,
LoadBalancerSuspendMethod.Suspend, status);
}
ExecuteOnServer(server, status, options);
return status;
}
catch
{
errorDuringLoadBalancing = true;
throw;
}
finally
{
try
{
if (bringServerOnlineAfterExecution && !status.HasErrors && !errorDuringLoadBalancing)
{
Logger.Info(string.Format("Taking server [{0}] online in load balancer.", server.Name));
loadBalancer.BringOnline(server.Name, server.LoadBalancerFarm, status);
}
}
finally
{
Logger.LogSectionEnd(server.Name);
}
}
}
public RunbookConfigurationHandler(IDiscoverRunbooks runbookHandler, IResolveRunbookDependencies runbookDependencyHandler, ILoadBalance loadBalancer)
{
_runbookHandler = runbookHandler;
_runbookDependencyHandler = runbookDependencyHandler;
_loadBalancer = loadBalancer;
}
public ExecutionSequenceManager(ILoadBalance loadBalancer)
{
_loadBalancer = loadBalancer;
}
public RoundRobinLoadBalancerExecutor(IEnumerable<ServerConfig> servers, ILoadBalance loadBalancer)
{
_servers = servers;
_loadBalancer = loadBalancer;
}
public RoundRobinLoadBalancerExecutor(IEnumerable <ServerConfig> servers, ILoadBalance loadBalancer)
{
_servers = servers;
_loadBalancer = loadBalancer;
}
public override IClusterResult DoInvoke(IClientPool pool, ILoadBalance loadbalance, URL address, IList <URL> urls, IInvocation invocation)
{
var goodUrls = new List <URL>();
var badUrls = new List <BadUrl>();
var invokers = urls;
string merger = address.GetMethodParameter(invocation.MethodInfo.Name, MERGER_KEY);
if (string.IsNullOrEmpty(merger))
{
// If a method doesn't have a merger, only invoke one Group
foreach (var invoker in invokers)
{
try
{
var client = pool.GetClient(invoker);
try
{
var refer = client.Refer();
var invokeResult = refer.Invoke(invocation);
pool.Recovery(client);
goodUrls.Add(invoker);
return(new ClusterResult(invokeResult, goodUrls, badUrls, null, false));
}
catch (Exception ex)
{
pool.Recovery(client);
throw ex;
}
}
catch (Exception e)
{
badUrls.Add(new BadUrl {
Url = invoker, BadTime = DateTime.Now, CurrentException = e
});
return(new ClusterResult(new RpcResult(e), goodUrls, badUrls, e, true));
}
}
try
{
var client2 = pool.GetClient(invokers[0]);
try
{
var refer2 = client2.Refer();
var result2 = refer2.Invoke(invocation);
pool.Recovery(client2);
goodUrls.Add(invokers[0]);
return(new ClusterResult(result2, goodUrls, badUrls, null, false));
}
catch (Exception ex)
{
client2.Dispose();
throw ex;
}
}
catch (Exception e)
{
badUrls.Add(new BadUrl {
Url = invokers[0], BadTime = DateTime.Now, CurrentException = e
});
return(new ClusterResult(new RpcResult(e), goodUrls, badUrls, e, true));
}
}
Type returnType;
try
{
returnType = invocation.TargetType.GetMethod(invocation.MethodInfo.Name, invocation.ArgumentTypes).ReturnType;
}
catch (Exception)
{
returnType = null;
}
IDictionary <string, Task <IResult> > results = new Dictionary <string, Task <IResult> >();
foreach (var invoker in invokers)
{
var task = Task.Run <IResult>(() =>
{
try
{
var client = pool.GetClient(invoker);
try
{
var refer = client.Refer();
var invoceResult = refer.Invoke(invocation);
pool.Recovery(client);
goodUrls.Add(invoker);
return(invoceResult);
}
catch (Exception ex)
{
pool.Recovery(client);
throw ex;
}
}
catch (Exception e)
{
badUrls.Add(new BadUrl {
Url = invoker, BadTime = DateTime.Now, CurrentException = e
});
return(new RpcResult(e));
}
});
results.Add(invoker.ServiceKey, task);
}
object resultValue = null;
var resultList = new List <IResult>(results.Count);
int timeout = address.GetMethodParameter(invocation.MethodInfo.Name, TIMEOUT_KEY, DEFAULT_TIMEOUT);
Task.WaitAll(results.Values.ToArray(), timeout);
foreach (var entry in results)
{
try
{
//IResult r = future.GetAwaiter().GetResult();// (timeout, TimeUnit.MILLISECONDS);
var r = entry.Value.Result;
if (r.HasException)
{
logger.Error($"Invoke {entry.Key} {getGroupDescFromServiceKey(entry.Key)} failed: {r.Exception.Message}", r.Exception);
}
else
{
resultList.Add(r);
}
}
catch (Exception e)
{
var ex = new RpcException($"Failed to invoke service {entry.Key}: {e.Message}", e);
return(new ClusterResult(new RpcResult(ex), goodUrls, badUrls, ex, true));
}
}
if (resultList.Count == 0)
{
return(new ClusterResult(new RpcResult(), goodUrls, badUrls, null, false));
}
else if (resultList.Count == 1)
{
return(new ClusterResult(resultList[0], goodUrls, badUrls, null, false));
}
if (returnType == typeof(void))
{
return(new ClusterResult(new RpcResult(), goodUrls, badUrls, null, false));
}
if (merger.StartsWith("."))
{
merger = merger.Substring(1);
MethodInfo method;
try
{
method = returnType.GetMethod(merger, new[] { returnType });
}
catch (Exception e)
{
var ex = new RpcException($"Can not merge result because missing method [{merger}] in class [{returnType.Name}]{e.Message}", e);
return(new ClusterResult(new RpcResult(ex), goodUrls, badUrls, ex, true));
}
if (method == null)
{
var ex = new RpcException($"Can not merge result because missing method [ {merger} ] in class [ {returnType.Name} ]");
return(new ClusterResult(new RpcResult(ex), goodUrls, badUrls, ex, true));
}
//if (!method.IsPublic)
//{
//method.setAccessible(true);
//}
resultValue = resultList[0].Value;
resultList.RemoveAt(0);
try
{
if (method.ReturnType != typeof(void) &&
method.ReturnType.IsAssignableFrom(resultValue.GetType()))
{
foreach (var r in resultList)
{
resultValue = method.Invoke(resultValue, new[] { r.Value });
}
}
else
{
foreach (var r in resultList)
{
method.Invoke(resultValue, new[] { r.Value });
}
}
}
catch (Exception e)
{
var ex = new RpcException($"Can not merge result: {e.Message}", e);
return(new ClusterResult(new RpcResult(ex), goodUrls, badUrls, ex, true));
}
}
else
{
IMerger resultMerger;
if (merger.ToLower() == "true" || merger.ToLower() == "default")
{
//resultMerger = DefaultMergers[returnType];
resultMerger = MergerFactory.GetMerger(returnType, DefaultMergers);
}
else
{
resultMerger = MySelfMergers[merger];
//resultMerger = ExtensionLoader.getExtensionLoader(Merger.class).getExtension(merger);
}
if (resultMerger != null)
{
var rets = new List <object>(resultList.Count);
foreach (var r in resultList)
{
rets.Add(r.Value);
}
resultValue = resultMerger.GetType().GetMethod("Merge", new Type[] { returnType }).Invoke(resultMerger, new[] { rets });
}
else
{
var ex = new RpcException("There is no merger to merge result.");
return(new ClusterResult(new RpcResult(ex), goodUrls, badUrls, ex, true));
}
}
return(new ClusterResult(new RpcResult(resultValue), goodUrls, badUrls, null, false));
}
public StickyLoadBalancerExecutor(ILoadBalance loadBalancer)
{
_loadBalancer = loadBalancer;
}
public ConsulHttpClient(IServiceDiscovery serviceDiscovery, ILoadBalance loadBalance, IHttpClientFactory httpClientFactory)
{
_serviceDiscovery = serviceDiscovery;
_loadBalance = loadBalance;
_httpClientFactory = httpClientFactory;
}
public ExecutionSequenceManager(IEnumerable<ServerConfig> servers, ILoadBalance loadBalancer)
{
_servers = servers;
_loadBalancer = loadBalancer;
_internalLoadBalancer = GetLoadBalancer();
}
