MB-66812: Use sha-256 hash instead of full VC for metakv rev

This change addresses the issue where vector clock revisions were too
long. Switch to the new format:
- Use a SHA256 hash of the vector clock

This does not change anything about the metakv vector clocks internally.
Services use `rev` to perform a CAS operation. `rev` is queried on a
node and passed on subsequent mutate operations - to ensure that the
underlying value is updated atomically. During a mutate operation, `rev`
is computed afresh and compared (strict equality) with `rev` in the
incoming request. If they differ, the operation is aborted.

This does not require any changes in the API nor to services because:
- Services treat `rev` as an opaque identifier. `rev` is queried using a
  GET. The raw bytes are sent in subsequent mutate operations. (PUT
  sends rev as raw bytes in a form URL-encoded body, DELETE as percent-
  encoded raw bytes in the query string.)
- Services use `rev` on a node-local basis. There is no need to
  consider distinct `rev` formats on nodes running different versions.
- During an upgrade, a service is restarted along with ns_server/cbauth.
  i.e. a node running a particular version always uses the same format
  for metakv Get/Set/Delete.

Filed MB-68058 for further cleanup.

Change-Id: I9f9bf165ac486fe213f1219a1a5b52e78e8b3d98
Reviewed-on: https://review.couchbase.org/c/ns_server/+/232169
Reviewed-by: Peter Searby <[email protected]>
Well-Formed: Restriction Checker
Well-Formed: Build Bot <[email protected]>
Tested-by: Neelima Premsankar <[email protected]>

Author: neelima32

src/menelaus_metakv.erl

@@ -52,7 +52,7 @@ handle_normal_get(Req, Key) ->
                 true ->
                     menelaus_util:reply_json(Req, [], 404);
                 false ->
-                    Rev = base64:encode(erlang:term_to_binary(VC)),
+                    Rev = base64:encode(metakv:convert_vc_to_opaque_hash(VC)),
                     Val = base64:encode(Val0),
                     menelaus_util:reply_json(Req, {[{rev, Rev},
                                                     {value, Val}]})
@@ -70,8 +70,7 @@ handle_mutate(Req, Key, Value, Params) ->
                           missing
                   end;
               XRev ->
-                  XRevB = list_to_binary(XRev),
-                  binary_to_term(XRevB)
+                  list_to_binary(XRev)
           end,
     Sensitive = proplists:get_value("sensitive", Params) =:= "true",
     case metakv:mutate(Key, Value,
@@ -142,7 +141,7 @@ handle_iterate(Req, Path, Continuous) ->
 output_kv(HTTPRes, {K, V}) ->
     write_chunk(HTTPRes, null, K, base64:encode(V), false);
 output_kv(HTTPRes, {K, V, VC, Sensitive}) ->
-    Rev0 = base64:encode(erlang:term_to_binary(VC)),
+    Rev0 = base64:encode(metakv:convert_vc_to_opaque_hash(VC)),
     {Rev, Value} = case V of
                        ?DELETED_MARKER ->
                            {null, null};

src/metakv.erl

@@ -20,7 +20,8 @@
          ns_config_get/2,
          mutate/2, mutate/3,
          iterate_matching/1, iterate_matching/2, iterate_matching/3,
-         check_continuous_allowed/1]).
+         check_continuous_allowed/1,
+         convert_vc_to_opaque_hash/1]).
 
 %% Exported APIs
 
@@ -180,12 +181,17 @@ ns_config_mutation(Key, Value, Params) ->
                   false ->
                       RV = ns_config:run_txn(
                              fun (Cfg, SetFn) ->
-                                     OldData = ns_config:search_with_vclock(Cfg, K),
+                                     OldData = ns_config:search_with_vclock(Cfg,
+                                                                            K),
                                      OldValue = get_old_value(OldData),
                                      NewValue = add_sensitive(Sensitive,
                                                               OldValue, Value),
-                                     OldVC = get_old_vclock(OldData),
-                                     case Rev =:= OldVC of
+                                     OldVCHash =
+                                         case get_old_vclock(OldData) of
+                                             missing -> missing;
+                                             VC -> convert_vc_to_opaque_hash(VC)
+                                         end,
+                                     case Rev =:= OldVCHash of
                                          true ->
                                              {commit, SetFn(K, NewValue, Cfg)};
                                          false ->
@@ -351,3 +357,7 @@ ns_config_matching_kvs(Key, KVList) ->
     %% This will retain the behaviour as it existed
     %% before this code was moved here from menelaus_metakv.erl.
     [{K, V} || {K, V} <- KVList, Filter(K)].
+
+%% Takes in a vector clock and returns an opaque SHA256 hash of that clock.
+convert_vc_to_opaque_hash(VC) ->
+    crypto:hash(sha256, erlang:term_to_binary(VC)).