public async Task RegisterServiceAsync(string serviceName, string groupName, Instance instance)
{
_logger?.LogInformation("[REGISTER-SERVICE] {0} registering service {1} with instance: {2}", namespaceId, serviceName, instance);
string groupedServiceName = NamingUtils.GetGroupedName(serviceName, groupName);
if (instance.Ephemeral)
{
BeatInfo beatInfo = beatReactor.BuildBeatInfo(groupedServiceName, instance);
beatReactor.AddBeatInfo(groupedServiceName, beatInfo);
}
var paramters = new Dictionary <string, string>()
{
{ CommonParams.NAMESPACE_ID, namespaceId },
{ CommonParams.SERVICE_NAME, groupedServiceName },
{ CommonParams.GROUP_NAME, groupName },
{ CommonParams.CLUSTER_NAME, instance.ClusterName },
{ CommonParams.IP_PARAM, instance.Ip },
{ CommonParams.PORT_PARAM, instance.Port.ToString() },
{ CommonParams.WEIGHT_PARAM, instance.Weight.ToString() },
{ CommonParams.ENABLE_PARAM, instance.Enabled.ToString() },
{ CommonParams.HEALTHY_PARAM, instance.Healthy.ToString() },
{ CommonParams.EPHEMERAL_PARAM, instance.Ephemeral.ToString() },
{ CommonParams.META_PARAM, instance.Metadata.ToJsonString() },
};
await ReqApi(UtilAndComs.NacosUrlInstance, paramters, HttpMethod.Post).ConfigureAwait(false);
}
public async Task <ServiceInfo> QueryInstancesOfService(string serviceName, string groupName, string clusters, int udpPort, bool healthyOnly)
{
string groupedServiceName = NamingUtils.GetGroupedName(serviceName, groupName);
var paramters = new Dictionary <string, string>()
{
{ CommonParams.NAMESPACE_ID, namespaceId },
{ CommonParams.SERVICE_NAME, groupedServiceName },
{ CommonParams.CLUSTER_NAME, clusters },
{ "udpPort", udpPort.ToString() },
// TODO:
{ "clientIP", "127.0.0.1" },
{ "healthyOnly", healthyOnly.ToString() },
};
var result = await ReqApi(UtilAndComs.NacosUrlBase + "/instance/list", paramters, HttpMethod.Get);
if (!string.IsNullOrWhiteSpace(result))
{
return(result.ToObj <ServiceInfo>());
}
return(new ServiceInfo(groupedServiceName, clusters));
}
public async Task RegisterServiceAsync(string serviceName, string groupName, Instance instance)
{
_logger?.LogInformation("[REGISTER-SERVICE] {0} registering service {1} with instance: {2}", namespaceId, serviceName, instance);
string groupedServiceName = NamingUtils.GetGroupedName(serviceName, groupName);
if (instance.Ephemeral)
{
BeatInfo beatInfo = beatReactor.BuildBeatInfo(groupedServiceName, instance);
beatReactor.AddBeatInfo(groupedServiceName, beatInfo);
}
var paramters = new Dictionary <string, string>()
{
{ CommonParams.NAMESPACE_ID, namespaceId },
{ CommonParams.SERVICE_NAME, groupedServiceName },
{ CommonParams.GROUP_NAME, groupName },
{ CommonParams.CLUSTER_NAME, instance.ClusterName },
{ "ip", instance.Ip },
{ "port", instance.Port.ToString() },
{ "weight", instance.Weight.ToString() },
{ "enable", instance.Enabled.ToString() },
{ "healthy", instance.Healthy.ToString() },
{ "ephemeral", instance.Ephemeral.ToString() },
{ "metadata", instance.Metadata.ToJsonString() },
};
await ReqApi(UtilAndComs.NacosUrlInstance, paramters, HttpMethod.Post);
}
public bool IsSubscribed(string groupName, string serviceName, string clusters)
{
string key = ServiceInfo.GetKey(NamingUtils.GetGroupedName(serviceName, groupName), clusters);
return(listenerMap.TryGetValue(key, out var eventListeners) &&
eventListeners != null && eventListeners.Any());
}
/// <summary>
/// Cache subscriber for redo.
/// </summary>
/// <param name="serviceName">service name</param>
/// <param name="groupName">group name</param>
/// <param name="cluster">cluster</param>
public void CacheSubscriberForRedo(string serviceName, string groupName, string cluster)
{
string key = ServiceInfo.GetKey(NamingUtils.GetGroupedName(serviceName, groupName), cluster);
var redoData = SubscriberRedoData.Build(serviceName, groupName, cluster);
_subscribes.AddOrUpdate(key, redoData, (x, y) => redoData);
}
/// <summary>
/// Cache registered instance for redo.
/// </summary>
/// <param name="serviceName">service name</param>
/// <param name="groupName">group name</param>
/// <param name="instance">registered instance</param>
public void CacheInstanceForRedo(string serviceName, string groupName, Instance instance)
{
string key = NamingUtils.GetGroupedName(serviceName, groupName);
var redoData = InstanceRedoData.Build(serviceName, groupName, instance);
_registeredInstances.AddOrUpdate(key, redoData, (x, y) => redoData);
}
public async Task Unsubscribe(string serviceName, string groupName, string clusters)
{
var request = new SubscribeServiceRequest(namespaceId, serviceName, groupName, clusters, true);
await RequestToServer <SubscribeServiceResponse>(request);
namingGrpcConnectionEventListener.RemoveSubscriberForRedo(NamingUtils.GetGroupedName(serviceName, groupName), clusters);
}
public async Task <ServiceInfo> Subscribe(string serviceName, string groupName, string clusters)
{
var request = new SubscribeServiceRequest(namespaceId, serviceName, groupName, clusters, true);
var response = await RequestToServer <SubscribeServiceResponse>(request).ConfigureAwait(false);
namingGrpcConnectionEventListener.CacheSubscriberForRedo(NamingUtils.GetGroupedName(serviceName, groupName), clusters);
return(response.ServiceInfo);
}
public UpdateModel(string serviceName, string groupName, string clusters)
{
this.ServiceName = serviceName;
this.GroupName = groupName;
this.Clusters = clusters;
this.GroupedServiceName = NamingUtils.GetGroupedName(serviceName, groupName);
this.ServiceKey = ServiceInfo.GetKey(GroupedServiceName, clusters);
}
internal void RemoveInstanceForRedo(string serviceName, string groupName, Instance instance)
{
string key = NamingUtils.GetGroupedName(serviceName, groupName);
if (_registeredInstanceCached.TryGetValue(key, out var instances))
{
instances.Remove(instance);
}
}
/// <summary>
/// Instance deregister, mark unregistering status as true.
/// </summary>
/// <param name="serviceName">service name</param>
/// <param name="groupName">group name</param>
public void InstanceDeregister(string serviceName, string groupName)
{
string key = NamingUtils.GetGroupedName(serviceName, groupName);
if (_registeredInstances.TryGetValue(key, out var data))
{
data.Unregistering = true;
}
}
/// <summary>
/// Subscriber deregister, mark unregistering status as true.
/// </summary>
/// <param name="serviceName">service name</param>
/// <param name="groupName">group name</param>
/// <param name="cluster">cluster</param>
public void SubscriberDeregister(string serviceName, string groupName, string cluster)
{
string key = ServiceInfo.GetKey(NamingUtils.GetGroupedName(serviceName, groupName), cluster);
if (_subscribes.TryGetValue(key, out var data))
{
data.Unregistering = true;
}
}
internal Dtos.ServiceInfo GetServiceInfo(string serviceName, string groupName, string clusters)
{
string groupedServiceName = NamingUtils.GetGroupedName(serviceName, groupName);
string key = ServiceInfo.GetKey(groupedServiceName, clusters);
/*if (failoverReactor.isFailoverSwitch())
* {
* return failoverReactor.getService(key);
* }*/
return(serviceInfoMap.TryGetValue(key, out var serviceInfo) ? serviceInfo : null);
}
public void StopUpdateIfContain(string serviceName, string groupName, string clusters)
{
string serviceKey = ServiceInfo.GetKey(NamingUtils.GetGroupedName(serviceName, groupName), clusters);
if (_timerMap.TryRemove(serviceKey, out var t))
{
t?.Change(Timeout.Infinite, Timeout.Infinite);
t?.Dispose();
_logger?.LogInformation("stop update task, servicekey:{0}", serviceKey);
}
}
internal Dtos.ServiceInfo GetServiceInfo(string serviceName, string groupName, string clusters)
{
_logger?.LogDebug("failover-mode:{0}", _failoverReactor.IsFailoverSwitch());
string groupedServiceName = NamingUtils.GetGroupedName(serviceName, groupName);
string key = ServiceInfo.GetKey(groupedServiceName, clusters);
if (_failoverReactor.IsFailoverSwitch())
{
return(_failoverReactor.GetService(key));
}
return(_serviceInfoMap.TryGetValue(key, out var serviceInfo) ? serviceInfo : null);
}
public void ScheduleUpdateIfAbsent(string serviceName, string groupName, string clusters)
{
string serviceKey = ServiceInfo.GetKey(NamingUtils.GetGroupedName(serviceName, groupName), clusters);
if (_timerMap.TryGetValue(serviceKey, out _))
{
return;
}
var task = UpdateTask(serviceName, groupName, clusters);
_timerMap.TryAdd(serviceKey, task);
}
private async Task RunUpdateTask(string serviceName, string groupName, string clusters)
{
int delayTime = -1;
var serviceKey = ServiceInfo.GetKey(NamingUtils.GetGroupedName(serviceName, groupName), clusters);
try
{
if (!changeNotifier.IsSubscribed(groupName, serviceName, clusters) && !_updatingMap.ContainsKey(serviceKey))
{
// TODO logger
return;
}
if (!serviceInfoHolder.GetServiceInfoMap().TryGetValue(serviceKey, out var serviceObj))
{
serviceObj = await namingClientProxy.QueryInstancesOfService(serviceName, groupName, clusters, 0, false);
serviceInfoHolder.ProcessServiceInfo(serviceObj);
delayTime = DEFAULT_DELAY;
// TODO lastRefTime serviceObj.LastRefTime
return;
}
if (serviceObj.LastRefTime <= 0)
{
serviceObj = await namingClientProxy.QueryInstancesOfService(serviceName, groupName, clusters, 0, false);
serviceInfoHolder.ProcessServiceInfo(serviceObj);
}
// TODO lastRefTime serviceObj.LastRefTime
if (serviceObj.Hosts == null || serviceObj.Hosts.Any())
{
// incFailCount
return;
}
delayTime = (int)serviceObj.CacheMillis * DEFAULT_UPDATE_CACHE_TIME_MULTIPLE;
// resetFailCount
}
catch (System.Exception)
{
// logger
}
finally
{
// next
}
}
public async Task <ServiceInfo> Subscribe(string serviceName, string groupName, string clusters)
{
string serviceNameWithGroup = NamingUtils.GetGroupedName(serviceName, groupName);
string serviceKey = ServiceInfo.GetKey(serviceNameWithGroup, clusters);
if (!serviceInfoHolder.GetServiceInfoMap().TryGetValue(serviceKey, out var result))
{
result = await GetExecuteClientProxy().Subscribe(serviceName, groupName, clusters);
}
_serviceInfoUpdateService.ScheduleUpdateIfAbsent(serviceName, groupName, clusters);
serviceInfoHolder.ProcessServiceInfo(result);
return(result);
}
public void OnEvent(InstancesChangeEvent @event)
{
string key = ServiceInfo.GetKey(NamingUtils.GetGroupedName(@event.ServiceName, @event.GroupName), @event.Clusters);
if (!listenerMap.TryGetValue(key, out var eventListeners))
{
return;
}
foreach (var listener in eventListeners)
{
listener.OnEvent(@event);
}
}
internal void CacheInstanceForRedo(string serviceName, string groupName, Instance instance)
{
string key = NamingUtils.GetGroupedName(serviceName, groupName);
if (_registeredInstanceCached.TryGetValue(key, out var instances))
{
instances.Add(instance);
}
else
{
_registeredInstanceCached[key] = new HashSet <Instance> {
instance
};
}
}
public void DeregisterListener(string groupName, string serviceName, string clusters, IEventListener listener)
{
string key = ServiceInfo.GetKey(NamingUtils.GetGroupedName(serviceName, groupName), clusters);
if (!listenerMap.TryGetValue(key, out var eventListeners))
{
return;
}
eventListeners.Remove(listener);
if (eventListeners == null || !eventListeners.Any())
{
listenerMap.TryRemove(key, out _);
}
}
public void RegisterListener(string groupName, string serviceName, string clusters, IEventListener listener)
{
string key = ServiceInfo.GetKey(NamingUtils.GetGroupedName(serviceName, groupName), clusters);
if (!listenerMap.TryGetValue(key, out var eventListeners))
{
lock (obj)
{
listenerMap.TryGetValue(key, out eventListeners);
if (eventListeners == null)
{
eventListeners = new HashSet <IEventListener>();
listenerMap[key] = eventListeners;
}
}
}
eventListeners.Add(listener);
}
public void ScheduleUpdateIfAbsent(string serviceName, string groupName, string clusters)
{
string serviceKey = ServiceInfo.GetKey(NamingUtils.GetGroupedName(serviceName, groupName), clusters);
var task = new TaskCompletionSource <bool>();
if (_updatingMap.TryAdd(serviceKey, task.Task))
{
_ = RunUpdateTask(serviceName, groupName, clusters);
task.SetResult(true);
}
else
{
// hold a moment waiting for update finish
if (_updatingMap.TryGetValue(serviceKey, out var waitTask))
{
waitTask.Wait(DEFAULT_DELAY);
}
}
}
public async Task <ServiceInfo> QueryInstancesOfService(string serviceName, string groupName, string clusters, int udpPort, bool healthyOnly)
{
string groupedServiceName = NamingUtils.GetGroupedName(serviceName, groupName);
var paramters = new Dictionary <string, string>()
{
{ CommonParams.NAMESPACE_ID, namespaceId },
{ CommonParams.SERVICE_NAME, groupedServiceName },
{ CommonParams.CLUSTER_NAME, clusters },
{ CommonParams.UDP_PORT_PARAM, udpPort.ToString() },
{ CommonParams.CLIENT_IP_PARAM, NetUtils.LocalIP() },
{ CommonParams.HEALTHY_ONLY_PARAM, healthyOnly.ToString() },
};
var result = await ReqApi(UtilAndComs.NacosUrlBase + "/instance/list", paramters, HttpMethod.Get).ConfigureAwait(false);
if (!string.IsNullOrWhiteSpace(result))
{
return(result.ToObj <ServiceInfo>());
}
return(new ServiceInfo(groupedServiceName, clusters));
}
public async Task DeregisterService(string serviceName, string groupName, Instance instance)
{
_logger?.LogInformation("[REGISTER-SERVICE] {0} deregistering service {1} with instance: {2}", namespaceId, serviceName, instance);
string groupedServiceName = NamingUtils.GetGroupedName(serviceName, groupName);
if (instance.Ephemeral)
{
beatReactor.RemoveBeatInfo(groupedServiceName, instance.Ip, instance.Port);
}
var paramters = new Dictionary <string, string>()
{
{ CommonParams.NAMESPACE_ID, namespaceId },
{ CommonParams.SERVICE_NAME, groupedServiceName },
{ CommonParams.GROUP_NAME, groupName },
{ CommonParams.CLUSTER_NAME, instance.ClusterName },
{ "ip", instance.Ip },
{ "port", instance.Port.ToString() },
{ "ephemeral", instance.Ephemeral.ToString() },
};
await ReqApi(UtilAndComs.NacosUrlInstance, paramters, HttpMethod.Delete);
}
internal void RemoveInstanceForRedo(string serviceName, string groupName, Instance instance)
{
string key = NamingUtils.GetGroupedName(serviceName, groupName);
_registeredInstanceCached.TryRemove(key, out _);
}
public void StopUpdateIfContain(string serviceName, string groupName, string clusters)
{
string serviceKey = ServiceInfo.GetKey(NamingUtils.GetGroupedName(serviceName, groupName), clusters);
_updatingMap.TryRemove(serviceKey, out _);
}
/// <summary>
/// Remove registered instance for redo.
/// </summary>
/// <param name="serviceName">service name</param>
/// <param name="groupName">group name</param>
public void RemoveInstanceForRedo(string serviceName, string groupName)
{
string key = NamingUtils.GetGroupedName(serviceName, groupName);
_registeredInstances.TryRemove(key, out _);
}
private Timer UpdateTask(string serviceName, string groupName, string clusters)
{
return(new Timer(
async x =>
{
var state = x as UpdateModel;
int delayTime = DEFAULT_DELAY;
try
{
if (!changeNotifier.IsSubscribed(state.GroupName, state.ServiceName, state.Clusters) && !_timerMap.ContainsKey(state.ServiceKey))
{
_logger?.LogInformation("update task is stopped, service:{0}, clusters:{1}", state.GroupedServiceName, state.Clusters);
return;
}
if (!serviceInfoHolder.GetServiceInfoMap().TryGetValue(state.ServiceKey, out var serviceObj))
{
serviceObj = await namingClientProxy.QueryInstancesOfService(state.ServiceName, state.GroupName, state.Clusters, 0, false);
serviceInfoHolder.ProcessServiceInfo(serviceObj);
delayTime = DEFAULT_DELAY;
state.LastRefTime = serviceObj.LastRefTime;
return;
}
if (serviceObj.LastRefTime <= state.LastRefTime)
{
serviceObj = await namingClientProxy.QueryInstancesOfService(serviceName, groupName, clusters, 0, false);
serviceInfoHolder.ProcessServiceInfo(serviceObj);
}
state.LastRefTime = serviceObj.LastRefTime;
if (serviceObj.Hosts == null || !serviceObj.Hosts.Any())
{
state.IncFailCount();
return;
}
delayTime = (int)serviceObj.CacheMillis * DEFAULT_UPDATE_CACHE_TIME_MULTIPLE;
state.ResetFailCount();
}
catch (Exception ex)
{
state.IncFailCount();
_logger?.LogWarning(ex, "[NA] failed to update serviceName: {0}", NamingUtils.GetGroupedName(state.ServiceName, state.GroupName));
}
finally
{
_timerMap.TryGetValue(state.ServiceKey, out var self);
var due = Math.Min(delayTime << state.FailCount, DEFAULT_DELAY * 60);
// _logger?.LogInformation("update service info due = {0}, {1}, {2}, {3}", due, delayTime << state.FailCount, delayTime, state.FailCount);
self?.Change(due, Timeout.Infinite);
}
}, new UpdateModel(serviceName, groupName, clusters), DEFAULT_DELAY, Timeout.Infinite));
}
/// <summary>
/// Remove subscriber for redo.
/// </summary>
/// <param name="serviceName">service name</param>
/// <param name="groupName">group name</param>
/// <param name="cluster">cluster</param>
public void RemoveSubscriberForRedo(string serviceName, string groupName, string cluster)
{
string key = ServiceInfo.GetKey(NamingUtils.GetGroupedName(serviceName, groupName), cluster);
_subscribes.TryRemove(key, out _);
}