Merge in default

8 files changed, 63 insertions, 44 deletions

diff --git a/Makefile b/Makefile
index 31c71dd4..948c6c06 100644
--- a/Makefile
+++ b/Makefile
@@ -347,10 +347,10 @@ $(foreach XML,$(USAGES_XML),$(eval $(call usage_dep, $(XML))))
 # Note that all targets which depend on clean must have clean in their
 # name.  Also any target that doesn't depend on clean should not have
 # clean in its name, unless you know that you don't need any of the
-# automatic dependency generation for that target (eg cleandb).
+# automatic dependency generation for that target (e.g. cleandb).
 
 # We want to load the dep file if *any* target *doesn't* contain
-# "clean" - i.e. if removing all clean-like targets leaves something
+# "clean" - i.e. if removing all clean-like targets leaves something.
 
 ifeq "$(MAKECMDGOALS)" ""
 TESTABLEGOALS:=$(.DEFAULT_GOAL)
diff --git a/packaging/windows/Makefile b/packaging/windows/Makefile
index 828cf000..a910941b 100644
--- a/packaging/windows/Makefile
+++ b/packaging/windows/Makefile
@@ -26,6 +26,9 @@ dist:
 	elinks -dump -no-references -no-numbering rabbitmq-service.html \
 		> $(TARGET_DIR)/readme-service.txt
 	todos $(TARGET_DIR)/readme-service.txt
+	todos $(TARGET_DIR)/INSTALL
+	todos $(TARGET_DIR)/LICENSE*
+	todos $(TARGET_DIR)/plugins/README.txt
 	rm -rf $(TARGET_DIR)/plugins-src
 	zip -q -r $(TARGET_ZIP).zip $(TARGET_DIR)
 	rm -rf $(TARGET_DIR) rabbitmq-service.html
diff --git a/src/rabbit_amqqueue_process.erl b/src/rabbit_amqqueue_process.erl
index b3a620fa..12cd0c93 100644
--- a/src/rabbit_amqqueue_process.erl
+++ b/src/rabbit_amqqueue_process.erl
@@ -710,15 +710,12 @@ infos(Items, State) ->
                || Item <- (Items1 -- [synchronised_slave_pids])].
 
 slaves_status(#q{q = #amqqueue{name = Name}}) ->
-    {ok, #amqqueue{mirror_nodes = MNodes, slave_pids = SPids}} =
-        rabbit_amqqueue:lookup(Name),
-    case MNodes of
-        undefined ->
+    case rabbit_amqqueue:lookup(Name) of
+        {ok, #amqqueue{mirror_nodes = undefined}} ->
             [{slave_pids, ''}, {synchronised_slave_pids, ''}];
-        _ ->
+        {ok, #amqqueue{slave_pids = SPids}} ->
             {Results, _Bad} =
-                delegate:invoke(
-                  SPids, fun (Pid) -> rabbit_mirror_queue_slave:info(Pid) end),
+                delegate:invoke(SPids, fun rabbit_mirror_queue_slave:info/1),
             {SPids1, SSPids} =
                 lists:foldl(
                   fun ({Pid, Infos}, {SPidsN, SSPidsN}) ->
@@ -762,11 +759,9 @@ i(memory, _) ->
     {memory, M} = process_info(self(), memory),
     M;
 i(slave_pids, #q{q = #amqqueue{name = Name}}) ->
-    {ok, #amqqueue{mirror_nodes = MNodes,
-                   slave_pids = SPids}} = rabbit_amqqueue:lookup(Name),
-    case MNodes of
-        undefined -> [];
-        _         -> SPids
+    case rabbit_amqqueue:lookup(Name) of
+        {ok, #amqqueue{mirror_nodes = undefined}} -> [];
+        {ok, #amqqueue{slave_pids = SPids}}       -> SPids
     end;
 i(backing_queue_status, #q{backing_queue_state = BQS, backing_queue = BQ}) ->
     BQ:status(BQS);
diff --git a/src/rabbit_misc.erl b/src/rabbit_misc.erl
index 9a6879b1..b6d38172 100644
--- a/src/rabbit_misc.erl
+++ b/src/rabbit_misc.erl
@@ -720,13 +720,14 @@ gb_trees_foreach(Fun, Tree) ->
 %%     [{"-q",true},{"-p","/"}]}
 get_options(Defs, As) ->
     lists:foldl(fun(Def, {AsIn, RsIn}) ->
-                        {AsOut, Value} = case Def of
-                                             {flag, Key} ->
-                                                 get_flag(Key, AsIn);
-                                             {option, Key, Default} ->
-                                                 get_option(Key, Default, AsIn)
-                                         end,
-                        {AsOut, [{Key, Value} | RsIn]}
+                        {K, {AsOut, V}} =
+                            case Def of
+                                {flag, Key} ->
+                                    {Key, get_flag(Key, AsIn)};
+                                {option, Key, Default} ->
+                                    {Key, get_option(Key, Default, AsIn)}
+                            end,
+                        {AsOut, [{K, V} | RsIn]}
                 end, {As, []}, Defs).
 
 get_option(K, _Default, [K, V | As]) ->
diff --git a/src/rabbit_mnesia.erl b/src/rabbit_mnesia.erl
index 60dd0770..4d419fd9 100644
--- a/src/rabbit_mnesia.erl
+++ b/src/rabbit_mnesia.erl
@@ -732,18 +732,18 @@ reset(Force) ->
         false -> ok
     end,
     Node = node(),
+    Nodes = all_clustered_nodes() -- [Node],
     case Force of
         true  -> ok;
         false ->
             ensure_mnesia_dir(),
             start_mnesia(),
-            {Nodes, RunningNodes} =
+            RunningNodes =
                 try
                     %% Force=true here so that reset still works when clustered
                     %% with a node which is down
                     ok = init_db(read_cluster_nodes_config(), true),
-                    {all_clustered_nodes() -- [Node],
-                     running_clustered_nodes() -- [Node]}
+                    running_clustered_nodes() -- [Node]
                 after
                     stop_mnesia()
                 end,
@@ -751,6 +751,10 @@ reset(Force) ->
             rabbit_misc:ensure_ok(mnesia:delete_schema([Node]),
                                   cannot_delete_schema)
     end,
+    %% We need to make sure that we don't end up in a distributed
+    %% Erlang system with nodes while not being in an Mnesia cluster
+    %% with them. We don't handle that well.
+    [erlang:disconnect_node(N) || N <- Nodes],
     ok = delete_cluster_nodes_config(),
     %% remove persisted messages and any other garbage we find
     ok = rabbit_file:recursive_delete(filelib:wildcard(dir() ++ "/*")),
diff --git a/src/rabbit_node_monitor.erl b/src/rabbit_node_monitor.erl
index 54a7add2..323cf0ce 100644
--- a/src/rabbit_node_monitor.erl
+++ b/src/rabbit_node_monitor.erl
@@ -61,23 +61,26 @@ notify_cluster() ->
 %%--------------------------------------------------------------------
 
 init([]) ->
-    {ok, no_state}.
+    {ok, ordsets:new()}.
 
 handle_call(_Request, _From, State) ->
     {noreply, State}.
 
-handle_cast({rabbit_running_on, Node}, State) ->
-    rabbit_log:info("rabbit on ~p up~n", [Node]),
-    erlang:monitor(process, {rabbit, Node}),
-    ok = handle_live_rabbit(Node),
-    {noreply, State};
+handle_cast({rabbit_running_on, Node}, Nodes) ->
+    case ordsets:is_element(Node, Nodes) of
+        true  -> {noreply, Nodes};
+        false -> rabbit_log:info("rabbit on node ~p up~n", [Node]),
+                 erlang:monitor(process, {rabbit, Node}),
+                 ok = handle_live_rabbit(Node),
+                 {noreply, ordsets:add_element(Node, Nodes)}
+    end;
 handle_cast(_Msg, State) ->
     {noreply, State}.
 
-handle_info({'DOWN', _MRef, process, {rabbit, Node}, _Reason}, State) ->
-    rabbit_log:info("node ~p lost 'rabbit'~n", [Node]),
+handle_info({'DOWN', _MRef, process, {rabbit, Node}, _Reason}, Nodes) ->
+    rabbit_log:info("rabbit on node ~p down~n", [Node]),
     ok = handle_dead_rabbit(Node),
-    {noreply, State};
+    {noreply, ordsets:del_element(Node, Nodes)};
 handle_info(_Info, State) ->
     {noreply, State}.
 
diff --git a/src/rabbit_reader.erl b/src/rabbit_reader.erl
index 908a279c..01242e81 100644
--- a/src/rabbit_reader.erl
+++ b/src/rabbit_reader.erl
@@ -505,9 +505,11 @@ handle_frame(Type, Channel, Payload,
 process_frame(Frame, Channel, State) ->
     case get({channel, Channel}) of
         {ChPid, AState} ->
-            NewAState = process_channel_frame(Frame, Channel, ChPid, AState),
-            put({channel, Channel}, {ChPid, NewAState}),
-            post_process_frame(Frame, ChPid, State);
+            case process_channel_frame(Frame,  ChPid, AState) of
+                {ok, NewAState} -> put({channel, Channel}, {ChPid, NewAState}),
+                                   post_process_frame(Frame, ChPid, State);
+                {error, Reason} -> handle_exception(State, Channel, Reason)
+            end;
         undefined when ?IS_RUNNING(State) ->
             ok = create_channel(Channel, State),
             process_frame(Frame, Channel, State);
@@ -910,17 +912,15 @@ create_channel(Channel, State) ->
     put({channel, Channel}, {ChPid, AState}),
     ok.
 
-process_channel_frame(Frame, Channel, ChPid, AState) ->
+process_channel_frame(Frame, ChPid, AState) ->
     case rabbit_command_assembler:process(Frame, AState) of
-        {ok, NewAState}                  -> NewAState;
+        {ok, NewAState}                  -> {ok, NewAState};
         {ok, Method, NewAState}          -> rabbit_channel:do(ChPid, Method),
-                                            NewAState;
+                                            {ok, NewAState};
         {ok, Method, Content, NewAState} -> rabbit_channel:do_flow(
                                               ChPid, Method, Content),
-                                            NewAState;
-        {error, Reason}                  -> self() ! {channel_exit, Channel,
-                                                      Reason},
-                                            AState
+                                            {ok, NewAState};
+        {error, Reason}                  -> {error, Reason}
     end.
 
 handle_exception(State = #v1{connection_state = closed}, _Channel, _Reason) ->
diff --git a/src/rabbit_tests.erl b/src/rabbit_tests.erl
index 7a96af26..433ed9cb 100644
--- a/src/rabbit_tests.erl
+++ b/src/rabbit_tests.erl
@@ -71,10 +71,13 @@ maybe_run_cluster_dependent_tests() ->
 run_cluster_dependent_tests(SecondaryNode) ->
     SecondaryNodeS = atom_to_list(SecondaryNode),
 
+    cover:stop(SecondaryNode),
     ok = control_action(stop_app, []),
     ok = control_action(reset, []),
     ok = control_action(cluster, [SecondaryNodeS]),
     ok = control_action(start_app, []),
+    cover:start(SecondaryNode),
+    ok = control_action(start_app, SecondaryNode, [], []),
 
     io:format("Running cluster dependent tests with node ~p~n", [SecondaryNode]),
     passed = test_delegates_async(SecondaryNode),
@@ -960,7 +963,9 @@ test_cluster_management2(SecondaryNode) ->
     ok = control_action(cluster, [SecondaryNodeS, NodeS]),
     ok = control_action(start_app, []),
     ok = control_action(stop_app, []),
+    cover:stop(SecondaryNode),
     ok = control_action(reset, []),
+    cover:start(SecondaryNode),
 
     %% attempt to leave cluster when no other node is alive
     ok = control_action(cluster, [SecondaryNodeS, NodeS]),
@@ -977,7 +982,15 @@ test_cluster_management2(SecondaryNode) ->
     %% leave system clustered, with the secondary node as a ram node
     ok = control_action(force_reset, []),
     ok = control_action(start_app, []),
-    ok = control_action(force_reset, SecondaryNode, [], []),
+    %% Yes, this is rather ugly. But since we're a clustered Mnesia
+    %% node and we're telling another clustered node to reset itself,
+    %% we will get disconnected half way through causing a
+    %% badrpc. This never happens in real life since rabbitmqctl is
+    %% not a clustered Mnesia node.
+    cover:stop(SecondaryNode),
+    {badrpc, nodedown} = control_action(force_reset, SecondaryNode, [], []),
+    pong = net_adm:ping(SecondaryNode),
+    cover:start(SecondaryNode),
     ok = control_action(cluster, SecondaryNode, [NodeS], []),
     ok = control_action(start_app, SecondaryNode, [], []),