private async Task <bool> CheckPersistToAsync(ObserveParams observeParams)
{
if (observeParams.PersistTo == PersistTo.Zero)
{
return(true);
}
var op = new ObserveSeqno(observeParams.Token, _clusterController.Transcoder, _timeout);
observeParams.Operation = op;
var tcs = new TaskCompletionSource <IOperationResult <ObserveSeqnoResponse> >();
op.Completed = CallbackFactory.CompletedFuncForRetry(_pending, _clusterController, tcs);
_pending.TryAdd(op.Opaque, op);
var server = await GetServerAsync(observeParams);
await server.SendAsync(op).ContinueOnAnyContext();
var response = await tcs.Task.ContinueOnAnyContext();
observeParams.CheckMutationLost(response);
observeParams.CheckPersisted(response);
return(observeParams.IsDurabilityMet());
}
static Task <bool> CheckReplicaAsync(ObserveParams observeParams, ObserveSeqno op, int replicaId)
{
var cloned = (ObserveSeqno)op.Clone();
var replica = observeParams.VBucket.LocateReplica(replicaId);
var result = replica.Send(cloned);
observeParams.CheckMutationLost(result.Value);
observeParams.CheckPersisted(result.Value);
observeParams.CheckReplicated(result.Value);
return(Task.FromResult(observeParams.IsDurabilityMet()));
}
/// <summary>
/// Checks a replica for durability constraints.
/// </summary>
/// <param name="observeParams">The observe parameters.</param>
/// <param name="op">The op.</param>
/// <param name="replicaId">The replica identifier.</param>
/// <returns></returns>
private bool CheckReplica(ObserveParams observeParams, ObserveSeqno op, int replicaId)
{
var cloned = (ObserveSeqno)op.Clone();
var replica = observeParams.VBucket.LocateReplica(replicaId);
var result = replica.Send(cloned);
observeParams.CheckMutationLost(result);
observeParams.CheckPersisted(result);
observeParams.CheckReplicated(result);
return(observeParams.IsDurabilityMet());
}
/// <summary>
/// Observes the specified key using the Seqno.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="token">The token.</param>
/// <param name="replicateTo">The replicate to.</param>
/// <param name="persistTo">The persist to.</param>
/// <returns>True if durability constraints were matched.</returns>
/// <exception cref="DocumentMutationLostException">Thrown if the observed document was lost during
/// a hard failover because the document did not reach the replica in time.</exception>
/// <exception cref="ReplicaNotConfiguredException">Thrown if the number of replicas requested
/// in the ReplicateTo parameter does not match the # of replicas configured on the server.</exception>
public bool Observe(MutationToken token, ReplicateTo replicateTo, PersistTo persistTo)
{
var keyMapper = (VBucketKeyMapper)_configInfo.GetKeyMapper();
var p = new ObserveParams
{
ReplicateTo = replicateTo,
PersistTo = persistTo,
Token = token,
VBucket = keyMapper[token.VBucketId]
};
p.CheckConfiguredReplicas();
var op = new ObserveSeqno(p.Token, _transcoder, _timeout);
do
{
var master = p.VBucket.LocatePrimary();
var result = master.Send(op);
var osr = result.Value;
p.CheckMutationLost(osr);
p.CheckPersisted(osr);
if (p.IsDurabilityMet())
{
return(true);
}
if (CheckReplicas(p, op))
{
return(true);
}
//prepare for another attempt
op = (ObserveSeqno)op.Clone();
p.Reset();
} while (!op.TimedOut());
return(false);
}
private async Task <bool> CheckReplicaAsync(ObserveParams observeParams, int replicaId)
{
var op = new ObserveSeqno(observeParams.Token, _clusterController.Transcoder, _timeout);
observeParams.Operation = op;
var tcs = new TaskCompletionSource <IOperationResult <ObserveSeqnoResponse> >();
op.Completed = CallbackFactory.CompletedFuncForRetry(_pending, _clusterController, tcs);
_pending.TryAdd(op.Opaque, op);
Log.Debug("checking replica {0} - opaque: {1}", replicaId, op.Opaque);
var replica = observeParams.VBucket.LocateReplica(replicaId);
await replica.SendAsync(op).ContinueOnAnyContext();
var response = await tcs.Task.ContinueOnAnyContext();
observeParams.CheckMutationLost(response);
observeParams.CheckPersisted(response);
observeParams.CheckReplicated(response);
return(observeParams.IsDurabilityMet());
}
static Task<bool> CheckReplicaAsync(ObserveParams observeParams, ObserveSeqno op, int replicaId)
{
var cloned = (ObserveSeqno)op.Clone();
var replica = observeParams.VBucket.LocateReplica(replicaId);
var result = replica.Send(cloned);
observeParams.CheckMutationLost(result.Value);
observeParams.CheckPersisted(result.Value);
observeParams.CheckReplicated(result.Value);
return Task.FromResult(observeParams.IsDurabilityMet());
}
/// <summary>
/// Observes the specified key using the Seqno.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="token">The token.</param>
/// <param name="replicateTo">The replicate to.</param>
/// <param name="persistTo">The persist to.</param>
/// <returns>True if durability constraints were matched.</returns>
/// <exception cref="DocumentMutationLostException">Thrown if the observed document was lost during
/// a hard failover because the document did not reach the replica in time.</exception>
/// <exception cref="ReplicaNotConfiguredException">Thrown if the number of replicas requested
/// in the ReplicateTo parameter does not match the # of replicas configured on the server.</exception>
public bool Observe(MutationToken token, ReplicateTo replicateTo, PersistTo persistTo)
{
var keyMapper = (VBucketKeyMapper)_configInfo.GetKeyMapper();
var p = new ObserveParams
{
ReplicateTo = replicateTo,
PersistTo = persistTo,
Token = token,
VBucket = keyMapper[token.VBucketId]
};
p.CheckConfiguredReplicas();
var op = new ObserveSeqno(p.Token, _transcoder, _timeout);
do
{
var master = p.VBucket.LocatePrimary();
var result = master.Send(op);
var osr = result.Value;
p.CheckMutationLost(osr);
p.CheckPersisted(osr);
if (p.IsDurabilityMet())
{
return true;
}
if (CheckReplicas(p, op))
{
return true;
}
//prepare for another attempt
op = (ObserveSeqno)op.Clone();
p.Reset();
} while (!op.TimedOut());
return false;
}
private async Task<bool> CheckReplicaAsync(ObserveParams observeParams, int replicaId)
{
var op = new ObserveSeqno(observeParams.Token, _clusterController.Transcoder, _timeout);
observeParams.Operation = op;
var tcs = new TaskCompletionSource<IOperationResult<ObserveSeqnoResponse>>();
op.Completed = CallbackFactory.CompletedFuncForRetry(_pending, _clusterController, tcs);
_pending.TryAdd(op.Opaque, op);
Log.Debug(m => m("checking replica {0} - opaque: {1}", replicaId, op.Opaque));
var replica = observeParams.VBucket.LocateReplica(replicaId);
await replica.SendAsync(op).ContinueOnAnyContext();
var response = await tcs.Task.ContinueOnAnyContext();
observeParams.CheckMutationLost(response);
observeParams.CheckPersisted(response);
observeParams.CheckReplicated(response);
return observeParams.IsDurabilityMet();
}
/// <summary>
/// Checks a replica for durability constraints.
/// </summary>
/// <param name="observeParams">The observe parameters.</param>
/// <param name="op">The op.</param>
/// <param name="replicaId">The replica identifier.</param>
/// <returns></returns>
private bool CheckReplica(ObserveParams observeParams, ObserveSeqno op, int replicaId)
{
var cloned = (ObserveSeqno)op.Clone();
var replica = observeParams.VBucket.LocateReplica(replicaId);
var result = replica.Send(cloned);
observeParams.CheckMutationLost(result);
observeParams.CheckPersisted(result);
observeParams.CheckReplicated(result);
return observeParams.IsDurabilityMet();
}
private async Task<bool> CheckPersistToAsync(ObserveParams observeParams)
{
if (observeParams.PersistTo == PersistTo.Zero) return true;
var op = new ObserveSeqno(observeParams.Token, _clusterController.Transcoder, _timeout);
observeParams.Operation = op;
var tcs = new TaskCompletionSource<IOperationResult<ObserveSeqnoResponse>>();
op.Completed = CallbackFactory.CompletedFuncForRetry(_pending, _clusterController, tcs);
_pending.TryAdd(op.Opaque, op);
var server = await GetServerAsync(observeParams);
await server.SendAsync(op).ContinueOnAnyContext();
var response = await tcs.Task.ContinueOnAnyContext();
observeParams.CheckMutationLost(response);
observeParams.CheckPersisted(response);
return observeParams.IsDurabilityMet();
}
