コード例 #1
0
        public void Test_KeySeqnoObserver()
        {

            var configuration = new ClientConfiguration
            {
                Servers = new List<Uri>
                {
                    new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
                }
            };

            var key = "Test_KeySeqnoObserver";
            using (var cluster = new Cluster(configuration))
            {
                using (var bucket = cluster.OpenBucket())
                {
                    bucket.Remove(key);
                }
            }

            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(), new DefaultSerializer()));

            var configInfo = provider.GetConfig("default");

            var features = new List<short>();
            features.Add((short)ServerFeatures.MutationSeqno);

            var keyMapper = configInfo.GetKeyMapper();
            var mappedNode = keyMapper.MapKey(key);
            var node = mappedNode.LocatePrimary();

            foreach (var server in configInfo.Servers.Where(x=>x.IsDataNode))
            {
                var hello = new Hello("couchbase-net-sdk/2.1.4", features.ToArray(), provider.Transcoder, 0, 0);
                var result3 = server.Send(hello);
                Assert.IsTrue(result3.Success);
            }

            var result = node.Send(new Add<string>(key, "", (VBucket)mappedNode,
                new DefaultTranscoder(new DefaultConverter(), new DefaultSerializer()), 1000));

            var clusterController = new Mock<IClusterController>();
            clusterController.Setup(x => x.Transcoder).Returns(new DefaultTranscoder());

            var pending = new ConcurrentDictionary<uint, IOperation>();

            var keyObserver = new KeySeqnoObserver("thekey", pending, configInfo, clusterController.Object, 0, 1000);
            var durabilityReached = keyObserver.Observe(result.Token, ReplicateTo.Zero, PersistTo.One);
            Assert.IsTrue(durabilityReached);
        }
コード例 #2
0
        /// <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);
        }
コード例 #3
0
        /// <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);
        }
コード例 #4
0
        /// <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);
        }