NCBC-3985: Add ReviveDocument to MutateInOptions

Motivation
==========
Added in 7.1, this is a server feature.   It is important for the
extReplaceBodyWithXattr extension to transactions, which is a
efficiency improvement.   So lets do it.

Modification
============
We added it as a bucket capability, and added it as another option
in the MutateInOption class.  Then, in MutateInAsync, we check for
it in the BucketCapabilities when using it.   Also - this expects
the AccessDeleted flag, so we add it when we add this one.  Also
a new exception if you try to revive a document when it is not
a tombstone.

Results
=======
Added tests, they pass.
in MutateInAsync.

Change-Id: I2e1158936aafd6f01396eec0fc56782f61a924e5
Reviewed-on: https://review.couchbase.org/c/couchbase-net-client/+/225219
Reviewed-by: Jeffry Morris <jeffrymorris@gmail.com>
Tested-by: Build Bot <build@couchbase.com>

Author: davidkelly

src/Couchbase/Core/Configuration/Server/BucketCapabilities.cs

@@ -18,6 +18,7 @@ public static class BucketCapabilities
         public const string SUBDOC_REPLICA_READ = "subdoc.ReplicaRead";
         public const string NON_DEDUPED_HISTORY = "nonDedupedHistory";
         public const string SUBDOC_REPLACE_BODY_WITH_XATTR = "subdoc.ReplaceBodyWithXattr";
+        public const string SUBDOC_REVIVE_DOCUMENT = "subdoc.ReviveDocument";
     }
 }
 

src/Couchbase/Core/Exceptions/KeyValue/DocumentAlreadyAliveException.cs

@@ -0,0 +1,47 @@
+using System;
+
+namespace Couchbase.Core.Exceptions.KeyValue
+{
+    public class DocumentAlreadyAliveException : KeyValueException
+    {
+        public DocumentAlreadyAliveException()
+        {
+        }
+
+        public DocumentAlreadyAliveException(IErrorContext context) : base(context)
+        {
+        }
+
+        public DocumentAlreadyAliveException(IKeyValueErrorContext context) : base(context)
+        {
+        }
+
+        public DocumentAlreadyAliveException(string message) : base(message)
+        {
+        }
+
+        public DocumentAlreadyAliveException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+    }
+}
+
+
+/* ************************************************************
+ *
+ *    @author Couchbase <info@couchbase.com>
+ *    @copyright 2021 Couchbase, Inc.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ * ************************************************************/

src/Couchbase/Core/IO/Operations/ResponseStatus.cs

@@ -302,6 +302,11 @@ client level failures. They are not supported by all SDKs. */
         /// </summary>
         SubdocInvalidXattrOrder = 0xd4,
 
+        /// <summary>
+        /// Attempted to ReviveDocument on a document which was not currently a tombstone.
+        /// </summary>
+        SubdocCanOnlyReviveDeletedDocuments = 0xd6,
+
         /// <summary>
         /// Collection does not exist/Collection Outdated
         /// </summary>

src/Couchbase/Core/IO/ResponseStatusExtensions.cs

@@ -182,6 +182,8 @@ public static Exception CreateException(this ResponseStatus status,  KeyValueErr
                     return new DocumentTooDeepException { Context = ctx };
                 case ResponseStatus.SubDocInvalidCombo:
                     return new InvalidArgumentException { Context = ctx };
+                case ResponseStatus.SubdocCanOnlyReviveDeletedDocuments:
+                    return new DocumentAlreadyAliveException { Context = ctx };
                 case ResponseStatus.DocumentMutationDetected: //maps to nothing
                 case ResponseStatus.NoReplicasFound: //maps to nothing
                 case ResponseStatus.InvalidRange: //maps to nothing

src/Couchbase/KeyValue/CouchbaseCollection.cs

@@ -917,6 +917,13 @@ public async Task<IMutateInResult> MutateInAsync(string id, IEnumerable<MutateIn
 
                 docFlags |= SubdocDocFlags.CreateAsDeleted;
             }
+            if (options.ReviveDocumentValue)
+            {
+                // We insist on AccessDeleted being set whenever we set ReviveDocument.
+                if (!_bucket.CurrentConfig?.BucketCapabilities.Contains(BucketCapabilities.SUBDOC_REVIVE_DOCUMENT) == true)
+                    throw new FeatureNotAvailableException(nameof(BucketCapabilities.SUBDOC_REVIVE_DOCUMENT));
+                docFlags |= SubdocDocFlags.ReviveDocument | SubdocDocFlags.AccessDeleted;
+            }
 
             if (options.AccessDeletedValue) docFlags |= SubdocDocFlags.AccessDeleted;
 

src/Couchbase/KeyValue/Options.cs

@@ -2629,6 +2629,8 @@ public class MutateInOptions : ITranscoderOverrideOptions, IKeyValueOptions, ITi
 
         internal bool CreateAsDeletedValue { get; private set; }
 
+        internal bool ReviveDocumentValue { get; private set; }
+
         internal bool AccessDeletedValue { get; private set; }
 
         internal IRetryStrategy? RetryStrategyValue { get; private set; }
@@ -2791,6 +2793,13 @@ public MutateInOptions CancellationToken(CancellationToken token)
             return this;
         }
 
+        public MutateInOptions ReviveDocument(bool reviveDocument)
+        {
+            Debug.Assert(!ReferenceEquals(this, Default), "Default should be immutable");
+            ReviveDocumentValue = reviveDocument;
+            return this;
+        }
+
         public MutateInOptions CreateAsDeleted(bool createAsDeleted)
         {
             Debug.Assert(!ReferenceEquals(this, Default), "Default should be immutable");
@@ -2809,7 +2818,7 @@ public MutateInOptions AccessDeleted(bool accessDeleted)
             return this;
         }
 
-        public void Deconstruct(out TimeSpan expiry, out StoreSemantics storeSemantics, out ulong cas, out (PersistTo, ReplicateTo) durability, out DurabilityLevel durabilityLevel, out TimeSpan? timeout, out CancellationToken token, out ITypeSerializer? serializer, out bool createAsDeleted, out bool accessDeleted, out IRetryStrategy? retryStrategy, out IRequestSpan? requestSpan, out bool preserveTtl, out ITypeTranscoder? transcoder)
+        public void Deconstruct(out TimeSpan expiry, out StoreSemantics storeSemantics, out ulong cas, out (PersistTo, ReplicateTo) durability, out DurabilityLevel durabilityLevel, out TimeSpan? timeout, out CancellationToken token, out ITypeSerializer? serializer, out bool createAsDeleted, out bool reviveDocument, out bool accessDeleted, out IRetryStrategy? retryStrategy, out IRequestSpan? requestSpan, out bool preserveTtl, out ITypeTranscoder? transcoder)
         {
             expiry = ExpiryValue;
             storeSemantics = StoreSemanticsValue;
@@ -2820,6 +2829,7 @@ public void Deconstruct(out TimeSpan expiry, out StoreSemantics storeSemantics,
             token = TokenValue;
             serializer = TranscoderValue?.Serializer;
             createAsDeleted = CreateAsDeletedValue;
+            reviveDocument = ReviveDocumentValue;
             accessDeleted = AccessDeletedValue;
             retryStrategy = RetryStrategyValue;
             requestSpan = RequestSpanValue;
@@ -2829,8 +2839,8 @@ public void Deconstruct(out TimeSpan expiry, out StoreSemantics storeSemantics,
 
         public ReadOnly AsReadOnly()
         {
-            this.Deconstruct(out TimeSpan expiry, out StoreSemantics storeSemantics, out ulong cas, out (PersistTo, ReplicateTo) durability, out DurabilityLevel durabilityLevel, out TimeSpan? timeout, out CancellationToken token, out ITypeSerializer? serializer, out bool createAsDeleted, out bool accessDeleted, out IRetryStrategy? retryStrategy, out IRequestSpan? requestSpan, out bool preserveTtl, out ITypeTranscoder? transcoder);
-            return new ReadOnly(expiry, storeSemantics, cas, durability, durabilityLevel, timeout, token, serializer, createAsDeleted, accessDeleted, retryStrategy, requestSpan, preserveTtl, transcoder);
+            this.Deconstruct(out TimeSpan expiry, out StoreSemantics storeSemantics, out ulong cas, out (PersistTo, ReplicateTo) durability, out DurabilityLevel durabilityLevel, out TimeSpan? timeout, out CancellationToken token, out ITypeSerializer? serializer, out bool createAsDeleted, out bool reviveDocument, out bool accessDeleted, out IRetryStrategy? retryStrategy, out IRequestSpan? requestSpan, out bool preserveTtl, out ITypeTranscoder? transcoder);
+            return new ReadOnly(expiry, storeSemantics, cas, durability, durabilityLevel, timeout, token, serializer, createAsDeleted, accessDeleted, reviveDocument, retryStrategy, requestSpan, preserveTtl, transcoder);
         }
 
         public record ReadOnly(
@@ -2844,6 +2854,7 @@ public record ReadOnly(
             ITypeSerializer? Serializer,
             bool CreateAsDeleted,
             bool AccessDeleted,
+            bool ReviveDocument,
             IRetryStrategy? RetryStrategy,
             IRequestSpan? RequestSpan,
             bool PreserveTtl,

src/Couchbase/KeyValue/StoreSemantics.cs

@@ -28,7 +28,8 @@ public enum StoreSemantics : byte
         /// Allows access to a deleted document's attributes section.
         /// Only for internal diagnostic use only and is an unsupported feature.
         /// </summary>
-        AccessDeleted = OpCode.Delete
+        AccessDeleted = OpCode.Delete,
+
     }
 }
 

src/Couchbase/KeyValue/SubDocFlags.cs

@@ -36,6 +36,13 @@ public enum SubdocDocFlags : byte
         /// </summary>
         CreateAsDeleted = 0x08,
 
+        /// <summary>
+        /// This will allow the document to no longer be a tombstone.   Note that the server
+        /// will respond with "ReviveDocument cannot be used without AccessDeletec", so we should
+        /// always send AccessDeleted as well.
+        ///</summary>
+        ReviveDocument = 0x10,
+
         /// <summary>
         /// Specifies that the request is being sent to a replica.
         /// </summary>

tests/Couchbase.IntegrationTests/SubdocTests.cs

@@ -569,6 +569,55 @@ public async Task MutateIn_ReplaceBodyWithXattr_Succeeds()
             Assert.Equal(getResult.ContentAs<string>(), JsonConvert.SerializeObject(newDocBody));
         }
 
+        [Fact]
+        public async Task MutateIn_ReviveDocument_Succeeds()
+        {
+            var collection = await _fixture.GetDefaultCollectionAsync().ConfigureAwait(false);
+            var documentKey = nameof(MutateIn_ReviveDocument_Succeeds) + Guid.NewGuid();
+            // first, lets create a tombstone
+            using (await collection.MutateInAsync(documentKey, builder =>
+                {
+                    builder.Upsert("test_attr", "foo", isXattr: true);
+                }, options => options.StoreSemantics(StoreSemantics.Upsert).CreateAsDeleted(true))
+                .ConfigureAwait(false));
+
+            // verify it is a tombstone
+            var lookupInResult = await collection.LookupInAsync(documentKey, builder =>
+            {
+                builder.GetFull();
+            }, options => options.AccessDeleted(true)).ConfigureAwait(false);
+            Assert.True(lookupInResult.IsDeleted);
+
+            // now revive (we can use the ReplaceBodyWithXattr since we do that with txns)...
+            using (await collection.MutateInAsync(documentKey, builder =>
+                   {
+                       builder.ReplaceBodyWithXattr("test_attr");
+                   }, options => options.ReviveDocument(true)).ConfigureAwait(false));
+            // verify not a tombstone
+            var lookupInResult2 = await collection.LookupInAsync(documentKey, builder =>
+            {
+                builder.GetFull();
+            }, options => options.AccessDeleted(true)).ConfigureAwait(false);
+            Assert.False(lookupInResult2.IsDeleted);
+        }
+
+        [Fact]
+        public async Task  MutateIn_ReviveDocument_FailsIfDocumentExists()
+        {
+            var collection = await _fixture.GetDefaultCollectionAsync().ConfigureAwait(false);
+            var documentKey = nameof(MutateIn_ReviveDocument_FailsIfDocumentExists);
+
+            // regular old non-tombstone document
+            await collection.UpsertAsync(documentKey, new { foo = "bar" }).ConfigureAwait(false);
+
+            using var task = collection.MutateInAsync(documentKey, builder =>
+            {
+                builder.Upsert("test_attr", "foo", isXattr: true);
+            }, options => options.ReviveDocument(true));
+
+            await Assert.ThrowsAsync<DocumentAlreadyAliveException>(async () => await task.ConfigureAwait(false));
+        }
+
         #region Helpers
 
         private class TestDoc