/// <summary>
/// Defragment defragments a member's backend database to recover storage space in async.
/// </summary>
/// <param name="request">Defragment Request</param>
/// <returns>Defragment Response</returns>
public async Task <DefragmentResponse> DefragmentAsync(DefragmentRequest request, Metadata headers = null)
{
DefragmentResponse response = new DefragmentResponse();
bool success = false;
int retryCount = 0;
while (!success)
{
try
{
response = await _balancer.GetConnection().maintenanceClient.DefragmentAsync(request, headers);
success = true;
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.Unavailable)
{
retryCount++;
if (retryCount >= _balancer._numNodes)
{
throw ex;
}
}
}
return(response);
}
/// <summary>
/// Defragment defragments a member's backend database to recover storage space in async.
/// </summary>
/// <param name="request">Defragment Request</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>Defragment Response</returns>
public async Task <DefragmentResponse> DefragmentAsync(DefragmentRequest request,
Grpc.Core.Metadata headers = null, DateTime?deadline = null,
CancellationToken cancellationToken = default)
{
DefragmentResponse response = new DefragmentResponse();
bool success = false;
int retryCount = 0;
while (!success)
{
try
{
response = await _balancer.GetConnection().maintenanceClient
.DefragmentAsync(request, headers, deadline, cancellationToken);
success = true;
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.Unavailable)
{
retryCount++;
if (retryCount >= _balancer._numNodes)
{
throw;
}
}
}
return(response);
}
/// <summary>
/// Defragment defragments a member's backend database to recover storage space in async.
/// </summary>
/// <param name="request">Defragment Request</param>
/// <returns>Defragment Response</returns>
public async Task <DefragmentResponse> DefragmentAsync(DefragmentRequest request, Metadata headers = null)
{
DefragmentResponse response = new DefragmentResponse();
response = await _balancer.GetConnection().maintenanceClient.DefragmentAsync(request, headers);
return(response);
}
/// <summary>
/// Defragment defragments a member's backend database to recover storage space.
/// </summary>
/// <param name="request">Defragment Request</param>
/// <returns>Defragment Response</returns>
public DefragmentResponse Defragment(DefragmentRequest request, Metadata headers = null)
{
DefragmentResponse response = new DefragmentResponse();
response = _balancer.GetConnection().maintenanceClient.Defragment(request, headers);
return(response);
}
/**
* defragment one member of the cluster.
*
* <p>After compacting the keyspace, the backend database may exhibit internal
* fragmentation. Any internal fragmentation is space that is free to use
* by the backend but still consumes storage space. The process of
* defragmentation releases this storage space back to the file system.
* Defragmentation is issued on a per-member so that cluster-wide latency
* spikes may be avoided.
*
* <p>Defragment is an expensive operation. User should avoid defragmenting
* multiple members at the same time.
* To defragment multiple members in the cluster, user need to call defragment
* multiple times with different endpoints.
*/
public DefragmentResponse DefragmentMember(Uri endpoint)
{
//需要一个全新的连接
var request = new Etcdserverpb.DefragmentRequest();
var rsp = maintenanceClient.Defragment(request);
DefragmentResponse response = new DefragmentResponse(rsp);
return(response);
//return Util.ToCompletableFuture(
// stub.Defragment(new Etcdserverpb.DefragmentRequest()),
// new FunctionResponse<Etcdserverpb.DefragmentRequest, DefragmentResponse>()
// );
}
/// <summary>
/// Defragment defragments a member's backend database to recover storage space in async.
/// </summary>
/// <param name="request">Defragment Request</param>
/// <returns>Defragment Response</returns>
public async Task <DefragmentResponse> DefragmentAsync(DefragmentRequest request)
{
DefragmentResponse response = new DefragmentResponse();
try
{
response = await _maintenanceClient.DefragmentAsync(request);
}
catch (RpcException)
{
ResetConnection();
throw;
}
catch
{
throw;
}
return(response);
}
/// <summary>
/// Defragment defragments a member's backend database to recover storage space.
/// </summary>
/// <param name="request">Defragment Request</param>
/// <returns>Defragment Response</returns>
public DefragmentResponse Defragment(DefragmentRequest request)
{
DefragmentResponse response = new DefragmentResponse();
try
{
response = _maintenanceClient.Defragment(request);
}
catch (RpcException)
{
ResetConnection();
throw;
}
catch
{
throw;
}
return(response);
}
