Upgrade eetcd and gun

 ## Why?

To introduce AMQP over WebSocket, we will add gun to the Erlang AMQP
1.0 client. We want to add the latest version of gun for this new
feature. Since rabbitmq_peer_discovery_etcd depends on the outdated
eetcd 0.3.6 which in turn depends on the outdated gun 1.3.3, this commit
first upgrades eetcd and gun.

  ## How?
See https://github.com/zhongwencool/eetcd?tab=readme-ov-file#migration-from-eetcd-03x-to-04x

 ## Breaking Changes

This commit causes the following breaking change:
`rabbitmq.conf` settings
* `cluster_formation.etcd.ssl_options.fail_if_no_peer_cert`
* `cluster_formation.etcd.ssl_options.dh`
* `cluster_formation.etcd.ssl_options.dhfile`

are unsupported because they are not valid `ssl:tls_client_option()`.

See erlang/otp#7497 (comment)

Author: ansd

deps/rabbitmq_peer_discovery_etcd/Makefile

@@ -5,8 +5,8 @@ PROJECT_MOD = rabbitmq_peer_discovery_etcd_app
 DEPS = rabbit_common rabbitmq_peer_discovery_common rabbit eetcd gun
 TEST_DEPS = rabbitmq_ct_helpers rabbitmq_ct_client_helpers ct_helper meck
 dep_ct_helper = git https://github.com/extend/ct_helper.git master
-dep_gun = hex 1.3.3
-dep_eetcd = hex 0.3.6
+dep_gun = hex 2.1.0
+dep_eetcd = hex 0.4.0
 
 DEP_EARLY_PLUGINS = rabbit_common/mk/rabbitmq-early-plugin.mk
 DEP_PLUGINS = rabbit_common/mk/rabbitmq-plugin.mk

deps/rabbitmq_peer_discovery_etcd/README.md

@@ -14,11 +14,6 @@ it is not. Cluster provisioning and most of Day 2 operations such as [proper mon
 are not in scope for this plugin.
 
 
-## Supported RabbitMQ Versions
-
-This plugin requires RabbitMQ 3.7.0 or later.
-
-
 ## Supported etcd Versions
 
 The plugin supports etcd 3.4 or later and uses the current stable v3 gRPC API.
@@ -36,17 +31,11 @@ before first node boot:
 rabbitmq-plugins --offline enable rabbitmq_peer_discovery_etcd
 ```
 
-
 ## Documentation
 
 See [RabbitMQ Cluster Formation guide](https://www.rabbitmq.com/cluster-formation.html).
 
 
-## Contributing
-
-See [CONTRIBUTING.md](./CONTRIBUTING.md) and our [development process overview](http://www.rabbitmq.com/github.html).
-
-
 ## License
 
 [Licensed under the MPL](LICENSE-MPL-RabbitMQ), same as RabbitMQ server.

deps/rabbitmq_peer_discovery_etcd/priv/schema/rabbitmq_peer_discovery_etcd.schema

@@ -182,9 +182,6 @@ end}.
 {mapping, "cluster_formation.etcd.ssl_options.verify", "rabbit.cluster_formation.peer_discovery_etcd.ssl_options.verify", [
     {datatype, {enum, [verify_peer, verify_none]}}]}.
 
-{mapping, "cluster_formation.etcd.ssl_options.fail_if_no_peer_cert", "rabbit.cluster_formation.peer_discovery_etcd.ssl_options.fail_if_no_peer_cert", [
-    {datatype, {enum, [true, false]}}]}.
-
 {mapping, "cluster_formation.etcd.ssl_options.cacertfile", "rabbit.cluster_formation.peer_discovery_etcd.ssl_options.cacertfile",
     [{datatype, string}, {validators, ["file_accessible"]}]}.
 
@@ -214,17 +211,6 @@ end}.
 {mapping, "cluster_formation.etcd.ssl_options.depth", "rabbit.cluster_formation.peer_discovery_etcd.ssl_options.depth",
     [{datatype, integer}, {validators, ["byte"]}]}.
 
-{mapping, "cluster_formation.etcd.ssl_options.dh", "rabbit.cluster_formation.peer_discovery_etcd.ssl_options.dh",
-    [{datatype, string}]}.
-
-{translation, "rabbit.cluster_formation.peer_discovery_etcd.ssl_options.dh",
-fun(Conf) ->
-    list_to_binary(cuttlefish:conf_get("cluster_formation.etcd.ssl_options.dh", Conf))
-end}.
-
-{mapping, "cluster_formation.etcd.ssl_options.dhfile", "rabbit.cluster_formation.peer_discovery_etcd.ssl_options.dhfile",
-    [{datatype, string}, {validators, ["file_accessible"]}]}.
-
 {mapping, "cluster_formation.etcd.ssl_options.key.RSAPrivateKey", "rabbit.cluster_formation.peer_discovery_etcd.ssl_options.key",
     [{datatype, string}]}.
 

deps/rabbitmq_peer_discovery_etcd/src/rabbit_peer_discovery_etcd.erl

@@ -16,8 +16,6 @@
 -export([init/0, list_nodes/0, supports_registration/0, register/0, unregister/0,
          post_registration/0, lock/1, unlock/1]).
 
--define(ETCD_CLIENT, rabbitmq_peer_discovery_etcd_v3_client).
-
 %%
 %% API
 %%
@@ -36,10 +34,10 @@ init() ->
             _ = application:ensure_all_started(eetcd),
             Formation = application:get_env(rabbit, cluster_formation, []),
             Opts = maps:from_list(proplists:get_value(peer_discovery_etcd, Formation, [])),
-            {ok, Pid} = rabbitmq_peer_discovery_etcd_v3_client:start_link(Opts),
+            {ok, Pid} = rabbitmq_peer_discovery_etcd_client:start_link(Opts),
             %% unlink so that this supervisor's lifecycle does not affect RabbitMQ core
             unlink(Pid),
-            rabbit_log:debug("etcd peer discovery: v3 client pid: ~tp", [whereis(rabbitmq_peer_discovery_etcd_v3_client)])
+            rabbit_log:debug("etcd peer discovery client pid: ~tp", [whereis(rabbitmq_peer_discovery_etcd_client)])
            end,
     rabbit_peer_discovery_util:maybe_backend_configured(?BACKEND_CONFIG_KEY, NoOp, NoOp, Run),
 
@@ -64,7 +62,7 @@ list_nodes() ->
                    %% The node with the lowest create_revision is thus selected
                    %% based on the assumption that the create_revision remains
                    %% consistent throughout the lifetime of the etcd key.
-                   [{_, Node} | _] = rabbitmq_peer_discovery_etcd_v3_client:list_nodes(),
+                   [{_, Node} | _] = rabbitmq_peer_discovery_etcd_client:list_nodes(),
                    {ok, {Node, disc}}
            end,
     rabbit_peer_discovery_util:maybe_backend_configured(?BACKEND_CONFIG_KEY, Fun0, Fun1, Fun2).
@@ -79,14 +77,14 @@ supports_registration() ->
 -spec register() -> ok | {error, string()}.
 
 register() ->
-    Result = ?ETCD_CLIENT:register(),
+    Result = rabbitmq_peer_discovery_etcd_client:register(),
     rabbit_log:info("Registered node with etcd"),
     Result.
 
 
 -spec unregister() -> ok | {error, string()}.
 unregister() ->
-    %% This backend unregisters on plugin (etcd v3 client) deactivation
+    %% This backend unregisters on plugin (etcd client) deactivation
     %% because by the time unregistration happens, the plugin and thus the client
     %% it provides are already gone. MK.
     ok.
@@ -101,7 +99,7 @@ post_registration() ->
 
 lock(Nodes) when is_list(Nodes) ->
     Node = node(),
-    case rabbitmq_peer_discovery_etcd_v3_client:lock(Node) of
+    case rabbitmq_peer_discovery_etcd_client:lock(Node) of
         {ok, GeneratedKey} -> {ok, GeneratedKey};
         {error, _} = Error -> Error
     end.
@@ -110,4 +108,4 @@ lock(Nodes) when is_list(Nodes) ->
 -spec unlock(Data :: term()) -> ok.
 
 unlock(GeneratedKey) ->
-    rabbitmq_peer_discovery_etcd_v3_client:unlock(GeneratedKey).
+    rabbitmq_peer_discovery_etcd_client:unlock(GeneratedKey).

deps/rabbitmq_peer_discovery_etcd/src/rabbitmq_peer_discovery_etcd_app.erl

@@ -20,7 +20,7 @@ start(_Type, _StartArgs) ->
 
 prep_stop(_State) ->
     try
-        rabbitmq_peer_discovery_etcd_v3_client:unregister()
+        rabbitmq_peer_discovery_etcd_client:unregister()
     catch
         _:_ -> ok
     end.

deps/rabbitmq_peer_discovery_etcd/src/rabbitmq_peer_discovery_etcd_v3_client.erl renamed to deps/rabbitmq_peer_discovery_etcd/src/rabbitmq_peer_discovery_etcd_client.erl

@@ -5,7 +5,7 @@
 %% Copyright (c) 2007-2024 Broadcom. All Rights Reserved. The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. All rights reserved.
 %%
 
--module(rabbitmq_peer_discovery_etcd_v3_client).
+-module(rabbitmq_peer_discovery_etcd_client).
 
 %% API
 -export([]).
@@ -85,11 +85,11 @@ init(Args) ->
 callback_mode() -> [state_functions, state_enter].
 
 terminate(Reason, State, Data) ->
-    rabbit_log:debug("etcd v3 API client will terminate in state ~tp, reason: ~tp",
+    rabbit_log:debug("etcd client will terminate in state ~tp, reason: ~tp",
                      [State, Reason]),
     _ = disconnect(?ETCD_CONN_NAME, Data),
-    rabbit_log:debug("etcd v3 API client has disconnected"),
-    rabbit_log:debug("etcd v3 API client: total number of connections to etcd is ~tp", [length(eetcd_conn_sup:info())]),
+    rabbit_log:debug("etcd client has disconnected"),
+    rabbit_log:debug("etcd client: total number of connections to etcd is ~tp", [length(eetcd_conn_sup:info())]),
     ok.
 
 register() ->
@@ -133,25 +133,19 @@ unlock(ServerRef, LockKey) ->
 %%
 
 recover(enter, _PrevState, #statem_data{endpoints = Endpoints}) ->
-    rabbit_log:debug("etcd v3 API client has entered recovery state, endpoints: ~ts",
+    rabbit_log:debug("etcd client has entered recovery state, endpoints: ~ts",
                      [string:join(Endpoints, ",")]),
     keep_state_and_data;
 recover(internal, start, Data = #statem_data{endpoints = Endpoints, connection_monitor = Ref}) ->
-    rabbit_log:debug("etcd v3 API client will attempt to connect, endpoints: ~ts",
+    rabbit_log:debug("etcd client will attempt to connect, endpoints: ~ts",
                      [string:join(Endpoints, ",")]),
     maybe_demonitor(Ref),
-    {Transport, TransportOpts} = pick_transport(Data),
-    case Transport of
-        tcp -> rabbit_log:info("etcd v3 API client is configured to connect over plain TCP, without using TLS");
-        tls -> rabbit_log:info("etcd v3 API client is configured to use TLS")
-    end,
-    ConnName = ?ETCD_CONN_NAME,
-    case connect(ConnName, Endpoints, Transport, TransportOpts, Data) of
+    case connect(?ETCD_CONN_NAME, Endpoints, Data) of
         {ok, Pid} ->
-            rabbit_log:debug("etcd v3 API client connection: ~tp", [Pid]),
-            rabbit_log:debug("etcd v3 API client: total number of connections to etcd is ~tp", [length(eetcd_conn_sup:info())]),
+            rabbit_log:debug("etcd client connection: ~tp", [Pid]),
+            rabbit_log:debug("etcd client: total number of connections to etcd is ~tp", [length(eetcd_conn_sup:info())]),
             {next_state, connected, Data#statem_data{
-                connection_name = ConnName,
+                connection_name = ?ETCD_CONN_NAME,
                 connection_pid = Pid,
                 connection_monitor = monitor(process, Pid)
             }};
@@ -166,7 +160,7 @@ recover(state_timeout, _PrevState, Data) ->
     _ = ensure_disconnected(?ETCD_CONN_NAME, Data),
     {next_state, recover, reset_statem_data(Data)};
 recover({call, From}, Req, _Data) ->
-    rabbit_log:error("etcd v3 API: client received a call ~tp while not connected, will do nothing", [Req]),
+    rabbit_log:error("etcd client received a call ~tp while not connected, will do nothing", [Req]),
     gen_statem:reply(From, {error, not_connected}),
     keep_state_and_data.
 
@@ -320,20 +314,21 @@ error_is_already_started({_Endpoint, already_started}) ->
 error_is_already_started({_Endpoint, _}) ->
     false.
 
-connect(Name, Endpoints, Transport, TransportOpts, Data) ->
+connect(Name, Endpoints, Data) ->
     case eetcd_conn:lookup(Name) of
         {ok, Pid} when is_pid(Pid) ->
             {ok, Pid};
         {error, eetcd_conn_unavailable} ->
-            do_connect(Name, Endpoints, Transport, TransportOpts, Data)
+            do_connect(Name, Endpoints, Data)
     end.
 
-do_connect(Name, Endpoints, Transport, TransportOpts, Data = #statem_data{username = Username}) ->
+do_connect(Name, Endpoints, Data = #statem_data{username = Username}) ->
+    Opts = connection_options(Data),
     case Username of
         undefined -> rabbit_log:info("etcd peer discovery: will connect to etcd without authentication (no credentials configured)");
         _         -> rabbit_log:info("etcd peer discovery: will connect to etcd as user '~ts'", [Username])
     end,
-    case eetcd:open(Name, Endpoints, connection_options(Data), Transport, TransportOpts) of
+    case eetcd:open(Name, Endpoints, Opts) of
         {ok, Pid} -> {ok, Pid};
         {error, Errors0} ->
             Errors = case is_list(Errors0) of
@@ -354,16 +349,6 @@ do_connect(Name, Endpoints, Transport, TransportOpts, Data = #statem_data{userna
             end
     end.
 
-connection_options(#statem_data{username = Username, obfuscated_password = Password}) ->
-    SharedOpts = [{mode, random}],
-    case {Username, Password} of
-        {undefined, _} -> SharedOpts;
-        {_, undefined} -> SharedOpts;
-        {UVal, PVal}   ->
-            [{name, UVal}, {password, to_list(deobfuscate(PVal))}] ++ SharedOpts
-    end.
-
-
 obfuscate(undefined) -> undefined;
 obfuscate(Password) ->
     credentials_obfuscation:encrypt(to_binary(Password)).
@@ -429,7 +414,23 @@ normalize_settings(Map) when is_map(Map) ->
     maps:merge(maps:without([etcd_prefix, lock_wait_time], Map),
                #{endpoints => AllEndpoints}).
 
-pick_transport(#statem_data{tls_options = []}) ->
-    {tcp, []};
-pick_transport(#statem_data{tls_options = Opts}) ->
-    {tls, Opts}.
+connection_options(#statem_data{tls_options = TlsOpts,
+                                username = Username,
+                                obfuscated_password = Password}) ->
+    Opts0 = case TlsOpts of
+                [] ->
+                    rabbit_log:info("etcd client is configured to use plain TCP (without TLS)"),
+                    [{transport, tcp}];
+                _ ->
+                    rabbit_log:info("etcd client is configured to use TLS"),
+                    [{transport, tls} | TlsOpts]
+            end,
+    Opts = [{mode, random} | Opts0],
+    case Username =:= undefined orelse
+         Password =:= undefined of
+        true ->
+            Opts;
+        false ->
+            [{name, Username},
+             {password, to_list(deobfuscate(Password))}] ++ Opts
+    end.

deps/rabbitmq_peer_discovery_etcd/src/rabbitmq_peer_discovery_etcd_sup.erl

@@ -24,16 +24,16 @@ init([]) ->
     Fun1 = fun() -> {ok, {Flags, []}} end,
     Fun2 = fun(_) ->
             %% we stop the previously started client and "re-attach" it. MK.
-            rabbitmq_peer_discovery_etcd_v3_client:stop(),
+            rabbitmq_peer_discovery_etcd_client:stop(),
             Formation = application:get_env(rabbit, cluster_formation, []),
             Opts = maps:from_list(proplists:get_value(peer_discovery_etcd, Formation, [])),
             EtcdClientFSM = #{
-                id => rabbitmq_peer_discovery_etcd_v3_client,
-                start => {rabbitmq_peer_discovery_etcd_v3_client, start_link, [Opts]},
+                id => rabbitmq_peer_discovery_etcd_client,
+                start => {rabbitmq_peer_discovery_etcd_client, start_link, [Opts]},
                 restart => permanent,
                 shutdown => ?SUPERVISOR_WAIT,
                 type => worker,
-                modules => [rabbitmq_peer_discovery_etcd_v3_client]
+                modules => [rabbitmq_peer_discovery_etcd_client]
             },
             Specs = [
                 EtcdClientFSM

deps/rabbitmq_peer_discovery_etcd/test/system_SUITE.erl

@@ -34,17 +34,17 @@
 
 all() ->
     [
-     {group, v3_client},
+     {group, client},
      {group, clustering}
     ].
 
 groups() ->
     [
-     {v3_client, [], [
-                    etcd_connection_sanity_check_test,
-                    init_opens_a_connection_test,
-                    registration_with_locking_test
-                ]},
+     {client, [], [
+                   etcd_connection_sanity_check_test,
+                   init_opens_a_connection_test,
+                   registration_with_locking_test
+                  ]},
      {clustering, [], [start_one_member_at_a_time,
                        start_members_concurrently]}
     ].
@@ -266,12 +266,12 @@ registration_with_locking_test(Config) ->
                  end,
     rabbit_ct_helpers:await_condition(Condition1, 90000),
 
-    {ok, LockOwnerKey} = rabbitmq_peer_discovery_etcd_v3_client:lock(Pid, node()),
-    rabbitmq_peer_discovery_etcd_v3_client:register(Pid),
-    ?assertEqual(ok, rabbitmq_peer_discovery_etcd_v3_client:unlock(Pid, LockOwnerKey)),
+    {ok, LockOwnerKey} = rabbitmq_peer_discovery_etcd_client:lock(Pid, node()),
+    rabbitmq_peer_discovery_etcd_client:register(Pid),
+    ?assertEqual(ok, rabbitmq_peer_discovery_etcd_client:unlock(Pid, LockOwnerKey)),
 
     Condition2 = fun() ->
-                    case rabbitmq_peer_discovery_etcd_v3_client:list_nodes(Pid) of
+                    case rabbitmq_peer_discovery_etcd_client:list_nodes(Pid) of
                         [{_, N}] when N =:= node() ->
                             true;
                         _ ->
@@ -381,7 +381,7 @@ assert_full_cluster(Config) ->
 %%
 
 start_client(Endpoints) ->
-    case rabbitmq_peer_discovery_etcd_v3_client:start(#{endpoints => Endpoints}) of
+    case rabbitmq_peer_discovery_etcd_client:start(#{endpoints => Endpoints}) of
         {ok, Pid} ->
             {ok, Pid};
         {error, {already_started, Pid}} ->