Merge default into bug24926

9 files changed, 320 insertions, 92 deletions

diff --git a/docs/rabbitmq-plugins.1.xml b/docs/rabbitmq-plugins.1.xml
index 8ecb4fc83c..f860e9c327 100644
--- a/docs/rabbitmq-plugins.1.xml
+++ b/docs/rabbitmq-plugins.1.xml
@@ -69,7 +69,7 @@
 
     <variablelist>
       <varlistentry>
-        <term><cmdsynopsis><command>list</command> <arg choice="opt">-v</arg> <arg choice="opt">-m</arg> <arg choice="opt">-E</arg> <arg choice="opt">-e</arg> <arg choice="opt"><replaceable>pattern</replaceable></arg></cmdsynopsis></term>
+        <term><cmdsynopsis><command>list</command> <arg choice="opt">-v</arg> <arg choice="opt">-m</arg> <arg choice="opt">-E</arg> <arg choice="opt">-e</arg> <arg choice="opt">-A</arg> <arg choice="opt">-I</arg> <arg choice="opt"><replaceable>pattern</replaceable></arg></cmdsynopsis></term>
         <listitem>
           <variablelist>
             <varlistentry>
@@ -91,6 +91,16 @@
               enabled plugins.</para></listitem>
             </varlistentry>
             <varlistentry>
+              <term>-A</term>
+              <listitem><para>Show active plugins (running on the broker) that
+              are not explicitly or implicitly enabled.</para></listitem>
+            </varlistentry>
+            <varlistentry>
+              <term>-I</term>
+              <listitem><para>Show in-active plugins (not running on the broker) that
+              are explicitly or implicitly enabled.</para></listitem>
+            </varlistentry>
+            <varlistentry>
               <term>pattern</term>
               <listitem><para>Pattern to filter the plugin names by.</para></listitem>
             </varlistentry>
@@ -102,7 +112,11 @@
             enabled, [E] to indicate that it is explicitly enabled,
             [e] to indicate that it is implicitly enabled, and [!] to
             indicate that it is enabled but missing and thus not
-            operational.
+            operational. When a plugin is enabled but not currently
+            active (i.e., running) in the currently targetted broker,
+            [A] is shown, whilst a plugin which is active/running but
+            not currently configured to be enabled is indicated by
+            an [I].
           </para>
           <para>
             If the optional pattern is given, only plugins whose
diff --git a/scripts/rabbitmq-plugins b/scripts/rabbitmq-plugins
index 2ec45be01f..2213e20bf1 100755
--- a/scripts/rabbitmq-plugins
+++ b/scripts/rabbitmq-plugins
@@ -21,6 +21,7 @@
 
 ##--- Set environment vars RABBITMQ_<var_name> to defaults if not set
 
+[ "x" = "x$RABBITMQ_NODENAME" ] && RABBITMQ_NODENAME=${NODENAME}
 [ "x" = "x$RABBITMQ_ENABLED_PLUGINS_FILE" ] && RABBITMQ_ENABLED_PLUGINS_FILE=${ENABLED_PLUGINS_FILE}
 [ "x" = "x$RABBITMQ_PLUGINS_DIR" ] && RABBITMQ_PLUGINS_DIR=${PLUGINS_DIR}
 
@@ -35,4 +36,5 @@ exec ${ERL_DIR}erl \
     -s rabbit_plugins_main \
     -enabled_plugins_file "$RABBITMQ_ENABLED_PLUGINS_FILE" \
     -plugins_dist_dir "$RABBITMQ_PLUGINS_DIR" \
+    -nodename $RABBITMQ_NODENAME \
     -extra "$@"
diff --git a/scripts/rabbitmq-plugins.bat b/scripts/rabbitmq-plugins.bat
index a535ebad31..61e39e3885 100755
--- a/scripts/rabbitmq-plugins.bat
+++ b/scripts/rabbitmq-plugins.bat
@@ -31,6 +31,10 @@ if "!RABBITMQ_BASE!"=="" (
     set RABBITMQ_BASE=!APPDATA!\!RABBITMQ_SERVICENAME!

 )

 

+if "!RABBITMQ_NODENAME!"=="" (

+    set RABBITMQ_NODENAME=rabbit@!COMPUTERNAME!

+)

+

 if not exist "!ERLANG_HOME!\bin\erl.exe" (

     echo.

     echo ******************************

@@ -51,7 +55,7 @@ if "!RABBITMQ_PLUGINS_DIR!"=="" (
     set RABBITMQ_PLUGINS_DIR=!TDP0!..\plugins

 )

 

-"!ERLANG_HOME!\bin\erl.exe" -pa "!TDP0!..\ebin" -noinput -hidden -sname rabbitmq-plugins!RANDOM!!TIME:~9! -s rabbit_plugins_main -enabled_plugins_file "!RABBITMQ_ENABLED_PLUGINS_FILE!" -plugins_dist_dir "!RABBITMQ_PLUGINS_DIR:\=/!" -extra !STAR!

+"!ERLANG_HOME!\bin\erl.exe" -pa "!TDP0!..\ebin" -noinput -hidden -sname rabbitmq-plugins!RANDOM!!TIME:~9! -s rabbit_plugins_main -enabled_plugins_file "!RABBITMQ_ENABLED_PLUGINS_FILE!" -plugins_dist_dir "!RABBITMQ_PLUGINS_DIR:\=/!" -nodename !RABBITMQ_NODENAME! -extra !STAR!

 

 endlocal

 endlocal

diff --git a/src/app_utils.erl b/src/app_utils.erl
index 0479ce6608..2efbb1f12b 100644
--- a/src/app_utils.erl
+++ b/src/app_utils.erl
@@ -17,7 +17,7 @@
 
 -export([load_applications/1, start_applications/1, start_applications/2,
          stop_applications/1, stop_applications/2, app_dependency_order/2,
-         wait_for_applications/1]).
+         wait_for_applications/1, app_dependencies/1, app_modules/1]).
 
 -ifdef(use_specs).
 
@@ -30,12 +30,18 @@
 -spec stop_applications([atom()], error_handler())  -> 'ok'.
 -spec wait_for_applications([atom()])               -> 'ok'.
 -spec app_dependency_order([atom()], boolean())     -> [digraph:vertex()].
+-spec app_dependencies(atom())                      -> [atom()].
+-spec app_modules(atom())                           -> [module()].
 
 -endif.
 
 %%---------------------------------------------------------------------------
 %% Public API
 
+app_modules(App) ->
+    {ok, Modules} = application:get_key(App, modules),
+    Modules.
+
 load_applications(Apps) ->
     load_applications(queue:from_list(Apps), sets:new()),
     ok.
diff --git a/src/rabbit.erl b/src/rabbit.erl
index c2d7e29d6b..1610614570 100644
--- a/src/rabbit.erl
+++ b/src/rabbit.erl
@@ -22,9 +22,9 @@
          stop_and_halt/0, await_startup/0, status/0, is_running/0,
          is_running/1, environment/0, rotate_logs/1, force_event_refresh/1,
          start_fhc/0]).
-
+-export([run_boot_steps/0, load_steps/1, run_step/3]).
 -export([start/2, stop/1]).
-
+-export([start_apps/1, stop_apps/1]).
 -export([log_location/1]). %% for testing
 
 %%---------------------------------------------------------------------------
@@ -312,8 +312,7 @@ start() ->
                      ok = ensure_working_log_handlers(),
                      rabbit_node_monitor:prepare_cluster_status_files(),
                      rabbit_mnesia:check_cluster_consistency(),
-                     ok = app_utils:start_applications(
-                            app_startup_order(), fun handle_app_error/2),
+                     start_apps(app_startup_order()),
                      ok = log_broker_started(rabbit_plugins:active())
              end).
 
@@ -331,19 +330,27 @@ boot() ->
                      rabbit_mnesia:check_cluster_consistency(),
                      Plugins = rabbit_plugins:setup(),
                      ToBeLoaded = Plugins ++ ?APPS,
-                     ok = app_utils:load_applications(ToBeLoaded),
-                     StartupApps = app_utils:app_dependency_order(ToBeLoaded,
-                                                                  false),
-                     ok = app_utils:start_applications(
-                            StartupApps, fun handle_app_error/2),
+                     start_apps(ToBeLoaded),
                      ok = log_broker_started(Plugins)
              end).
 
-handle_app_error(App, {bad_return, {_MFA, {'EXIT', {Reason, _}}}}) ->
-    throw({could_not_start, App, Reason});
+handle_app_error(Term) ->
+    fun(App, {bad_return, {_MFA, {'EXIT', {ExitReason, _}}}}) ->
+            throw({Term, App, ExitReason});
+       (App, Reason) ->
+            throw({Term, App, Reason})
+    end.
 
-handle_app_error(App, Reason) ->
-    throw({could_not_start, App, Reason}).
+start_apps(Apps) ->
+    app_utils:load_applications(Apps),
+    StartupApps = app_utils:app_dependency_order(Apps, false),
+    case whereis(rabbit_boot) of
+        undefined -> run_boot_steps(Apps);
+        _         -> ok
+    end,
+    ok = app_utils:start_applications(StartupApps,
+                                      handle_app_error(could_not_start)),
+    StartupApps.
 
 start_it(StartFun) ->
     Marker = spawn_link(fun() -> receive stop -> ok end end),
@@ -369,12 +376,13 @@ start_it(StartFun) ->
     end.
 
 stop() ->
+    Apps = app_shutdown_order(),
     case whereis(rabbit_boot) of
         undefined -> ok;
-        _         -> await_startup()
+        _         -> app_utils:wait_for_applications(Apps)
     end,
     rabbit_log:info("Stopping RabbitMQ~n"),
-    ok = app_utils:stop_applications(app_shutdown_order()).
+    ok = app_utils:stop_applications(Apps).
 
 stop_and_halt() ->
     try
@@ -385,6 +393,29 @@ stop_and_halt() ->
     end,
     ok.
 
+stop_apps(Apps) ->
+    try
+        ok = app_utils:stop_applications(
+               Apps, handle_app_error(error_during_shutdown))
+    after
+        run_cleanup_steps(Apps),
+        [begin
+             {ok, Mods} = application:get_key(App, modules),
+             [begin
+                  code:soft_purge(Mod),
+                  code:delete(Mod),
+                  false = code:is_loaded(Mod)
+              end || Mod <- Mods],
+             application:unload(App)
+         end || App <- Apps]
+    end.
+
+run_cleanup_steps(Apps) ->
+    [run_step(Name, Attributes, cleanup) ||
+        {App, Name, Attributes} <- load_steps(Apps),
+        lists:member(App, Apps)],
+    ok.
+
 await_startup() ->
     app_utils:wait_for_applications(app_startup_order()).
 
@@ -468,7 +499,7 @@ start(normal, []) ->
             true = register(rabbit, self()),
             print_banner(),
             log_banner(),
-            [ok = run_boot_step(Step) || Step <- boot_steps()],
+            run_boot_steps(),
             {ok, SupPid};
         Error ->
             Error
@@ -496,29 +527,90 @@ app_shutdown_order() ->
 %%---------------------------------------------------------------------------
 %% boot step logic
 
-run_boot_step({_StepName, Attributes}) ->
-    case [MFA || {mfa, MFA} <- Attributes] of
+run_boot_steps() ->
+    run_boot_steps([App || {App, _, _} <- application:loaded_applications()]).
+
+run_boot_steps(Apps) ->
+    Steps = load_steps(Apps),
+    [ok = run_step(StepName, Attributes, mfa) ||
+        {_, StepName, Attributes} <- Steps],
+    ok.
+
+run_step(StepName, Attributes, AttributeName) ->
+    case [MFA || {Key, MFA} <- Attributes,
+                 Key =:= AttributeName] of
         [] ->
             ok;
         MFAs ->
             [try
                  apply(M,F,A)
              of
-                 ok ->              ok;
-                 {error, Reason} -> boot_error(Reason, not_available)
+                 ok              -> ok;
+                 {error, Reason} -> boot_error({boot_step, StepName, Reason},
+                                               not_available)
              catch
-                 _:Reason -> boot_error(Reason, erlang:get_stacktrace())
+                 _:Reason -> boot_error({boot_step, StepName, Reason},
+                                        erlang:get_stacktrace())
              end || {M,F,A} <- MFAs],
             ok
     end.
 
-boot_steps() ->
-    sort_boot_steps(rabbit_misc:all_module_attributes(rabbit_boot_step)).
+load_steps(BaseApps) ->
+    Apps = BaseApps -- [App || {App, _, _} <- rabbit_misc:which_applications()],
+    StepAttrs = rabbit_misc:all_module_attributes(rabbit_boot_step),
+    {AllSteps, StepsDict} =
+        lists:foldl(
+          fun({AppName, Mod, Steps}, {AccSteps, AccDict}) ->
+                  {[{Mod, {AppName, Steps}}|AccSteps],
+                   lists:foldl(
+                     fun({StepName, _}, Acc) ->
+                             dict:store(StepName, AppName, Acc)
+                     end, AccDict, Steps)}
+          end, {[], dict:new()}, StepAttrs),
+    Steps = lists:foldl(filter_steps(Apps, StepsDict), [], AllSteps),
+    sort_boot_steps(lists:usort(Steps)).
+
+filter_steps(Apps, Dict) ->
+    fun({Mod, {AppName, Steps}}, Acc) ->
+            Steps2 = [begin
+                          Filtered = lists:foldl(filter_attrs(Apps, Dict),
+                                                 [], Attrs),
+                          {Step, Filtered}
+                      end || {Step, Attrs} <- Steps,
+                             filter_app(Apps, Dict, Step)],
+            [{Mod, {AppName, Steps2}}|Acc]
+    end.
+
+filter_app(Apps, Dict, Step) ->
+    case dict:find(Step, Dict) of
+        {ok, App} -> lists:member(App, Apps);
+        error     -> false
+    end.
+
+filter_attrs(Apps, Dict) ->
+    fun(Attr={Type, Other}, AccAttrs) when Type =:= requires orelse
+                                           Type =:= enables ->
+            %% If we don't know about a dependency, we allow it through,
+            %% since we don't *know* that it should be ignored. If, on
+            %% the other hand, we recognise a dependency then we _only_
+            %% include it (i.e., the requires/enables attribute itself)
+            %% if the referenced step comes from one of the Apps we're
+            %% actively working with at this point.
+            case dict:find(Other, Dict) of
+                error     -> [Attr | AccAttrs];
+                {ok, App} -> case lists:member(App, Apps) of
+                                 true  -> [Attr | AccAttrs];
+                                 false -> AccAttrs
+                             end
+            end;
+       (Attr, AccAttrs) ->
+            [Attr | AccAttrs]
+    end.
 
-vertices(_Module, Steps) ->
-    [{StepName, {StepName, Atts}} || {StepName, Atts} <- Steps].
+vertices(_Module, {AppName, Steps}) ->
+    [{StepName, {AppName, StepName, Atts}} || {StepName, Atts} <- Steps].
 
-edges(_Module, Steps) ->
+edges(_Module, {_AppName, Steps}) ->
     [case Key of
          requires -> {StepName, OtherStep};
          enables  -> {OtherStep, StepName}
@@ -541,8 +633,8 @@ sort_boot_steps(UnsortedSteps) ->
             digraph:delete(G),
             %% Check that all mentioned {M,F,A} triples are exported.
             case [{StepName, {M,F,A}} ||
-                     {StepName, Attributes} <- SortedSteps,
-                     {mfa, {M,F,A}}         <- Attributes,
+                     {_App, StepName, Attributes} <- SortedSteps,
+                     {mfa, {M,F,A}}               <- Attributes,
                      not erlang:function_exported(M, F, length(A))] of
                 []               -> SortedSteps;
                 MissingFunctions -> basic_boot_error(
diff --git a/src/rabbit_misc.erl b/src/rabbit_misc.erl
index 2e87a8f6e1..866166328d 100644
--- a/src/rabbit_misc.erl
+++ b/src/rabbit_misc.erl
@@ -209,7 +209,8 @@
          [string()])
         -> {'ok', {atom(), [{string(), string()}], [string()]}} |
            'no_command').
--spec(all_module_attributes/1 :: (atom()) -> [{atom(), [term()]}]).
+-spec(all_module_attributes/1 ::
+        (atom()) -> [{atom(), atom(), [term()]}]).
 -spec(build_acyclic_graph/3 ::
         (graph_vertex_fun(), graph_edge_fun(), [{atom(), [term()]}])
         -> rabbit_types:ok_or_error2(digraph(),
@@ -849,20 +850,20 @@ module_attributes(Module) ->
     end.
 
 all_module_attributes(Name) ->
-    Modules =
+    Targets =
         lists:usort(
           lists:append(
-            [Modules || {App, _, _}   <- application:loaded_applications(),
-                        {ok, Modules} <- [application:get_key(App, modules)]])),
+            [[{App, Module} || Module <- Modules] ||
+                {App, _, _}   <- application:loaded_applications(),
+                {ok, Modules} <- [application:get_key(App, modules)]])),
     lists:foldl(
-      fun (Module, Acc) ->
+      fun ({App, Module}, Acc) ->
               case lists:append([Atts || {N, Atts} <- module_attributes(Module),
                                          N =:= Name]) of
                   []   -> Acc;
-                  Atts -> [{Module, Atts} | Acc]
+                  Atts -> [{App, Module, Atts} | Acc]
               end
-      end, [], Modules).
-
+      end, [], Targets).
 
 build_acyclic_graph(VertexFun, EdgeFun, Graph) ->
     G = digraph:new([acyclic]),
diff --git a/src/rabbit_plugins.erl b/src/rabbit_plugins.erl
index 4ac6c4a01c..d3d76be059 100644
--- a/src/rabbit_plugins.erl
+++ b/src/rabbit_plugins.erl
@@ -18,6 +18,7 @@
 -include("rabbit.hrl").
 
 -export([setup/0, active/0, read_enabled/1, list/1, dependencies/3]).
+-export([enable/1, disable/1]).
 
 %%----------------------------------------------------------------------------
 
@@ -31,17 +32,35 @@
 -spec(read_enabled/1 :: (file:filename()) -> [plugin_name()]).
 -spec(dependencies/3 :: (boolean(), [plugin_name()], [#plugin{}]) ->
                              [plugin_name()]).
-
+-spec(enable/1  :: ([plugin_name()]) -> 'ok').
+-spec(disable/1 :: ([plugin_name()]) -> 'ok').
 -endif.
 
 %%----------------------------------------------------------------------------
 
+enable(Plugins) ->
+    prepare_plugins(Plugins),
+    Diff = rabbit:start_apps(Plugins),
+    ok = rabbit_event:notify(plugins_changed, [{enabled, Diff}]).
+
+disable(Plugins) ->
+    Diff = rabbit:stop_apps(Plugins),
+    ok = rabbit_event:notify(plugins_changed, [{disabled, Plugins}]).
+
 %% @doc Prepares the file system and installs all enabled plugins.
 setup() ->
-    {ok, PluginDir}   = application:get_env(rabbit, plugins_dir),
     {ok, ExpandDir}   = application:get_env(rabbit, plugins_expand_dir),
+
+    %% Eliminate the contents of the destination directory
+    case delete_recursively(ExpandDir) of
+        ok          -> ok;
+        {error, E1} -> throw({error, {cannot_delete_plugins_expand_dir,
+                                      [ExpandDir, E1]}})
+    end,
+
     {ok, EnabledFile} = application:get_env(rabbit, enabled_plugins_file),
-    prepare_plugins(EnabledFile, PluginDir, ExpandDir).
+    Enabled = read_enabled(EnabledFile),
+    prepare_plugins(Enabled).
 
 %% @doc Lists the plugins which are currently running.
 active() ->
@@ -104,9 +123,11 @@ dependencies(Reverse, Sources, AllPlugins) ->
 
 %%----------------------------------------------------------------------------
 
-prepare_plugins(EnabledFile, PluginsDistDir, ExpandDir) ->
+prepare_plugins(Enabled) ->
+    {ok, PluginsDistDir} = application:get_env(rabbit, plugins_dir),
+    {ok, ExpandDir} = application:get_env(rabbit, plugins_expand_dir),
+
     AllPlugins = list(PluginsDistDir),
-    Enabled = read_enabled(EnabledFile),
     ToUnpack = dependencies(false, Enabled, AllPlugins),
     ToUnpackPlugins = lookup_plugins(ToUnpack, AllPlugins),
 
@@ -117,12 +138,6 @@ prepare_plugins(EnabledFile, PluginsDistDir, ExpandDir) ->
                      [Missing])
     end,
 
-    %% Eliminate the contents of the destination directory
-    case delete_recursively(ExpandDir) of
-        ok          -> ok;
-        {error, E1} -> throw({error, {cannot_delete_plugins_expand_dir,
-                                      [ExpandDir, E1]}})
-    end,
     case filelib:ensure_dir(ExpandDir ++ "/") of
         ok          -> ok;
         {error, E2} -> throw({error, {cannot_create_plugins_expand_dir,
diff --git a/src/rabbit_plugins_main.erl b/src/rabbit_plugins_main.erl
index 89e16f14b2..96fd83da24 100644
--- a/src/rabbit_plugins_main.erl
+++ b/src/rabbit_plugins_main.erl
@@ -19,20 +19,29 @@
 
 -export([start/0, stop/0]).
 
+-define(NODE_OPT, "-n").
 -define(VERBOSE_OPT, "-v").
 -define(MINIMAL_OPT, "-m").
 -define(ENABLED_OPT, "-E").
 -define(ENABLED_ALL_OPT, "-e").
+-define(ACTIVE_ONLY_OPT, "-A").
+-define(INACTIVE_ONLY_OPT, "-I").
 
+-define(NODE_DEF(Node), {?NODE_OPT, {option, Node}}).
 -define(VERBOSE_DEF, {?VERBOSE_OPT, flag}).
 -define(MINIMAL_DEF, {?MINIMAL_OPT, flag}).
 -define(ENABLED_DEF, {?ENABLED_OPT, flag}).
 -define(ENABLED_ALL_DEF, {?ENABLED_ALL_OPT, flag}).
+-define(ACTIVE_ONLY_DEF, {?ACTIVE_ONLY_OPT, flag}).
+-define(INACTIVE_ONLY_DEF, {?INACTIVE_ONLY_OPT, flag}).
 
--define(GLOBAL_DEFS, []).
+-define(RPC_TIMEOUT, infinity).
+
+-define(GLOBAL_DEFS(Node), [?NODE_DEF(Node)]).
 
 -define(COMMANDS,
-        [{list, [?VERBOSE_DEF, ?MINIMAL_DEF, ?ENABLED_DEF, ?ENABLED_ALL_DEF]},
+        [{list, [?VERBOSE_DEF, ?MINIMAL_DEF, ?ENABLED_DEF,
+                 ?ENABLED_ALL_DEF, ?ACTIVE_ONLY_DEF, ?INACTIVE_ONLY_DEF]},
          enable,
          disable]).
 
@@ -51,11 +60,10 @@
 start() ->
     {ok, [[PluginsFile|_]|_]} =
         init:get_argument(enabled_plugins_file),
+    {ok, [[NodeStr|_]|_]} = init:get_argument(nodename),
     {ok, [[PluginsDir|_]|_]} = init:get_argument(plugins_dist_dir),
     {Command, Opts, Args} =
-        case rabbit_misc:parse_arguments(?COMMANDS, ?GLOBAL_DEFS,
-                                         init:get_plain_arguments())
-        of
+        case parse_arguments(init:get_plain_arguments(), NodeStr) of
             {ok, Res}  -> Res;
             no_command -> print_error("could not recognise command", []),
                           usage()
@@ -67,7 +75,8 @@ start() ->
                             [string:join([atom_to_list(Command) | Args], " ")])
         end,
 
-    case catch action(Command, Args, Opts, PluginsFile, PluginsDir) of
+    Node = proplists:get_value(?NODE_OPT, Opts),
+    case catch action(Command, Node, Args, Opts, PluginsFile, PluginsDir) of
         ok ->
             rabbit_misc:quit(0);
         {'EXIT', {function_clause, [{?MODULE, action, _} | _]}} ->
@@ -92,12 +101,25 @@ stop() ->
 
 %%----------------------------------------------------------------------------
 
-action(list, [], Opts, PluginsFile, PluginsDir) ->
-    action(list, [".*"], Opts, PluginsFile, PluginsDir);
-action(list, [Pat], Opts, PluginsFile, PluginsDir) ->
-    format_plugins(Pat, Opts, PluginsFile, PluginsDir);
+parse_arguments(CmdLine, NodeStr) ->
+    case rabbit_misc:parse_arguments(
+           ?COMMANDS, ?GLOBAL_DEFS(NodeStr), CmdLine) of
+        {ok, {Cmd, Opts0, Args}} ->
+            Opts = [case K of
+                        ?NODE_OPT -> {?NODE_OPT, rabbit_nodes:make(V)};
+                        _         -> {K, V}
+                    end || {K, V} <- Opts0],
+            {ok, {Cmd, Opts, Args}};
+        E ->
+            E
+    end.
+
+action(list, Node, [], Opts, PluginsFile, PluginsDir) ->
+    action(list, Node, [".*"], Opts, PluginsFile, PluginsDir);
+action(list, Node, [Pat], Opts, PluginsFile, PluginsDir) ->
+    format_plugins(Node, Pat, Opts, PluginsFile, PluginsDir);
 
-action(enable, ToEnable0, _Opts, PluginsFile, PluginsDir) ->
+action(enable, Node, ToEnable0, _Opts, PluginsFile, PluginsDir) ->
     case ToEnable0 of
         [] -> throw({error_string, "Not enough arguments for 'enable'"});
         _  -> ok
@@ -108,7 +130,16 @@ action(enable, ToEnable0, _Opts, PluginsFile, PluginsDir) ->
                                                     Enabled, AllPlugins),
     ToEnable = [list_to_atom(Name) || Name <- ToEnable0],
     Missing = ToEnable -- plugin_names(AllPlugins),
-    NewEnabled = lists:usort(Enabled ++ ToEnable),
+    ExplicitlyEnabled = lists:usort(Enabled ++ ToEnable),
+    NewEnabled =
+        case rpc:call(Node, rabbit_plugins, active, [], ?RPC_TIMEOUT) of
+            {badrpc, _} -> ExplicitlyEnabled;
+            []          -> ExplicitlyEnabled;
+            ActiveList  -> EnabledSet = sets:from_list(ExplicitlyEnabled),
+                           ActiveSet = sets:from_list(ActiveList),
+                           Intersect = sets:intersection(EnabledSet, ActiveSet),
+                           sets:to_list(sets:subtract(EnabledSet, Intersect))
+        end,
     NewImplicitlyEnabled = rabbit_plugins:dependencies(false,
                                                        NewEnabled, AllPlugins),
     MissingDeps = (NewImplicitlyEnabled -- plugin_names(AllPlugins)) -- Missing,
@@ -120,15 +151,15 @@ action(enable, ToEnable0, _Opts, PluginsFile, PluginsDir) ->
                              fmt_missing("plugins", Missing) ++
                                  fmt_missing("dependencies", MissingDeps)})
     end,
-    write_enabled_plugins(PluginsFile, NewEnabled),
-    case NewEnabled -- ImplicitlyEnabled of
+    write_enabled_plugins(PluginsFile, ExplicitlyEnabled),
+    case NewEnabled -- (ImplicitlyEnabled -- ExplicitlyEnabled) of
         [] -> io:format("Plugin configuration unchanged.~n");
         _  -> print_list("The following plugins have been enabled:",
-                         NewImplicitlyEnabled -- ImplicitlyEnabled),
-              report_change()
+                         NewEnabled),
+              action_change(Node, enable, NewEnabled)
     end;
 
-action(disable, ToDisable0, _Opts, PluginsFile, PluginsDir) ->
+action(disable, Node, ToDisable0, _Opts, PluginsFile, PluginsDir) ->
     case ToDisable0 of
         [] -> throw({error_string, "Not enough arguments for 'disable'"});
         _  -> ok
@@ -143,18 +174,25 @@ action(disable, ToDisable0, _Opts, PluginsFile, PluginsDir) ->
                          Missing)
     end,
     ToDisableDeps = rabbit_plugins:dependencies(true, ToDisable, AllPlugins),
+    Active =
+        case rpc:call(Node, rabbit_plugins, active, [], ?RPC_TIMEOUT) of
+            {badrpc, _} -> Enabled;
+            []          -> Enabled;
+            ActiveList  -> ActiveList
+        end,
     NewEnabled = Enabled -- ToDisableDeps,
-    case length(Enabled) =:= length(NewEnabled) of
+    case length(Active) =:= length(NewEnabled) of
         true  -> io:format("Plugin configuration unchanged.~n");
         false -> ImplicitlyEnabled =
-                     rabbit_plugins:dependencies(false, Enabled, AllPlugins),
+                     rabbit_plugins:dependencies(false, Active, AllPlugins),
                  NewImplicitlyEnabled =
                      rabbit_plugins:dependencies(false,
                                                  NewEnabled, AllPlugins),
+                 Disabled = ImplicitlyEnabled -- NewImplicitlyEnabled,
                  print_list("The following plugins have been disabled:",
-                            ImplicitlyEnabled -- NewImplicitlyEnabled),
+                            Disabled),
                  write_enabled_plugins(PluginsFile, NewEnabled),
-                 report_change()
+                 action_change(Node, disable, Disabled)
     end.
 
 %%----------------------------------------------------------------------------
@@ -167,7 +205,7 @@ usage() ->
     rabbit_misc:quit(1).
 
 %% Pretty print a list of plugins.
-format_plugins(Pattern, Opts, PluginsFile, PluginsDir) ->
+format_plugins(Node, Pattern, Opts, PluginsFile, PluginsDir) ->
     Verbose = proplists:get_bool(?VERBOSE_OPT, Opts),
     Minimal = proplists:get_bool(?MINIMAL_OPT, Opts),
     Format = case {Verbose, Minimal} of
@@ -179,12 +217,19 @@ format_plugins(Pattern, Opts, PluginsFile, PluginsDir) ->
              end,
     OnlyEnabled    = proplists:get_bool(?ENABLED_OPT,     Opts),
     OnlyEnabledAll = proplists:get_bool(?ENABLED_ALL_OPT, Opts),
+    OnlyActive     = proplists:get_bool(?ACTIVE_ONLY_OPT, Opts),
+    OnlyInactive   = proplists:get_bool(?INACTIVE_ONLY_OPT, Opts),
 
     AvailablePlugins = rabbit_plugins:list(PluginsDir),
     EnabledExplicitly = rabbit_plugins:read_enabled(PluginsFile),
-    EnabledImplicitly =
-        rabbit_plugins:dependencies(false, EnabledExplicitly,
-                                    AvailablePlugins) -- EnabledExplicitly,
+    AllEnabled = rabbit_plugins:dependencies(false, EnabledExplicitly,
+                                             AvailablePlugins),
+    EnabledImplicitly = AllEnabled -- EnabledExplicitly,
+    ActivePlugins = case rpc:call(Node, rabbit_plugins, active,
+                                  [], ?RPC_TIMEOUT) of
+                        {badrpc, _} -> AllEnabled;
+                        Active      -> Active
+                    end,
     Missing = [#plugin{name = Name, dependencies = []} ||
                   Name <- ((EnabledExplicitly ++ EnabledImplicitly) --
                                plugin_names(AvailablePlugins))],
@@ -193,29 +238,44 @@ format_plugins(Pattern, Opts, PluginsFile, PluginsDir) ->
                   Plugin = #plugin{name = Name} <- AvailablePlugins ++ Missing,
                   re:run(atom_to_list(Name), RE, [{capture, none}]) =:= match,
                   if OnlyEnabled    ->  lists:member(Name, EnabledExplicitly);
-                     OnlyEnabledAll -> (lists:member(Name,
-                                                     EnabledExplicitly) or
-                                        lists:member(Name, EnabledImplicitly));
+                     OnlyEnabledAll -> is_enabled(Name, EnabledExplicitly,
+                                                  EnabledImplicitly);
+                     OnlyActive     -> (lists:member(Name, ActivePlugins)
+                                        andalso not
+                                        (is_enabled(Name, EnabledExplicitly,
+                                                    EnabledImplicitly)));
+                     OnlyInactive   -> (is_enabled(Name, EnabledExplicitly,
+                                                    EnabledImplicitly)
+                                        andalso not
+                                        lists:member(Name, ActivePlugins));
                      true           -> true
                   end],
     Plugins1 = usort_plugins(Plugins),
     MaxWidth = lists:max([length(atom_to_list(Name)) ||
                              #plugin{name = Name} <- Plugins1] ++ [0]),
-    [format_plugin(P, EnabledExplicitly, EnabledImplicitly,
+    [format_plugin(P, EnabledExplicitly, EnabledImplicitly, ActivePlugins,
                    plugin_names(Missing), Format, MaxWidth) || P <- Plugins1],
     ok.
 
+is_enabled(Name, EnabledExplicitly, EnabledImplicitly) ->
+    lists:member(Name,EnabledExplicitly) or
+        lists:member(Name, EnabledImplicitly).
+
 format_plugin(#plugin{name = Name, version = Version,
                       description = Description, dependencies = Deps},
-              EnabledExplicitly, EnabledImplicitly, Missing,
-              Format, MaxWidth) ->
+              EnabledExplicitly, EnabledImplicitly, Active,
+              Missing, Format, MaxWidth) ->
     Glyph = case {lists:member(Name, EnabledExplicitly),
                   lists:member(Name, EnabledImplicitly),
-                  lists:member(Name, Missing)} of
-                {true, false, false} -> "[E]";
-                {false, true, false} -> "[e]";
-                {_,        _,  true} -> "[!]";
-                _                    -> "[ ]"
+                  lists:member(Name, Missing),
+                  lists:member(Name, Active)} of
+                {true,  false, false, false} -> "[I]";
+                {false,  true, false, false} -> "[i]";
+                {false, false, false,  true} -> "[A]";
+                {true,  false, false,  true} -> "[E]";
+                {false,  true, false,  true} -> "[e]";
+                {_,         _,  true,     _} -> "[!]";
+                _                            -> "[ ]"
             end,
     Opt = fun (_F, A, A) -> ok;
               ( F, A, _) -> io:format(F, [A])
@@ -262,6 +322,39 @@ write_enabled_plugins(PluginsFile, Plugins) ->
                                           PluginsFile, Reason}})
     end.
 
-report_change() ->
-    io:format("Plugin configuration has changed. "
-              "Restart RabbitMQ for changes to take effect.~n").
+action_change(Node, Action, Targets) ->
+    rpc_call(Node, rabbit_plugins, Action, [Targets]).
+
+rpc_call(Node, Mod, Action, Args) ->
+    case net_adm:ping(Node) of
+        pong -> io:format("Changing plugin configuration on ~p.", [Node]),
+                AsyncKey = rpc:async_call(Node, Mod, Action, Args),
+                rpc_progress(AsyncKey, Node, Action);
+        pang -> io:format("Plugin configuration has changed. "
+                          "Plugins were not ~p since the node is down.~n"
+                          "Please start the broker to apply "
+                          "your changes.~n",
+                         [case Action of
+                              enable  -> started;
+                              disable -> stopped
+                          end])
+
+    end.
+
+rpc_progress(Key, Node, Action) ->
+    case rpc:nb_yield(Key, 100) of
+        timeout -> io:format("."),
+                   rpc_progress(Key, Node, Action);
+        {value, {badrpc, nodedown}} ->
+            io:format(". error: Unable to contact ~p.~n ", [Node]),
+            io:format("Please start the broker to apply "
+                      "your changes.~n");
+        {value, ok} ->
+            io:format(". done: Plugin(s) ~pd.~n", [Action]);
+        {value, Error} ->
+            io:format(". error: Unable to ~p plugin(s).~n"
+                      "Please restart the broker to apply your changes.~n"
+                      "Error: ~p~n",
+                      [Action, Error])
+    end.
+
diff --git a/src/rabbit_version.erl b/src/rabbit_version.erl
index d943b5998f..e4fcc5966b 100644
--- a/src/rabbit_version.erl
+++ b/src/rabbit_version.erl
@@ -113,10 +113,11 @@ upgrades_required(Scope) ->
 %% -------------------------------------------------------------------
 
 with_upgrade_graph(Fun, Scope) ->
+    Attrs = rabbit_misc:all_module_attributes(rabbit_upgrade),
     case rabbit_misc:build_acyclic_graph(
            fun (Module, Steps) -> vertices(Module, Steps, Scope) end,
            fun (Module, Steps) -> edges(Module, Steps, Scope) end,
-           rabbit_misc:all_module_attributes(rabbit_upgrade)) of
+           [{Mod, Steps} || {_, Mod, Steps} <- Attrs]) of
         {ok, G} -> try
                        Fun(G)
                    after
@@ -161,7 +162,7 @@ heads(G) ->
 
 categorise_by_scope(Version) when is_list(Version) ->
     Categorised =
-        [{Scope, Name} || {_Module, Attributes} <-
+        [{Scope, Name} || {_App, _Module, Attributes} <-
                               rabbit_misc:all_module_attributes(rabbit_upgrade),
                           {Name, Scope, _Requires} <- Attributes,
                           lists:member(Name, Version)],