wip

Author: dumbbell

deps/rabbit/Makefile

@@ -152,20 +152,24 @@ DEP_PLUGINS = rabbit_common/mk/rabbitmq-plugin.mk
 include ../../rabbitmq-components.mk
 include ../../erlang.mk
 
-CLI_SCRIPTS := scripts/rmq
+ESCRIPT_NAME := rabbit_cli
+ESCRIPT_FILE := scripts/rmq
 
-ebin/$(PROJECT).app:: $(CLI_SCRIPTS)
+ebin/$(PROJECT).app:: $(ESCRIPT_FILE)
 
-$(CLI_SCRIPTS): ebin/rabbit_cli.beam
-	$(gen_verbose) echo '#!/usr/bin/env escript' > "$@"
-	$(verbose) echo '%%! +sbtu +A1 -start_epmd false' >> "$@"
-	$(verbose) cat $^ >> "$@"
-	$(verbose) chmod a+x "$@"
+$(ESCRIPT_FILE): ebin/rabbit_cli.beam ebin/rabbit_cli_io.beam
+	$(gen_verbose) cd .. && $(ESCRIPT_ZIP) $(abspath $(ESCRIPT_ZIP_FILE)) $(patsubst %,$(PROJECT)/%,$^)
+	$(gen_verbose) printf "%s\n" \
+		"#!$(ESCRIPT_SHEBANG)" \
+		"%% $(ESCRIPT_COMMENT)" \
+		"%%! $(ESCRIPT_EMU_ARGS)" > $(ESCRIPT_FILE)
+	$(verbose) cat $(abspath $(ESCRIPT_ZIP_FILE)) >> $(ESCRIPT_FILE)
+	$(verbose) chmod a+x $(ESCRIPT_FILE)
 
 clean:: clean-cli
 
 clean-cli:
-	$(gen_verbose) rm -f $(CLI_SCRIPTS)
+	$(gen_verbose) rm -f $(ESCRIPT_FILE)
 
 ifeq ($(strip $(BATS)),)
 BATS := $(ERLANG_MK_TMP)/bats/bin/bats

deps/rabbit/src/rabbit_cli.erl

@@ -5,27 +5,27 @@
 -export([main/1]).
 
 main(Args) ->
-    case run_ci(Args) of
+    case run_cli(Args) of
         ok ->
             erlang:halt();
         {error, ErrorMsg} ->
             io:format(standard_error, "Error: ~ts~n", [ErrorMsg]),
             erlang:halt(1)
     end.
 
-run_ci(Args) ->
+run_cli(Args) ->
     maybe
-        io:format("Args = ~p~n", [Args]),
         {ok, RemainingArgs, Nodename} ?= lookup_rabbitmq_nodename(Args),
-        io:format("Args = ~p~n", [RemainingArgs]),
-        io:format("Nodename = ~p~n", [Nodename]),
         {ok, _} ?= net_kernel:start(undefined, #{name_domain => shortnames}),
         true ?= net_kernel:connect_node(Nodename),
-        io:format("This node = ~p~n", [node()]),
-        %{ok, CommandMap} ?= lookup_command_map(Nodename),
-        %io:format("CommandMap= ~p~n", [CommandMap]),
-        Ret ?= run_command(Nodename,  RemainingArgs),
-        io:format("Ret = ~p~n", [Ret]),
+
+        {ok, IO} ?= rabbit_cli_io:start_link(),
+        try
+            Ret = run_command(Nodename,  RemainingArgs, IO),
+            io:format("Ret = ~p~n", [Ret])
+        after
+            rabbit_cli_io:stop(IO)
+        end,
         ok
     end.
 
@@ -44,9 +44,20 @@ lookup_rabbitmq_nodename(Args) ->
 
 get_rabbitmq_nodename_from_args(Args) ->
     Definition = #{arguments =>
-                   [#{name => node,
+                   [#{name => verbose,
+                      long => "-verbose",
+                      short => $v,
+                      action => count,
+                      help =>
+                      "Be verbose; can be specified multiple times to "
+                      "increase "
+                      "verbosity"},
+                    #{name => node,
                       long => "-node",
-                      short => $n},
+                      short => $n,
+                      type => string,
+                      nargs => 1,
+                      help => "Name of the node to control"},
                     #{name => rest,
                       nargs => list,
                       action => extend,
@@ -138,9 +149,9 @@ complete_nodename(Nodename) ->
 %    io:format("Script = ~p~n", [ScriptDir]),
 %    ok.
 
-run_command(Nodename, Args) ->
+run_command(Nodename, Args, IO) ->
     try
-        erpc:call(Nodename, rabbit_cli_commands, run_command, [Args])
+        erpc:call(Nodename, rabbit_cli_commands, run_command, [Args, IO])
     catch
         error:{erpc, Reason} ->
             {error, Reason}

deps/rabbit/src/rabbit_cli_commands.erl

@@ -2,43 +2,88 @@
 
 -include_lib("kernel/include/logger.hrl").
 
--export([commands/0, run_command/1]).
--export([list_queues/1]).
+-export([commands/0, run_command/2]).
+-export([list_exchanges/2]).
 
 commands() ->
+    %% Extract the commands from module attributes like feature flags and boot
+    %% steps.
     #{
       arguments =>
       [
-       #{name => verbose,
-         short => $v,
-         action => count,
-         help =>
-         "Be verbose; can be specified multiple times to increase "
-         "verbosity"}
+       #{name => rest,
+         nargs => list,
+         action => extend,
+         required => false,
+         default => []}
       ],
       commands =>
       #{
        "list" =>
-       #{commands =>
-         #{"queues" =>
-           #{handler => {?MODULE, list_queues}}
+       #{
+         commands =>
+         #{"exchanges" =>
+           #{
+             handler => {?MODULE, list_exchanges}
+            }
           }
         }
       }
      }.
 
-run_command(Args) ->
+run_command(Args, IO) ->
     Definition = commands(),
     case argparse:parse(Args, Definition, #{}) of
-        {ok, ArgMap, CmdPath, #{handler := {Mod, Fun}} = Command} ->
-            ?LOG_ALERT("ArgMap=~0p~nCmdPath=~0p~nCommand=~0p", [ArgMap, CmdPath, Command]),
-            Mod:Fun(ArgMap),
-            ok;
-        {error, Reason} ->
-            ?LOG_ALERT("Reason=~0p", [Reason]),
-            ok
+        {ok, ArgMap, _CmdPath, Command} ->
+            %% TODO: Put both processes under the rabbit supervision tree.
+            RunnerPid = command_runner(Command, ArgMap, IO),
+            RunnerMRef = erlang:monitor(process, RunnerPid),
+            receive
+                {'DOWN', RunnerMRef, _, _, Reason} ->
+                    {ok, Reason}
+            end;
+        {error, _Reason} = Error ->
+            Error
     end.
 
-list_queues(ArgMap) ->
-    ?LOG_ALERT("Listing queues, ~0p", [ArgMap]),
-    ok.
+command_runner(#{handler := {Mod, Fun}} = _Command, ArgMap, IO) ->
+    spawn_link(Mod, Fun, [ArgMap, IO]).
+
+list_exchanges(ArgMap, IO) ->
+    InfoKeys = rabbit_exchange:info_keys(),
+    Fields = lists:map(
+               fun
+                   (name = Key) ->
+                       #{name => Key, type => resource};
+                   (type = Key) ->
+                       #{name => Key, type => string};
+                   (durable = Key) ->
+                       #{name => Key, type => boolean};
+                   (auto_delete = Key) ->
+                       #{name => Key, type => boolean};
+                   (internal = Key) ->
+                       #{name => Key, type => boolean};
+                   (arguments = Key) ->
+                       #{name => Key, type => term};
+                   (policy = Key) ->
+                       #{name => Key, type => string};
+                   (user_who_performed_action = Key) ->
+                       #{name => Key, type => string};
+                   (Key) ->
+                       #{name => Key, type => term}
+               end, InfoKeys),
+    IOArgs = maps:get(rest, ArgMap, []),
+    case rabbit_cli_io:start_record_stream(IO, exchanges, Fields, IOArgs) of
+        {ok, Stream} ->
+            Exchanges = rabbit_exchange:list(),
+            lists:foreach(
+              fun(Exchange) ->
+                      Record0 = rabbit_exchange:info(Exchange),
+                      Record1 = lists:sublist(Record0, length(Fields)),
+                      Record2 = [Value || {_Key, Value} <- Record1],
+                      rabbit_cli_io:push_new_record(IO, Stream, Record2)
+              end, Exchanges),
+            rabbit_cli_io:end_record_stream(IO, Stream);
+        {error, _} = Error ->
+            Error
+    end.