Beispiel #1
0
        public async Task <IGetResult> GetAndLock(string id, TimeSpan expiration, GetAndLockOptions options)
        {
            var getAndLockOp = new GetL <byte[]>
            {
                Key        = id,
                Cid        = Cid,
                Expiration = expiration.ToTtl()
            };

            await ExecuteOp(getAndLockOp, options.Token, options.Timeout);

            return(new GetResult(getAndLockOp.Data.ToArray(), _transcoder));
        }
        public override IOperation Clone()
        {
            var cloned = new GetL <T>
            {
                Key                     = Key,
                Content                 = Content,
                Transcoder              = Transcoder,
                VBucketId               = VBucketId,
                Opaque                  = Opaque,
                Attempts                = Attempts,
                Cas                     = Cas,
                CreationTime            = CreationTime,
                LastConfigRevisionTried = LastConfigRevisionTried,
                BucketName              = BucketName,
                ErrorCode               = ErrorCode
            };

            return(cloned);
        }
Beispiel #3
0
        public async Task <IGetResult> GetAndLockAsync(string id, TimeSpan lockTime, GetAndLockOptions?options = null)
        {
            //sanity check for deferred bootstrapping errors
            _bucket.ThrowIfBootStrapFailed();

            //Check to see if the CID is needed
            if (RequiresCid())
            {
                //Get the collection ID
                await PopulateCidAsync().ConfigureAwait(false);
            }

            options ??= GetAndLockOptions.Default;
            using var rootSpan     = RootSpan(OuterRequestSpans.ServiceSpan.Kv.GetAndLock, options.RequestSpanValue);
            using var getAndLockOp = new GetL <byte[]>
                  {
                      Key    = id,
                      Cid    = Cid,
                      CName  = Name,
                      SName  = ScopeName,
                      Expiry = lockTime.ToTtl(),
                      Span   = rootSpan
                  };
            _operationConfigurator.Configure(getAndLockOp, options);

            using var ctp = CreateRetryTimeoutCancellationTokenSource(options, getAndLockOp);
            await _bucket.RetryAsync(getAndLockOp, ctp.TokenPair).ConfigureAwait(false);

            return(new GetResult(getAndLockOp.ExtractBody(), getAndLockOp.Transcoder, _getLogger)
            {
                Id = getAndLockOp.Key,
                Cas = getAndLockOp.Cas,
                Flags = getAndLockOp.Flags,
                Header = getAndLockOp.Header,
                OpCode = getAndLockOp.OpCode
            });
        }
        public async Task <IGetResult> GetAndLockAsync(string id, TimeSpan expiry, GetAndLockOptions options)
        {
            var transcoder = options.Transcoder ?? _transcoder;

            using (var getAndLockOp = new GetL <byte[]>
            {
                Key = id,
                Cid = Cid,
                Expiry = expiry.ToTtl(),
                Transcoder = transcoder
            })
            {
                await _bucket.SendAsync(getAndLockOp, options.Token, options.Timeout);

                return(new GetResult(getAndLockOp.ExtractData(), transcoder)
                {
                    Id = getAndLockOp.Key,
                    Cas = getAndLockOp.Cas,
                    Flags = getAndLockOp.Flags,
                    Header = getAndLockOp.Header,
                    OpCode = getAndLockOp.OpCode
                });
            }
        }
        public void When_ErrorCode_Is_Null_CanRetry_Returns_True()
        {
            var get = new GetL <dynamic>("thekey", null, new DefaultTranscoder(), 0);

            Assert.True(get.CanRetry());
        }