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);
}
public async Task <List <ServiceRoute> > GetRoutesAsync()
{
if (_routes != null && _routes.Any())
{
return(_routes.ToList());
}
byte[] data = (await _consulClient.KV.Get(GetKey())).Response?.Value;
if (data == null)
{
return(_routes);
}
ServerDesc descriptor = _serializer.Deserialize <byte[], ServerDesc>(data);
if (descriptor != null)
{
foreach (ServiceDesc desc in descriptor.ServiceDescriptor)
{
_routes.Add(new ServiceRoute
{
ServiceDescriptor = desc.Clone() as ServiceDesc
});
}
}
return(_routes);
}
public bool Match(ServerDesc sd)
{
return(
string.Compare(sd.NodeType, NodeType, StringComparison.OrdinalIgnoreCase) == 0 &&
string.Compare(sd.NodeName, NodeName, StringComparison.OrdinalIgnoreCase) == 0 &&
sd.NodeId == NodeId);
}
public static NodeIdent FromServerDesc(ServerDesc sd)
{
return(new NodeIdent()
{
NodeType = sd.NodeType, NodeName = sd.NodeName, NodeId = sd.NodeId
});
}
private async Task UpdateRoutes()
{
List <ServerDesc> routes = new List <ServerDesc>();
foreach (Func <Task <ServerDesc> > routesGetter in _routesGetters)
{
ServerDesc server = await routesGetter();
if (server != null && server.ServiceDescriptor.Any())
{
routes.Add(server);
}
}
// merge service and its address by service id
ClearQueue(_routes);
foreach (ServerDesc route in routes)
{
_routes.Enqueue(route);
}
}
public async Task <List <ServerDesc> > GetRoutesAsync()
{
List <ServerAddress> addresses = await GetAddressAsync();
List <ServerDesc> reuslt = new List <ServerDesc>(_routesGetters.Count);
foreach (Func <Task <ServerDesc> > getter in _routesGetters)
{
ServerDesc server = await getter();
if (addresses.Where(x => x.Ip == server.ServerAddress.Ip && x.Port == server.ServerAddress.Port).Any())
{
byte[] data = (await _consulClient.KV.Get($"{server.ServerAddress.Ip}-{server.ServerAddress.Port}")).Response?.Value;
if (data == null)
{
continue;
}
ServerDesc descriptors = _serializer.Deserialize <byte[], ServerDesc>(data);
reuslt.Add(descriptors);
}
}
return(reuslt);
}
public async Task SetRoutesAsync(IEnumerable <ServiceRoute> routes)
{
_routes = routes.ToList();
ServerDesc routeDescriptor = new ServerDesc()
{
ServerAddress = _address,
ServiceDescriptor = new List <ServiceDesc>()
};
routeDescriptor.ServerAddress = _address;
foreach (ServiceRoute route in routes)
{
routeDescriptor.ServiceDescriptor.Add(route.ServiceDescriptor);
}
//await SetRoutesAsync(routeDescriptors);
byte[] nodeData = _serializer.Serialize <byte[]>(routeDescriptor);
KVPair keyValuePair = new KVPair(GetKey())
{
Value = nodeData
};
await _consulClient.KV.Put(keyValuePair);
}
void StartConnecting(ServerDesc sd)
{
_connectTask = Task.Run(() => rdClient.Connect(sd.IpAddress, sd.Port, 2.0));
}
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);
}
