Merge pull request #8991 from rabbitmq/replace-remaining-direct-calls-to-rabbit_ff_registry

Replace remaining direct calls to `rabbit_ff_registry`

Author: dumbbell

deps/rabbit/src/rabbit_deprecated_features.erl

@@ -286,7 +286,7 @@ is_permitted_nolog(FeatureName) ->
 %% features.
 
 get_phase(FeatureName) when is_atom(FeatureName) ->
-    case rabbit_ff_registry:get(FeatureName) of
+    case rabbit_ff_registry_wrapper:get(FeatureName) of
         undefined    -> undefined;
         FeatureProps -> get_phase(FeatureProps)
     end;
@@ -317,7 +317,7 @@ get_phase(FeatureProps) when is_map(FeatureProps) ->
 %% features.
 
 get_warning(FeatureName) when is_atom(FeatureName) ->
-    case rabbit_ff_registry:get(FeatureName) of
+    case rabbit_ff_registry_wrapper:get(FeatureName) of
         undefined    -> undefined;
         FeatureProps -> get_warning(FeatureProps)
     end;
@@ -328,7 +328,7 @@ get_warning(FeatureProps) when is_map(FeatureProps) ->
     get_warning(FeatureProps, Permitted).
 
 get_warning(FeatureName, Permitted) when is_atom(FeatureName) ->
-    case rabbit_ff_registry:get(FeatureName) of
+    case rabbit_ff_registry_wrapper:get(FeatureName) of
         undefined    -> undefined;
         FeatureProps -> get_warning(FeatureProps, Permitted)
     end;

deps/rabbit/src/rabbit_feature_flags.erl

@@ -1109,11 +1109,11 @@ try_to_write_enabled_feature_flags_list(FeatureNames) ->
                         end,
     FeatureNames1 = lists:filter(
                       fun(FeatureName) ->
-                              case rabbit_ff_registry:get(FeatureName) of
-                                  undefined ->
-                                      false;
-                                  FeatureProps ->
-                                      ?IS_FEATURE_FLAG(FeatureProps)
+                              FeatureProps = rabbit_ff_registry_wrapper:get(
+                                               FeatureName),
+                              case FeatureProps of
+                                  undefined -> false;
+                                  _         -> ?IS_FEATURE_FLAG(FeatureProps)
                               end
                       end, FeatureNames),
     FeatureNames2 = lists:foldl(

deps/rabbit/src/rabbit_ff_controller.erl

@@ -1055,7 +1055,7 @@ collect_inventory_on_nodes(Nodes, Timeout) ->
     Inventory0 = #{feature_flags => #{},
                    applications_per_node => #{},
                    states_per_node => #{}},
-    Rets = rpc_calls(Nodes, rabbit_ff_registry, inventory, [], Timeout),
+    Rets = inventory_rpcs(Nodes, Timeout),
     maps:fold(
       fun
           (Node,
@@ -1081,6 +1081,46 @@ collect_inventory_on_nodes(Nodes, Timeout) ->
               Error
       end, {ok, Inventory0}, Rets).
 
+inventory_rpcs(Nodes, Timeout) ->
+    %% We must use `rabbit_ff_registry_wrapper' if it is available to avoid
+    %% any deadlock with the Code server. If it is unavailable, we fall back
+    %% to `rabbit_ff_registry'.
+    %%
+    %% See commit aacfa1978e24bcacd8de7d06a7c3c5d9d8bd098e and pull request
+    %% #8155.
+    Rets0 = rpc_calls(
+              Nodes,
+              rabbit_ff_registry_wrapper, inventory, [], Timeout),
+    OlderNodes = maps:fold(
+                   fun
+                       (Node,
+                        {error,
+                         {exception, undef,
+                          [{rabbit_ff_registry_wrapper,_ , _, _} | _]}},
+                        Acc) ->
+                           [Node | Acc];
+                       (_Node, _Ret, Acc) ->
+                           Acc
+                   end, [], Rets0),
+    case OlderNodes of
+        [] ->
+            Rets0;
+        _ ->
+            ?LOG_INFO(
+               "Feature flags: the following nodes run an older version of "
+               "RabbitMQ causing the "
+               "\"rabbit_ff_registry_wrapper:inventory[] undefined\" error "
+               "above: ~2p~n"
+               "Feature flags: falling back to another method for those "
+               "nodes; this may trigger a bug causing them to hang",
+               [lists:sort(OlderNodes)],
+               #{domain => ?RMQLOG_DOMAIN_FEAT_FLAGS}),
+            Rets1 = rpc_calls(
+                      OlderNodes,
+                      rabbit_ff_registry, inventory, [], Timeout),
+            maps:merge(Rets0, Rets1)
+    end.
+
 merge_feature_flags(FeatureFlagsA, FeatureFlagsB) ->
     FeatureFlags = maps:merge(FeatureFlagsA, FeatureFlagsB),
     maps:map(

deps/rabbit/src/rabbit_ff_registry.erl

@@ -203,11 +203,10 @@ is_registry_written_to_disk() ->
       Inventory :: rabbit_feature_flags:inventory().
 
 inventory() ->
-    _ = rabbit_ff_registry_factory:initialize_registry(),
     Inventory = #{applications => [],
                   feature_flags => #{},
                   states => #{}},
-    ?convince_dialyzer(?MODULE:inventory(), Inventory, Inventory).
+    ?convince_dialyzer(?MODULE:inventory(), init_required, Inventory).
 
 always_return_true() ->
     %% This function is here to trick Dialyzer. We want some functions

deps/rabbit/src/rabbit_ff_registry_factory.erl

@@ -114,8 +114,9 @@ initialize_registry(NewSupportedFeatureFlags) ->
     RegistryInitialized = rabbit_ff_registry:is_registry_initialized(),
     FeatureStates = case RegistryInitialized of
                         true ->
-                            CurrentFeatureStates = rabbit_ff_registry:states(),
-                            maps:merge(FeatureStates0, CurrentFeatureStates);
+                            maps:merge(
+                              FeatureStates0,
+                              rabbit_ff_registry_wrapper:states());
                         false ->
                             FeatureStates0
                     end,
@@ -205,7 +206,7 @@ maybe_initialize_registry(NewSupportedFeatureFlags,
     %% We take the feature flags already registered.
     RegistryInitialized = rabbit_ff_registry:is_registry_initialized(),
     KnownFeatureFlags1 = case RegistryInitialized of
-                             true  -> rabbit_ff_registry:list(all);
+                             true  -> rabbit_ff_registry_wrapper:list(all);
                              false -> #{}
                          end,
 
@@ -253,8 +254,9 @@ maybe_initialize_registry(NewSupportedFeatureFlags,
     not rabbit_feature_flags:does_enabled_feature_flags_list_file_exist(),
     FeatureStates0 = case RegistryInitialized of
                          true ->
-                             maps:merge(rabbit_ff_registry:states(),
-                                        NewFeatureStates);
+                             maps:merge(
+                               rabbit_ff_registry_wrapper:states(),
+                               NewFeatureStates);
                          false ->
                              NewFeatureStates
                      end,
@@ -374,8 +376,8 @@ does_registry_need_refresh(AllFeatureFlags,
             %% Before proceeding with the actual
             %% (re)initialization, let's see if there are any
             %% changes.
-            CurrentAllFeatureFlags = rabbit_ff_registry:list(all),
-            CurrentFeatureStates = rabbit_ff_registry:states(),
+            CurrentAllFeatureFlags = rabbit_ff_registry_wrapper:list(all),
+            CurrentFeatureStates = rabbit_ff_registry_wrapper:states(),
             CurrentWrittenToDisk =
             rabbit_ff_registry:is_registry_written_to_disk(),