/// <summary>
/// MemberList lists all the members in the cluster
/// </summary>
/// <param name="request">The request to send to the server.</param>
/// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
/// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
/// <param name="cancellationToken">An optional token for canceling the call.</param>
/// <returns>The response received from the server.</returns>
public MemberListResponse MemberList(MemberListRequest request, Grpc.Core.Metadata headers = null,
DateTime?deadline = null,
CancellationToken cancellationToken = default)
{
return(CallEtcd((connection) => connection.clusterClient
.MemberList(request, headers, deadline, cancellationToken)));
}
/// <summary>
/// MemberListAsync lists all the members in the cluster in async
/// </summary>
/// <param name="request">The request to send to the server.</param>
/// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
/// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
/// <param name="cancellationToken">An optional token for canceling the call.</param>
/// <returns>The response received from the server.</returns>
public async Task <MemberListResponse> MemberListAsync(MemberListRequest request,
Grpc.Core.Metadata headers = null, DateTime?deadline = null,
CancellationToken cancellationToken = default)
{
return(await CallEtcdAsync(async (connection) => await connection.clusterClient
.MemberListAsync(request, headers, deadline, cancellationToken)));
}
/// <summary>
/// MemberListAsync lists all the members in the cluster in async
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <MemberListResponse> MemberListAsync(MemberListRequest request, Grpc.Core.Metadata headers = null)
{
MemberListResponse response = new MemberListResponse();
bool success = false;
int retryCount = 0;
while (!success)
{
try
{
response = await _balancer.GetConnection().clusterClient.MemberListAsync(request, headers);
success = true;
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.Unavailable)
{
retryCount++;
if (retryCount >= _balancer._numNodes)
{
throw ex;
}
}
}
return(response);
}
public void DescribeCluster()
{
var request = new MemberListRequest();
var result = _client.MemberList(request);
Assert.NotZero(result.Members.Count);
}
public MemberListResponse MemberUpdate(MemberListRequest request)
{
var req = request.ToProto();
var rsp = client.MemberList(req);
return(rsp.FromProto());
}
/// <summary>
/// MemberList lists all the members in the cluster
/// </summary>
/// <param name="request">The request to send to the server.</param>
/// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
/// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
/// <param name="cancellationToken">An optional token for canceling the call.</param>
/// <returns>The response received from the server.</returns>
public MemberListResponse MemberList(MemberListRequest request, Grpc.Core.Metadata headers = null,
DateTime?deadline = null,
CancellationToken cancellationToken = default)
{
MemberListResponse response = new MemberListResponse();
bool success = false;
int retryCount = 0;
while (!success)
{
try
{
response = _balancer.GetConnection().clusterClient
.MemberList(request, headers, deadline, cancellationToken);
success = true;
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.Unavailable)
{
retryCount++;
if (retryCount >= _balancer._numNodes)
{
throw;
}
}
}
return(response);
}
/// <summary>
/// MemberList lists all the members in the cluster
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public MemberListResponse MemberList(MemberListRequest request, Metadata headers = null)
{
MemberListResponse response = new MemberListResponse();
response = _balancer.GetConnection().clusterClient.MemberList(request, headers);
return(response);
}
/// <summary>
/// MemberListAsync lists all the members in the cluster in async
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <MemberListResponse> MemberListAsync(MemberListRequest request, Metadata headers = null)
{
MemberListResponse response = new MemberListResponse();
response = await _balancer.GetConnection().clusterClient.MemberListAsync(request, headers);
return(response);
}
/// <summary>
/// MemberListAsync lists all the members in the cluster in async
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <MemberListResponse> MemberListAsync(MemberListRequest request)
{
MemberListResponse response = new MemberListResponse();
try
{
response = await _clusterClient.MemberListAsync(request, _headers);
}
catch (RpcException ex)
{
ResetConnection(ex);
throw;
}
catch
{
throw;
}
return(response);
}
/// <summary>
/// MemberList lists all the members in the cluster
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public MemberListResponse MemberList(MemberListRequest request)
{
MemberListResponse response = new MemberListResponse();
try
{
response = _clusterClient.MemberList(request, _headers);
}
catch (RpcException ex)
{
ResetConnection(ex);
throw;
}
catch
{
throw;
}
return(response);
}
/// <summary>
/// 更新集群列表
/// </summary>
/// <param name="client"></param>
private void UpdateCluster(EtcdClient client)
{
MemberListRequest request = new MemberListRequest();
var rsp = client.MemberList(request);
if (dic.ContainsKey(rsp.Header.ClusterId))
{
Health health = dic[rsp.Header.ClusterId];
health.Clients.Add(client);
health.Urls.Urls.Clear();
foreach (var kv in rsp.Members)
{
EtcdClientUrls urls = new EtcdClientUrls();
foreach (var c in kv.ClientURLs)
{
urls.Urls.Add(c);
}
health.Urls = urls;
}
health.Clients.Add(client);
}
}
public async Task <string> ListAllMembersInCluster()
{
MemberListRequest request = new MemberListRequest();
etcdClient.MemberList(request);
// Sync
//MemberListResponse res = etcdClient.MemberList(request);
// Async
MemberListResponse res = await etcdClient.MemberListAsync(request);
JsonMemberList = JsonConvert.SerializeObject(res);
// Do something with response
//foreach (var member in res.Members)
//{
// WriteLine($"member.ID: {member.ID} - member.Name: {member.Name} - member.PeerURLs :{member.PeerURLs} - member.ClientURLs: { member.ClientURLs}");
//}
return(JsonMemberList);
}
/// <summary>
/// 保持服务活动
/// </summary>
/// <param name="client">客户端</param>
/// <param name="key">服务Key</param>
/// <param name="ttl">服务更新时间</param>
/// <param name="ID">申请ID</param>
public async Task AddKeepAliveAsync(EtcdClient client, string key, long ttl, long ID)
{
//获取集群列表
MemberListRequest request = new MemberListRequest();
var rsp = await client.MemberListAsync(request);
if (minTTL > ttl)
{
if (minTTL == DefaultTTL)
{
//第一次修改
ExecuteTiks = (DefaultTTL - ttl) * STicks;//需要提前时间
}
else
{
//需要提前的时间减去已经运行的时间
ExecuteTiks = (minTTL - ttl) * STicks - (LastKeep - DateTime.Now.Ticks);
}
FulshTicks = FulshTicks - ExecuteTiks; //针对上次运行任务还剩余的时间
minTTL = ttl;
isUpdate = false; //无法正常允许了
}
if (!dic.ContainsKey(rsp.Header.ClusterId))
{
Health health = new Health
{
Clients = new List <EtcdClient>(),
KeyTTL = new Dictionary <string, long>(),
LastKeep = new Dictionary <string, long>(),
LeaseID = new Dictionary <string, long>()
};
foreach (var kv in rsp.Members)
{
EtcdClientUrls urls = new EtcdClientUrls();
foreach (var c in kv.ClientURLs)
{
urls.Urls.Add(c);
}
health.Urls = urls;
}
//
health.Clients.Add(client);
health.KeyTTL[key] = ttl;
health.LeaseID[key] = ID;
health.LastKeep[key] = DateTime.Now.Ticks;
dic[rsp.Header.ClusterId] = health;
Console.WriteLine("加入刷新");
}
else
{
Health health = dic[rsp.Header.ClusterId];
lock (health)
{
health.Clients.Add(client);
health.KeyTTL[key] = ttl;
health.LastKeep[key] = DateTime.Now.Ticks;
health.LeaseID[key] = ID;
}
}
}
