Update Khepri from 0.14.0 to 0.15.0

Release notes:
https://github.com/rabbitmq/khepri/releases/tag/v0.15.0

The `favor` default value is now `low_latency`. Therefore, we don't need
to specify it explicitly anymore.

MODULE.bazel

@@ -207,11 +207,11 @@ erlang_package.hex_package(
     version = "1.4.1",
 )
 
-erlang_package.hex_package(
+erlang_package.git_package(
     name = "khepri",
     build_file = "@rabbitmq-server//bazel:BUILD.khepri",
-    sha256 = "dccfaeb3583a04722e2258911f7f906ce67f8efac80504be4923aaafae6d4e21",
-    version = "0.14.0",
+    branch = "main",
+    repository = "rabbitmq/khepri",
 )
 
 erlang_package.hex_package(

deps/rabbit/src/rabbit_db_maintenance.erl

@@ -155,11 +155,7 @@ get_consistent_in_mnesia(Node) ->
 
 get_consistent_in_khepri(Node) ->
     Path = khepri_maintenance_path(Node),
-    %% FIXME: Ra consistent queries are fragile in the sense that the query
-    %% function may run on a remote node and the function reference or MFA may
-    %% not be valid on that node. That's why we force a local query for now.
-    %Options = #{favor => consistent},
-    Options = #{favor => local},
+    Options = #{favor => consistency},
     case rabbit_khepri:get(Path, Options) of
         {ok, #node_maintenance_state{status = Status}} ->
             Status;

deps/rabbit/src/rabbit_khepri.erl

@@ -292,8 +292,7 @@ wait_for_leader(_Timeout, 0) ->
 wait_for_leader(Timeout, Retries) ->
     rabbit_log:info("Waiting for Khepri leader for ~tp ms, ~tp retries left",
                     [Timeout, Retries - 1]),
-    Options = #{timeout => Timeout,
-                favor => low_latency},
+    Options = #{timeout => Timeout},
     case khepri:exists(?STORE_ID, [], Options) of
         Exists when is_boolean(Exists) ->
             rabbit_log:info("Khepri leader elected"),
@@ -877,50 +876,46 @@ cas(Path, Pattern, Data) ->
       ?STORE_ID, Path, Pattern, Data, ?DEFAULT_COMMAND_OPTIONS).
 
 fold(Path, Pred, Acc) ->
-    khepri:fold(?STORE_ID, Path, Pred, Acc, #{favor => low_latency}).
+    khepri:fold(?STORE_ID, Path, Pred, Acc).
 
 fold(Path, Pred, Acc, Options) ->
-    Options1 = Options#{favor => low_latency},
-    khepri:fold(?STORE_ID, Path, Pred, Acc, Options1).
+    khepri:fold(?STORE_ID, Path, Pred, Acc, Options).
 
 foreach(Path, Pred) ->
-    khepri:foreach(?STORE_ID, Path, Pred, #{favor => low_latency}).
+    khepri:foreach(?STORE_ID, Path, Pred).
 
 filter(Path, Pred) ->
-    khepri:filter(?STORE_ID, Path, Pred, #{favor => low_latency}).
+    khepri:filter(?STORE_ID, Path, Pred).
 
 get(Path) ->
-    khepri:get(?STORE_ID, Path, #{favor => low_latency}).
+    khepri:get(?STORE_ID, Path).
 
 get(Path, Options) ->
-    Options1 = Options#{favor => low_latency},
-    khepri:get(?STORE_ID, Path, Options1).
+    khepri:get(?STORE_ID, Path, Options).
 
 get_many(PathPattern) ->
-    khepri:get_many(?STORE_ID, PathPattern, #{favor => low_latency}).
+    khepri:get_many(?STORE_ID, PathPattern).
 
 adv_get(Path) ->
-    khepri_adv:get(?STORE_ID, Path, #{favor => low_latency}).
+    khepri_adv:get(?STORE_ID, Path).
 
 adv_get_many(PathPattern) ->
-    khepri_adv:get_many(?STORE_ID, PathPattern, #{favor => low_latency}).
+    khepri_adv:get_many(?STORE_ID, PathPattern).
 
 match(Path) ->
     match(Path, #{}).
 
 match(Path, Options) ->
-    Options1 = Options#{favor => low_latency},
-    khepri:get_many(?STORE_ID, Path, Options1).
+    khepri:get_many(?STORE_ID, Path, Options).
 
-exists(Path) -> khepri:exists(?STORE_ID, Path, #{favor => low_latency}).
+exists(Path) -> khepri:exists(?STORE_ID, Path).
 
 list(Path) ->
     khepri:get_many(
-      ?STORE_ID, Path ++ [?KHEPRI_WILDCARD_STAR], #{favor => low_latency}).
+      ?STORE_ID, Path ++ [?KHEPRI_WILDCARD_STAR]).
 
 list_child_nodes(Path) ->
-    Options = #{props_to_return => [child_names],
-                favor => low_latency},
+    Options = #{props_to_return => [child_names]},
     case khepri_adv:get_many(?STORE_ID, Path, Options) of
         {ok, Result} ->
             case maps:values(Result) of
@@ -934,8 +929,7 @@ list_child_nodes(Path) ->
     end.
 
 count_children(Path) ->
-    Options = #{props_to_return => [child_list_length],
-               favor => low_latency},
+    Options = #{props_to_return => [child_list_length]},
     case khepri_adv:get_many(?STORE_ID, Path, Options) of
         {ok, Map} ->
             lists:sum([L || #{child_list_length := L} <- maps:values(Map)]);
@@ -986,18 +980,9 @@ transaction(Fun) ->
 transaction(Fun, ReadWrite) ->
     transaction(Fun, ReadWrite, #{}).
 
-transaction(Fun, ReadWrite, Options0) ->
-    %% If the transaction is read-only, use the same default options we use
-    %% for most queries.
-    DefaultQueryOptions = case ReadWrite of
-                              ro ->
-                                  #{favor => low_latency};
-                              _ ->
-                                  #{}
-                          end,
-    Options1 = maps:merge(DefaultQueryOptions, Options0),
-    Options = maps:merge(?DEFAULT_COMMAND_OPTIONS, Options1),
-    case khepri:transaction(?STORE_ID, Fun, ReadWrite, Options) of
+transaction(Fun, ReadWrite, Options) ->
+    Options1 = maps:merge(?DEFAULT_COMMAND_OPTIONS, Options),
+    case khepri:transaction(?STORE_ID, Fun, ReadWrite, Options1) of
         ok -> ok;
         {ok, Result} -> Result;
         {error, Reason} -> throw({error, Reason})