/// <summary>
/// Sends an operation to the server while observing it's durability requirements using async/await
/// </summary>
/// <typeparam name="T">The value for T.</typeparam>
/// <param name="operation">A binary memcached operation - must be a mutation operation.</param>
/// <param name="deletion">True if mutation is a deletion.</param>
/// <param name="replicateTo">The durability requirement for replication.</param>
/// <param name="persistTo">The durability requirement for persistence.</param>
/// <returns>The <see cref="Task{IOperationResult}"/> to be awaited on with it's <see cref="Durability"/> status.</returns>
public override async Task <IOperationResult <T> > SendWithDurabilityAsync <T>(IOperation <T> operation, bool deletion, ReplicateTo replicateTo, PersistTo persistTo)
{
//Is the cluster configured for Data services?
if (!ConfigInfo.IsDataCapable)
{
throw new ServiceNotSupportedException("The cluster does not support Data services.");
}
var result = await SendWithRetryAsync(operation);
if (result.Success)
{
var config = ConfigInfo.ClientConfig.BucketConfigs[BucketName];
var observer = new KeyObserver(ConfigInfo,
ClusterController.Transcoder,
config.ObserveInterval, config.ObserveTimeout);
var observed = await observer.ObserveAsync(operation.Key, result.Cas, deletion, replicateTo, persistTo);
result.Durability = observed
? Durability.Satisfied
: Durability.NotSatisfied;
}
else
{
result.Durability = Durability.NotSatisfied;
}
return(result);
}
public void When_Observing_Key_During_Remove_Durability_Constraint_Is_Reached()
{
var configuration = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
}
};
configuration.Initialize();
var provider = new CarrierPublicationProvider(
configuration,
(pool) => new PooledIOService(pool),
(config, endpoint) => new ConnectionPool<Connection>(config, endpoint),
SaslFactory.GetFactory(),
new DefaultConverter(),
#pragma warning disable 618
new DefaultTranscoder(new DefaultConverter(), new DefaultSerializer()));
#pragma warning restore 618
var configInfo = provider.GetConfig("default");
var clusterController = new Mock<IClusterController>();
clusterController.Setup(x => x.Transcoder).Returns(new DefaultTranscoder());
var pending = new ConcurrentDictionary<uint, IOperation>();
var observer = new KeyObserver(pending, configInfo, clusterController.Object, 10, 500);
var constraintReached = observer.ObserveRemove("Test_Timeout_Remove", 0, ReplicateTo.Zero, PersistTo.One);
Assert.IsTrue(constraintReached);
}
public void When_Observing_Key_During_Remove_Durability_Constraint_Is_Reached()
{
var configuration = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
}
};
configuration.Initialize();
var provider = new CarrierPublicationProvider(
configuration,
(pool) => new DefaultIOStrategy(pool),
(config, endpoint) => new ConnectionPool<EapConnection>(config, endpoint),
SaslFactory.GetFactory3(),
new AutoByteConverter(),
new TypeSerializer(new AutoByteConverter()));
var configInfo = provider.GetConfig("default");
var observer = new KeyObserver(configInfo, 10, 500);
var constraintReached = observer.ObserveRemove("Test_Timeout_Remove", 0, ReplicateTo.Zero, PersistTo.One);
Assert.IsTrue(constraintReached);
}
public void When_Observing_Key_During_Add_Durability_Constraint_Is_Reached()
{
var configuration = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
}
};
configuration.Initialize();
var provider = new CarrierPublicationProvider(
configuration,
(pool) => new DefaultIOStrategy(pool),
(config, endpoint) => new ConnectionPool<EapConnection>(config, endpoint),
SaslFactory.GetFactory3(),
new AutoByteConverter(),
new TypeSerializer(new AutoByteConverter()));
var configInfo = provider.GetConfig("default");
ulong cas = 0;
using (var cluster = new CouchbaseCluster(configuration))
{
using (var bucket = cluster.OpenBucket())
{
bucket.Remove("Test_Timeout_Add");
bucket.Insert("Test_Timeout_Add", "");
cas = bucket.Upsert("Test_Timeout_Add", "").Cas;
}
}
var observer = new KeyObserver(configInfo, 10, 500);
var constraintReached = observer.ObserveAdd("Test_Timeout_Add", cas, ReplicateTo.One, PersistTo.One);
Assert.IsTrue(constraintReached);
}
/// <summary>
/// Sends an operation to the server while observing it's durability requirements
/// </summary>
/// <typeparam name="T">The value for T.</typeparam>
/// <param name="operation">A binary memcached operation - must be a mutation operation.</param>
/// <param name="deletion">True if mutation is a deletion.</param>
/// <param name="replicateTo">The durability requirement for replication.</param>
/// <param name="persistTo">The durability requirement for persistence.</param>
/// <returns>The <see cref="IOperationResult{T}"/> with it's <see cref="Durability"/> status.</returns>
public override IOperationResult <T> SendWithDurability <T>(IOperation <T> operation, bool deletion, ReplicateTo replicateTo, PersistTo persistTo)
{
var result = SendWithRetry(operation);
if (result.Success)
{
var config = ConfigInfo.ClientConfig.BucketConfigs[BucketName];
var observer = new KeyObserver(ConfigInfo,
ClusterController.Transcoder,
config.ObserveInterval, config.ObserveTimeout);
var observed = observer.Observe(operation.Key, result.Cas, deletion, replicateTo, persistTo);
result.Durability = observed
? Durability.Satisfied
: Durability.NotSatisfied;
}
else
{
result.Durability = Durability.NotSatisfied;
}
return(result);
}
public async void When_Observing_Key_During_AddAsync_Durability_Constraint_Is_Reached()
{
var configuration = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
}
};
configuration.Initialize();
var provider = new CarrierPublicationProvider(
configuration,
(pool) => new PooledIOService(pool),
(config, endpoint) => new ConnectionPool<Connection>(config, endpoint),
SaslFactory.GetFactory(),
new DefaultConverter(),
new DefaultTranscoder(new DefaultConverter()));
var configInfo = provider.GetConfig("default");
var key = "Test_Timeout_Add_Async";
ulong cas = 0;
using (var cluster = new Cluster(configuration))
{
using (var bucket = cluster.OpenBucket())
{
bucket.Remove(key);
bucket.Insert(key, "");
cas = bucket.Upsert(key, "").Cas;
}
}
var observer = new KeyObserver(configInfo, 10, 500);
var constraintReached = await observer.ObserveAddAsync(key, cas, ReplicateTo.Zero, PersistTo.Zero);
Assert.IsTrue(constraintReached);
}
public void When_No_Replicas_Are_Found_GetReplicas_Returns_Empty_List()
{
var vBucket = new VBucket(null, 0, 0, new[] { -1, -1, -1 });
var expected = new int[] {};
var observer = new KeyObserver(null, 10, 500);
var actual = observer.GetReplicas(vBucket, ReplicateTo.One, PersistTo.Two);
Assert.AreEqual(expected, actual);
Assert.AreEqual(expected.Count(), actual.Count());
}
public async Task Test_Timeout_Add_PersistTo_Master_Async()
{
var configuration = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
}
};
configuration.Initialize();
var provider = new CarrierPublicationProvider(
configuration,
(pool) => new PooledIOService(pool),
(config, endpoint) => new ConnectionPool<Connection>(config, endpoint),
SaslFactory.GetFactory(),
new DefaultConverter(),
new DefaultTranscoder(new DefaultConverter()));
var configInfo = provider.GetConfig("default");
var key = "Test_Timeout_Add_PersistTo_Master_Async";
IOperationResult result;
using (var cluster = new Cluster(configuration))
{
using (var bucket = cluster.OpenBucket())
{
bucket.Remove(key);
result = bucket.Insert(key, "");
}
}
var clusterController = new Mock<IClusterController>();
clusterController.Setup(x => x.Transcoder).Returns(new DefaultTranscoder());
var pending = new ConcurrentDictionary<uint, IOperation>();
var observer = new KeyObserver(pending, configInfo, clusterController.Object, 10, 500);
using (var cts = new CancellationTokenSource(configuration.ObserveTimeout))
{
var constraintReached =
await observer.ObserveAddAsync(key, result.Cas, ReplicateTo.Zero, PersistTo.Zero, cts);
Assert.IsTrue(constraintReached);
}
}
public void When_PersistTo_Is_Greater_Than_ReplicateTo_Length_Of_Replicas_Is_PersistTo()
{
var vBucket = new VBucket(null, 0, 0, new[] { 0, 2, 1 }, 0, new VBucketServerMap { ServerList = new string[] { } }, "default");
var expected = new[] { 0, 2 };
var clusterController = new Mock<IClusterController>();
clusterController.Setup(x => x.Transcoder).Returns(new DefaultTranscoder());
var pending = new ConcurrentDictionary<uint, IOperation>();
var observer = new KeyObserver(pending, null, clusterController.Object, 10, 500);
var actual = observer.GetReplicas(vBucket, ReplicateTo.One, PersistTo.Two);
Assert.AreEqual(expected, actual);
Assert.AreEqual(actual.Count, (int)PersistTo.Two);
}
public void When_PersistTo_Is_Greater_Than_ReplicateTo_Length_Of_Replicas_Is_PersistTo()
{
var vBucket = new VBucket(null, 0, 0, new[] { 0, 2, 1 });
var expected = new[] { 0, 2 };
var observer = new KeyObserver(null, 10, 500);
var actual = observer.GetReplicas(vBucket, ReplicateTo.One, PersistTo.Two);
Assert.AreEqual(expected, actual);
Assert.AreEqual(actual.Count, (int)PersistTo.Two);
}
/// <summary>
/// Sends an operation to the server while observing its durability requirements using async/await
/// </summary>
/// <param name="operation">A binary memcached operation - must be a mutation operation.</param>
/// <param name="deletion">True if mutation is a deletion.</param>
/// <param name="replicateTo">The durability requirement for replication.</param>
/// <param name="persistTo">The durability requirement for persistence.</param>
/// <returns>The <see cref="Task{IOperationResult}"/> to be awaited on with its <see cref="Durability"/> status.</returns>
/// <exception cref="ServiceNotSupportedException">The cluster does not support Data services.</exception>
public override async Task <IOperationResult> SendWithDurabilityAsync(IOperation operation, bool deletion, ReplicateTo replicateTo, PersistTo persistTo)
{
IOperationResult result;
try
{
//Is the cluster configured for Data services?
if (!ConfigInfo.IsDataCapable)
{
throw new ServiceNotSupportedException(
ExceptionUtil.GetMessage(ExceptionUtil.ServiceNotSupportedMsg, "Data"));
}
result = await SendWithRetryAsync(operation).ContinueOnAnyContext();
if (result.Success)
{
var config = ConfigInfo.ClientConfig.BucketConfigs[BucketName];
using (var cts = new CancellationTokenSource(config.ObserveTimeout))
{
if (ConfigInfo.SupportsEnhancedDurability)
{
var seqnoObserver = new KeySeqnoObserver(operation.Key, Pending, ConfigInfo,
ClusterController,
config.ObserveInterval, (uint)config.ObserveTimeout);
var observed = await seqnoObserver.ObserveAsync(result.Token, replicateTo, persistTo, cts)
.ContinueOnAnyContext();
result.Durability = observed ? Durability.Satisfied : Durability.NotSatisfied;
((OperationResult)result).Success = result.Durability == Durability.Satisfied;
}
else
{
var observer = new KeyObserver(Pending, ConfigInfo, ClusterController,
config.ObserveInterval, config.ObserveTimeout);
var observed = await observer.ObserveAsync(operation.Key, result.Cas,
deletion, replicateTo, persistTo, cts).ContinueOnAnyContext();
result.Durability = observed ? Durability.Satisfied : Durability.NotSatisfied;
((OperationResult)result).Success = result.Durability == Durability.Satisfied;
}
}
}
else
{
result.Durability = Durability.NotSatisfied;
((OperationResult)result).Success = result.Durability == Durability.Satisfied;
}
}
catch (TaskCanceledException e)
{
result = new OperationResult
{
Id = operation.Key,
Exception = e,
Status = ResponseStatus.OperationTimeout,
Durability = Durability.NotSatisfied,
Success = false
};
}
catch (ReplicaNotConfiguredException e)
{
result = new OperationResult
{
Id = operation.Key,
Exception = e,
Status = ResponseStatus.NoReplicasFound,
Durability = Durability.NotSatisfied,
Success = false
};
}
catch (DocumentMutationLostException e)
{
result = new OperationResult
{
Id = operation.Key,
Exception = e,
Status = ResponseStatus.DocumentMutationLost,
Durability = Durability.NotSatisfied,
Success = false
};
}
catch (DocumentMutationException e)
{
result = new OperationResult
{
Id = operation.Key,
Exception = e,
Status = ResponseStatus.DocumentMutationDetected,
Durability = Durability.NotSatisfied,
Success = false
};
}
catch (Exception e)
{
result = new OperationResult
{
Id = operation.Key,
Exception = e,
Status = ResponseStatus.ClientFailure,
Success = false
};
}
return(result);
}
/// <summary>
/// Sends an operation to the server while observing it's durability requirements using async/await
/// </summary>
/// <typeparam name="T">The value for T.</typeparam>
/// <param name="operation">A binary memcached operation - must be a mutation operation.</param>
/// <param name="deletion">True if mutation is a deletion.</param>
/// <param name="replicateTo">The durability requirement for replication.</param>
/// <param name="persistTo">The durability requirement for persistence.</param>
/// <returns>The <see cref="Task{IOperationResult}"/> to be awaited on with it's <see cref="Durability"/> status.</returns>
/// <exception cref="ServiceNotSupportedException">The cluster does not support Data services.</exception>
public override async Task <IOperationResult <T> > SendWithDurabilityAsync <T>(IOperation <T> operation, bool deletion, ReplicateTo replicateTo, PersistTo persistTo)
{
//Is the cluster configured for Data services?
if (!ConfigInfo.IsDataCapable)
{
throw new ServiceNotSupportedException("The cluster does not support Data services.");
}
IOperationResult <T> result;
try
{
result = await SendWithRetryAsync(operation);
if (result.Success)
{
var config = ConfigInfo.ClientConfig.BucketConfigs[BucketName];
if (ConfigInfo.SupportsEnhancedDurability)
{
var seqnoObserver = new KeySeqnoObserver(ConfigInfo, ClusterController.Transcoder,
config.ObserveInterval, (uint)config.ObserveTimeout);
var observed = await seqnoObserver.ObserveAsync(result.Token, replicateTo, persistTo);
result.Durability = observed ? Durability.Satisfied : Durability.NotSatisfied;
}
else
{
var observer = new KeyObserver(ConfigInfo, ClusterController.Transcoder,
config.ObserveInterval, config.ObserveTimeout);
var observed =
await observer.ObserveAsync(operation.Key, result.Cas, deletion, replicateTo, persistTo);
result.Durability = observed ? Durability.Satisfied : Durability.NotSatisfied;
}
}
else
{
result.Durability = Durability.NotSatisfied;
}
}
catch (ReplicaNotConfiguredException e)
{
result = new OperationResult <T>
{
Exception = e,
Status = ResponseStatus.NoReplicasFound,
Durability = Durability.NotSatisfied
};
}
catch (DocumentMutationLostException e)
{
result = new OperationResult <T>
{
Exception = e,
Status = ResponseStatus.DocumentMutationLost,
Durability = Durability.NotSatisfied
};
}
catch (Exception e)
{
result = new OperationResult <T>
{
Exception = e,
Status = ResponseStatus.ClientFailure
};
}
return(result);
}
/// <summary>
/// Sends an operation to the server while observing it's durability requirements
/// </summary>
/// <param name="operation">A binary memcached operation - must be a mutation operation.</param>
/// <param name="deletion">True if mutation is a deletion.</param>
/// <param name="replicateTo">The durability requirement for replication.</param>
/// <param name="persistTo">The durability requirement for persistence.</param>
/// <returns>The <see cref="IOperationResult"/> with it's <see cref="Durability"/> status.</returns>
/// <exception cref="ServiceNotSupportedException">The cluster does not support Data services.</exception>
public override IOperationResult SendWithDurability(IOperation operation, bool deletion, ReplicateTo replicateTo, PersistTo persistTo)
{
IOperationResult result;
try
{
//Is the cluster configured for Data services?
if (!ConfigInfo.IsDataCapable)
{
throw new ServiceNotSupportedException(
ExceptionUtil.GetMessage(ExceptionUtil.ServiceNotSupportedMsg, "Data"));
}
result = SendWithRetry(operation);
if (result.Success)
{
var config = ConfigInfo.ClientConfig.BucketConfigs[BucketName];
if (ConfigInfo.SupportsEnhancedDurability)
{
var seqnoObserver = new KeySeqnoObserver(operation.Key, Pending, ConfigInfo, ClusterController,
config.ObserveInterval, (uint)config.ObserveTimeout);
var observed = seqnoObserver.Observe(result.Token, replicateTo, persistTo);
result.Durability = observed ? Durability.Satisfied : Durability.NotSatisfied;
}
else
{
var observer = new KeyObserver(Pending, ConfigInfo, ClusterController, config.ObserveInterval, config.ObserveTimeout);
var observed = observer.Observe(operation.Key, result.Cas, deletion, replicateTo, persistTo);
result.Durability = observed ? Durability.Satisfied : Durability.NotSatisfied;
}
}
else
{
result.Durability = Durability.NotSatisfied;
}
}
catch (ReplicaNotConfiguredException e)
{
result = new OperationResult
{
Id = operation.Key,
Exception = e,
Status = ResponseStatus.NoReplicasFound,
Durability = Durability.NotSatisfied,
OpCode = operation.OperationCode
};
}
catch (DocumentMutationLostException e)
{
result = new OperationResult
{
Id = operation.Key,
Exception = e,
Status = ResponseStatus.DocumentMutationLost,
Durability = Durability.NotSatisfied,
OpCode = operation.OperationCode
};
}
catch (Exception e)
{
result = new OperationResult
{
Id = operation.Key,
Exception = e,
Status = ResponseStatus.ClientFailure,
OpCode = operation.OperationCode
};
}
return(result);
}
public void When_No_Replicas_Are_Found_GetReplicas_Returns_Empty_List()
{
var vBucket = new VBucket(null, 0, 0, new[] { -1, -1, -1 }, 0, new VBucketServerMap { ServerList = new string[] { } }, "default");
var expected = new int[] {};
var clusterController = new Mock<IClusterController>();
clusterController.Setup(x => x.Transcoder).Returns(new DefaultTranscoder());
var pending = new ConcurrentDictionary<uint, IOperation>();
var observer = new KeyObserver(pending, null, clusterController.Object, 10, 500);
var actual = observer.GetReplicas(vBucket, ReplicateTo.One, PersistTo.Two);
Assert.AreEqual(expected, actual);
Assert.AreEqual(expected.Count(), actual.Count());
}
public async void Test_Timeout_Add_PersistTo_Master_Async()
{
var configuration = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
}
};
configuration.Initialize();
var provider = new CarrierPublicationProvider(
configuration,
(pool) => new DefaultIOStrategy(pool),
(config, endpoint) => new ConnectionPool<Connection>(config, endpoint),
SaslFactory.GetFactory3(),
new DefaultConverter(),
new DefaultTranscoder(new DefaultConverter()));
var configInfo = provider.GetConfig("default");
var key = "Test_Timeout_Add_PersistTo_Master_Async";
IOperationResult result;
using (var cluster = new Cluster(configuration))
{
using (var bucket = cluster.OpenBucket())
{
bucket.Remove(key);
result = bucket.Insert(key, "");
}
}
var observer = new KeyObserver(configInfo, 10, 500);
var constraintReached = await observer.ObserveAddAsync(key, result.Cas, ReplicateTo.Zero, PersistTo.Zero);
Assert.IsTrue(constraintReached);
}
public async void When_Mutation_Happens_Observe_Fails_Async()
{
var configuration = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
}
};
configuration.Initialize();
var provider = new CarrierPublicationProvider(
configuration,
(pool) => new DefaultIOStrategy(pool),
(config, endpoint) => new ConnectionPool<Connection>(config, endpoint),
SaslFactory.GetFactory3(),
new DefaultConverter(),
new DefaultTranscoder(new DefaultConverter()));
var configInfo = provider.GetConfig("default");
var key = "When_Mutation_Happens_Observe_Fails_async";
ulong cas = 0;
using (var cluster = new Cluster(configuration))
{
using (var bucket = cluster.OpenBucket())
{
bucket.Remove(key);
cas = bucket.Insert(key, "").Cas;
bucket.Upsert(key, "");
}
}
var observer = new KeyObserver(configInfo, 10, 500);
var constraintReached = await observer.ObserveAddAsync(key, cas, ReplicateTo.One, PersistTo.One);
Assert.IsFalse(constraintReached);
}
public void When_Observing_Key_During_Add_Durability_Constraint_Is_Reached()
{
var configuration = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
}
};
configuration.Initialize();
var provider = new CarrierPublicationProvider(
configuration,
(pool) => new PooledIOService(pool),
(config, endpoint) => new ConnectionPool<Connection>(config, endpoint),
SaslFactory.GetFactory(),
new DefaultConverter(),
new DefaultTranscoder(new DefaultConverter()));
var configInfo = provider.GetConfig("default");
ulong cas = 0;
using (var cluster = new Cluster(configuration))
{
using (var bucket = cluster.OpenBucket())
{
bucket.Remove("Test_Timeout_Add");
bucket.Insert("Test_Timeout_Add", "");
cas = bucket.Upsert("Test_Timeout_Add", "").Cas;
}
}
var clusterController = new Mock<IClusterController>();
clusterController.Setup(x => x.Transcoder).Returns(new DefaultTranscoder());
var pending = new ConcurrentDictionary<uint, IOperation>();
var observer = new KeyObserver(pending, configInfo, clusterController.Object, 10, 500);
var constraintReached = observer.ObserveAdd("Test_Timeout_Add", cas, ReplicateTo.Zero, PersistTo.Zero);
Assert.IsTrue(constraintReached);
}
