Merge pull request #4695 from esl/remove_ejabberd_router_2

MIM-2669 Remove ejabberd router

Author: bartekgorny

big_tests/tests/muc_SUITE.erl

@@ -50,6 +50,7 @@
          change_nick_form_iq/1,
          set_nick/2,
          assert_room_event/2,
+         assert_room_events/3,
          wait_for_room_count/1,
          count_rooms/0
          ]).
@@ -98,6 +99,7 @@
 %%--------------------------------------------------------------------
 
 all() -> [
+          acl_deny,
           {group, disco},
           {group, disco_with_mam},
           {group, disco_rsm},
@@ -134,6 +136,9 @@ groups() ->
                                     deep_hibernation_metrics_are_updated,
                                     can_found_in_db_when_stopped
                                    ]},
+         {hibernation_failures, [], [hibernated_room_is_stopped_and_restored_by_presence_user_not_allowed,
+                                     hibernated_room_is_stopped_and_restoration_by_presence_fails
+         ]},
          {disco, [parallel], [
                               disco_service,
                               disco_features,
@@ -155,6 +160,7 @@ groups() ->
                                   moderator_kick_with_reason,
                                   moderator_kick_unauthorized,
                                   moderator_voice,
+                                  visitor_is_not_allowed_to_send,
                                   moderator_voice_with_reason,
                                   moderator_voice_unauthorized,
                                   moderator_voice_list,
@@ -226,6 +232,7 @@ groups() ->
                                  subject,
                                  no_subject,
                                  send_to_all,
+                                 member_must_not_send_service_messages,
                                  send_and_receive_private_message_client_with_x_elem,
                                  send_and_receive_private_message_client_without_x_elem,
                                  send_private_groupchat,
@@ -409,6 +416,10 @@ init_per_group(hibernation, Config) ->
     Config1 = dynamic_modules:save_modules(host_type(), Config),
     setup_mam(mam_helper:backend()),
     Config1;
+init_per_group(hibernation_failures, Config) ->
+    Config1 = dynamic_modules:save_modules(host_type(), Config),
+    setup_mam(mam_helper:backend()),
+    Config1;
 init_per_group(register_over_s2s, Config) ->
     Config1 = s2s_helper:init_s2s(Config),
     Config2 = s2s_helper:configure_s2s(both_plain, Config1),
@@ -471,6 +482,8 @@ end_per_group(G, Config) when G =:= http_auth_no_server;
     dynamic_modules:restore_modules(Config);
 end_per_group(hibernation, Config) ->
     dynamic_modules:restore_modules(Config);
+end_per_group(hibernation_failures, Config) ->
+    dynamic_modules:restore_modules(Config);
 end_per_group(register_over_s2s, Config) ->
     s2s_helper:end_s2s(Config),
     escalus:delete_users(Config, escalus:get_users([alice2, bob, kate]));
@@ -604,6 +617,15 @@ end_per_testcase(CaseName = room_creation_not_allowed, Config) ->
 end_per_testcase(CaseName = create_instant_persistent_room, Config) ->
     dynamic_modules:restore_modules(Config),
     escalus:end_per_testcase(CaseName, Config);
+end_per_testcase(CaseName = acl_deny, Config) ->
+    unload_meck(),
+    escalus:end_per_testcase(CaseName, Config);
+end_per_testcase(CaseName = hibernated_room_is_stopped_and_restored_by_presence_user_not_allowed, Config) ->
+    unload_meck(),
+    escalus:end_per_testcase(CaseName, Config);
+end_per_testcase(CaseName = hibernated_room_is_stopped_and_restoration_by_presence_fails, Config) ->
+    unload_meck(),
+    escalus:end_per_testcase(CaseName, Config);
 end_per_testcase(CaseName, Config) ->
     escalus:end_per_testcase(CaseName, Config).
 
@@ -811,6 +833,31 @@ moderator_voice(ConfigIn) ->
         escalus:assert(Pred2, escalus:wait_for_stanza(Bob))
     end).
 
+visitor_is_not_allowed_to_send(ConfigIn) ->
+    UserSpecs = [{alice, 1}, {bob, 1}],
+    story_with_room(ConfigIn, moderator_room_opts(), UserSpecs, fun(Config, Alice, Bob) ->
+        %% Alice joins room
+        escalus:send(Alice, stanza_muc_enter_room(?config(room, Config), <<"alice">>)),
+        escalus:wait_for_stanzas(Alice, 2),
+        %% Bob joins room
+        escalus:send(Bob, stanza_muc_enter_room(?config(room, Config), <<"bob">>)),
+        escalus:wait_for_stanzas(Bob, 3),
+        %% Skip Bob's presence
+        escalus:wait_for_stanza(Alice),
+        %% Alice makes Bob a visitor
+        escalus:send(Alice, stanza_set_roles(?config(room,Config),
+                                             [{<<"bob">>,<<"visitor">>}])),
+        Msg = <<"chat message">>,
+        Id = <<"MyID">>,
+        Stanza = escalus_stanza:set_id(
+            escalus_stanza:groupchat_to(room_address(?config(room, Config)), Msg), Id),
+        escalus:send(Bob, Stanza),
+        Res = escalus:wait_for_stanza(Bob),
+        ?assertEqual(<<"error">>, exml_query:attr(Res, <<"type">>)),
+        ?assertEqual(<<"403">>, exml_query:path(Res, [{element, <<"error">>}, {attr, <<"code">>}])),
+        ok
+    end).
+
 moderator_voice_with_reason(ConfigIn) ->
     UserSpecs = [{alice, 1}, {bob, 1}],
     story_with_room(ConfigIn, moderator_room_opts(), UserSpecs, fun(Config, Alice, Bob) ->
@@ -2630,6 +2677,41 @@ send_to_all(ConfigIn) ->
         escalus_assert:has_no_stanzas(Kate)
     end).
 
+acl_deny(ConfigIn) ->
+    ok = rpc(mim(), meck, expect, [acl, match_rule,
+                                   fun(_, _, muc, #jid{luser = K}) ->
+                                       case K of
+                                           <<"kate", _/binary>> -> deny;
+                                           _ -> allow
+                                       end;
+                                      (_, _, _, _) ->
+                                          allow
+                                   end]),
+    UserSpecs = [{alice, 1}, {bob, 1}, {kate, 1}],
+    story_with_room(ConfigIn, [], UserSpecs, fun(Config, _Alice, Bob, Kate) ->
+        escalus:send(Bob, stanza_muc_enter_room(?config(room, Config), escalus_utils:get_username(Bob))),
+        escalus:wait_for_stanzas(Bob, 2),
+        escalus:send(Kate, stanza_muc_enter_room(?config(room, Config), escalus_utils:get_username(Kate))),
+        Res = escalus_client:wait_for_stanza(Kate),
+        escalus:assert(is_presence_with_type, [<<"error">>], Res),
+        ?assertEqual(<<"403">>, exml_query:path(Res, [{element, <<"error">>}, {attr, <<"code">>}])),
+        ok
+    end).
+
+member_must_not_send_service_messages(ConfigIn) ->
+    UserSpecs = [{alice, 1}, {bob, 1}],
+    story_with_room(ConfigIn, [], UserSpecs, fun(Config, _Alice, Bob) ->
+        escalus:send(Bob, stanza_muc_enter_room(?config(room, Config), escalus_utils:get_username(Bob))),
+        escalus:wait_for_stanzas(Bob, 2),
+        Msg = <<"chat message">>,
+        Id = <<"MyID">>,
+        Stanza = escalus_stanza:set_id(escalus_stanza:groupchat_to(muc_host(), Msg), Id),
+        escalus:send(Bob, Stanza),
+        Res = escalus:wait_for_stanza(Bob),
+        ?assertEqual(<<"error">>, exml_query:attr(Res, <<"type">>)),
+        ?assertEqual(<<"403">>, exml_query:path(Res, [{element, <<"error">>}, {attr, <<"code">>}])),
+        ok
+    end).
 
 %Examples 46, 47
 send_and_receive_private_message_client_with_x_elem(ConfigIn) ->
@@ -4468,7 +4550,6 @@ hibernated_room_is_stopped_and_restored_by_presence(Config) ->
         escalus:wait_for_stanza(Bob),
         leave_room(RoomName, Bob),
         true = wait_for_room_to_be_stopped(Pid, timer:seconds(8)),
-        ct:sleep(timer:seconds(1)),
 
         escalus:send(Bob, stanza_join_room(RoomName, <<"bob">>)),
         Presence = escalus:wait_for_stanza(Bob, ?WAIT_TIMEOUT),
@@ -4483,6 +4564,59 @@ hibernated_room_is_stopped_and_restored_by_presence(Config) ->
     destroy_room(muc_host(), RoomName),
     forget_room(host_type(), muc_host(), RoomName).
 
+hibernated_room_is_stopped_and_restored_by_presence_user_not_allowed(Config) ->
+    RoomName = fresh_room_name(),
+    ok = rpc(mim(), meck, expect, [acl, match_rule,
+                                   fun(_, _, muc_create, #jid{luser = K}) ->
+                                       case K of
+                                           <<"bob", _/binary>> -> deny;
+                                           _ -> allow
+                                       end;
+                                      (_, _, _, _) ->
+                                          allow
+                                   end]),
+    escalus:fresh_story(Config, [{alice, 1}, {bob, 1}], fun(Alice, Bob) ->
+        Opts = [{persistentroom, true},
+                {subject, <<"Restorable">>}],
+        Result = given_fresh_room_with_participants_is_hibernated(Alice, RoomName, Opts, Bob),
+        {ok, _RoomJID, Pid} = Result,
+        leave_room(RoomName, Alice),
+        escalus:wait_for_stanza(Bob),
+        leave_room(RoomName, Bob),
+        true = wait_for_room_to_be_stopped(Pid, timer:seconds(8)),
+        escalus:send(Bob, stanza_join_room(RoomName, <<"bob">>)),
+        Presence = escalus:wait_for_stanza(Bob, ?WAIT_TIMEOUT),
+        escalus:assert(is_presence_with_type, [<<"error">>], Presence),
+        ?assertEqual(<<"405">>, exml_query:path(Presence, [{element, <<"error">>}, {attr, <<"code">>}])),
+        ok
+    end),
+    destroy_room(muc_host(), RoomName),
+    forget_room(host_type(), muc_host(), RoomName).
+
+hibernated_room_is_stopped_and_restoration_by_presence_fails(Config) ->
+    RoomName = fresh_room_name(),
+    escalus:fresh_story(Config, [{alice, 1}, {bob, 1}], fun(Alice, Bob) ->
+        Opts = [{persistentroom, true},
+                {subject, <<"Restorable">>}],
+        Result = given_fresh_room_with_participants_is_hibernated(Alice, RoomName, Opts, Bob),
+        {ok, _RoomJID, Pid} = Result,
+        leave_room(RoomName, Alice),
+        escalus:wait_for_stanza(Bob),
+        leave_room(RoomName, Bob),
+        true = wait_for_room_to_be_stopped(Pid, timer:seconds(8)),
+        ok = rpc(mim(), meck, expect, [mod_muc_backend, restore_room,
+                                       fun(_, _, _) ->
+                                           {error, fails}
+                                       end]),
+        escalus:send(Bob, stanza_join_room(RoomName, <<"bob">>)),
+        Presence = escalus:wait_for_stanza(Bob, ?WAIT_TIMEOUT),
+        escalus:assert(is_presence_with_type, [<<"error">>], Presence),
+        ?assertEqual(<<"503">>, exml_query:path(Presence, [{element, <<"error">>}, {attr, <<"code">>}])),
+        ok
+    end),
+    destroy_room(muc_host(), RoomName),
+    forget_room(host_type(), muc_host(), RoomName).
+
 stopped_rooms_history_is_available(Config) ->
     RoomName = fresh_room_name(),
     escalus:fresh_story(Config, [{alice, 1}, {bob, 1}], fun(Alice, Bob) ->
@@ -5475,3 +5609,15 @@ fresh_nick_name(Prefix) ->
 
 fresh_nick_name() ->
     fresh_room_name(binary:encode_hex(crypto:strong_rand_bytes(5), lowercase)).
+
+stop_room(Room) ->
+    {ok, Pid} = rpc(mim(), mod_muc_online_backend, find_room_pid,
+                    [domain_helper:host_type(), muc_host(), Room]),
+    Pid ! stop_persistent_room_process,
+    WaitFun = fun() ->
+                  rpc(mim(), mod_muc_online_backend, find_room_pid,
+                      [domain_helper:host_type(), muc_host(), Room])
+              end,
+    wait_helper:wait_until(WaitFun, {error, not_found}),
+    ok.
+

big_tests/tests/muc_helper.erl

@@ -358,6 +358,9 @@ wait_for_room_count(ExpectedCounts) ->
 assert_room_event(EventName, RoomJid) ->
     assert_event(EventName, fun(#{count := 1, jid := Jid}) -> Jid =:= RoomJid end).
 
+assert_room_events(EventName, RoomJid, Count) ->
+    assert_event(EventName, fun(#{count := C, jid := Jid}) -> C =:= Count andalso Jid =:= RoomJid end).
+
 assert_event(EventName, F) ->
     instrument_helper:assert_one(EventName, labels(), F).
 

big_tests/tests/vcard_SUITE.erl

@@ -32,6 +32,7 @@
 -include_lib("escalus/include/escalus_xmlns.hrl").
 -include_lib("escalus/include/escalus.hrl").
 -include_lib("exml/include/exml.hrl").
+-include_lib("kernel/include/logger.hrl").
 
 %% Element CData
 -define(EL(Element, Name), exml_query:path(Element, [{element, Name}])).
@@ -1128,7 +1129,8 @@ get_jid_record(JID) ->
     jid:make_bare(User, Server).
 
 vcard_rpc(JID, Stanza) ->
-    Res = rpc(mim(), ejabberd_router, route, [JID, JID, Stanza]),
+    Acc = rpc(mim(), mongoose_acc, new, [JID, JID, Stanza, ?LOCATION]),
+    Res = rpc(mim(), mongoose_router, route, [Acc]),
     case Res of
         #{stanza := #{type := <<"set">>}} ->
             ok;

src/c2s/mongoose_c2s.erl

@@ -807,8 +807,7 @@ handle_stanza_from_client(#c2s_data{host_type = HostType}, HookParams, Acc, _) -
 
 -spec maybe_route(gen_hook:hook_fn_ret(mongoose_acc:t())) -> mongoose_acc:t().
 maybe_route({ok, Acc}) ->
-    {FromJid, ToJid, El} = mongoose_acc:packet(Acc),
-    ejabberd_router:route(FromJid, ToJid, Acc, El),
+    mongoose_router:route(Acc),
     Acc;
 maybe_route({stop, Acc}) ->
     Acc.
@@ -943,9 +942,8 @@ bounce_messages(StateData) ->
 
 -spec reroute_one(data(), mongoose_acc:t()) -> mongoose_acc:t().
 reroute_one(#c2s_data{sid = Sid}, Acc) ->
-    {From, To, _El} = mongoose_acc:packet(Acc),
     Acc2 = patch_acc_for_reroute(Acc, Sid),
-    ejabberd_router:route(From, To, Acc2).
+    mongoose_router:route(Acc2).
 
 -spec reroute_buffer(data(), [mongoose_acc:t()]) -> term().
 reroute_buffer(StateData = #c2s_data{host_type = HostType, jid = Jid}, Buffer) ->

src/component/mongoose_component_connection.erl

@@ -259,7 +259,7 @@ handle_stream_established(StateData, #xmlel{name = Name} = El) ->
     case IsStanza andalso IsValidFromJid andalso (error =/= ToJid) of
         true ->
             Acc = element_to_origin_accum(StateData, FromJid, ToJid, NewEl),
-            ejabberd_router:route(FromJid, ToJid, Acc, NewEl);
+            mongoose_router:route(Acc);
         false ->
             ?LOG_INFO(#{what => comp_bad_request,
                         text => <<"Not valid Name or error in FromJid or ToJid">>,
@@ -361,7 +361,8 @@ handle_route(StateData = #component_data{}, _, Acc) ->
             Packet2 = jlib:replace_from_to(From, To, Packet),
             send_xml(StateData, Packet2);
         deny ->
-            ejabberd_router:route_error_reply(To, From, Acc, mongoose_xmpp_errors:not_allowed())
+            {Acc1, Error} = jlib:make_error_reply(Acc, mongoose_xmpp_errors:not_allowed()),
+            mongoose_router:route(mongoose_acc:update(To, From, Error, Acc1))
     end,
     keep_state_and_data.
 

src/ejabberd_local.erl

@@ -111,12 +111,13 @@ process_iq(#iq{ xmlns = XMLNS } = IQ, Acc, From, To, _El) ->
             gen_iq_component:handle(IQHandler, Acc, From, To, IQ);
         [] ->
             T = <<"Local server does not implement this feature">>,
-            ejabberd_router:route_error_reply(To, From, Acc,
-                mongoose_xmpp_errors:feature_not_implemented(<<"en">>, T))
+            {Acc1, Error} = jlib:make_error_reply(Acc,
+                mongoose_xmpp_errors:feature_not_implemented(<<"en">>, T)),
+            mongoose_router:route(mongoose_acc:update(To, From, Error, Acc1))
     end;
 process_iq(_, Acc, From, To, El) ->
     {Acc1, Err} = jlib:make_error_reply(Acc, El, mongoose_xmpp_errors:bad_request()),
-    ejabberd_router:route(To, From, Acc1, Err).
+    mongoose_router:route(mongoose_acc:update(To, From, Err, Acc1)).
 
 -spec process_iq_reply(From :: jid:jid(),
                        To :: jid:jid(),
@@ -196,7 +197,7 @@ route_iq(From, To, Acc, #iq{type = Type} = IQ, Callback, Timeout)
                 false ->
                      jlib:iq_to_xml(IQ)
              end,
-    ejabberd_router:route(From, To, Acc, Packet).
+    mongoose_router:route(mongoose_acc:update(From, To, Packet, Acc)).
 
 -spec register_iq_response_handler(
            ID :: id(),
@@ -233,7 +234,7 @@ unregister_iq_handler(Domain, XMLNS) ->
                              El :: exml:element()) -> mongoose_acc:t().
 bounce_resource_packet(Acc, From, To, El) ->
     {Acc1, Err} = jlib:make_error_reply(Acc, El, mongoose_xmpp_errors:item_not_found()),
-    ejabberd_router:route(To, From, Acc1, Err),
+    mongoose_router:route(mongoose_acc:update(To, From, Err, Acc1)),
     Acc.
 
 -spec register_host(Host :: jid:server()) -> ok.