support multiple backends by specifying a backend_ref in config

proger · proger · commit 2a9074f69e7f · 2020-06-30T13:02:41.000+03:00
diff --git a/README.md b/README.md
@@ -67,13 +67,24 @@ modules:
         type: apns
         # make sure this pem file contains only one(!) certificate + key pair
         certfile: "/etc/ssl/private/apns_example_app.pem"
-        # sandbox is for testing
         gateway: "gateway.push.apple.com"
-        #gateway: "gateway.sandbox.push.apple.com"
+      -
+        type: apns
+        # you can add more backends of each type by specifying backend_ref with unique names
+        backend_ref: "sandbox"
+        # make sure this pem file contains only one(!) certificate + key pair
+        certfile: "/etc/ssl/private/apns_example_app_sandbox.pem"
+        gateway: "gateway.sandbox.push.apple.com"
       -
         type: fcm
         gateway: "https://fcm.googleapis.com/fcm/send"
         api_key: "API_KEY"
+      -
+        type: fcm
+        # you can add more backends of each type by specifying backend_ref with unique names
+        backend_ref: "fcm2"
+        gateway: "https://fcm.googleapis.com/fcm/send"
+        api_key: "API_KEY_2"
 ```
 
 ## Client Applications
@@ -94,15 +105,34 @@ Example (note, `to='localhost'` contain the your user's server name):
            node='register-push-apns'
            action='execute'>
     <x xmlns='jabber:x:data' type='submit'>
-      <field
-      var='token'>
+      <field var='token'>
         <value>urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6uro=</value>
       </field>
     </x>
   </command>
 </iq>
 ```
 
+You need to specify a `backend_ref` field to route your subscription to a particular backend:
+
+```xml
+<iq type='set' to='localhost' id='randomrandomrequestid2'>
+  <command xmlns='http://jabber.org/protocol/commands'
+           node='register-push-apns'
+           action='execute'>
+    <x xmlns='jabber:x:data' type='submit'>
+      <field var='backend_ref'>
+        <value>sandbox</value>
+      </field>
+      <field var='token'>
+        <value>urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6uro=</value>
+      </field>
+    </x>
+  </command>
+</iq>
+```
+
+
 See [client.py](client.py) for a reference client.
 
 You can use `babababababababababababababababababababababababababababababababa` (`urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6uro=` in base64) token to test APNS.
diff --git a/include/mod_pushoff.hrl b/include/mod_pushoff.hrl
@@ -1,6 +1,6 @@
 -type bare_jid() :: {binary(), binary()}.
--type backend_type() :: apns | fcm.
--type backend_id() :: {binary(), backend_type()}.
+-type backend_ref() :: apns | fcm | {apns, binary()} | {fcm, binary()}.
+-type backend_id() :: {binary(), backend_ref()}.
 
 -record(pushoff_registration, {bare_jid :: bare_jid(),
                                token :: binary(),
diff --git a/src/mod_pushoff.erl b/src/mod_pushoff.erl
@@ -55,7 +55,7 @@
 -type fcm_config() :: #fcm_config{}.
 
 -record(backend_config,
-        {type :: backend_type(),
+        {ref :: backend_ref(),
          config :: apns_config() | fcm_config()}).
 
 -type backend_config() :: #backend_config{}.
@@ -145,18 +145,34 @@ adhoc_local_commands(Acc, _From, _To, _Request) ->
 
 
 adhoc_perform_action(<<"register-push-apns">>, #jid{lserver = LServer} = From, XData) ->
-    case xmpp_util:get_xdata_values(<<"token">>, XData) of
-        [Base64Token] ->
-            case catch base64:decode(Base64Token) of
-                {'EXIT', _} -> {error, xmpp:err_bad_request()};
-                Token -> mod_pushoff_mnesia:register_client(From, {LServer, apns}, Token)
-            end;
-        _ -> {error, xmpp:err_bad_request()}
+    BackendRef = case xmpp_util:get_xdata_values(<<"backend_ref">>, XData) of
+        [Key] -> {apns, Key};
+        _ -> apns
+    end,
+    case validate_backend_ref(LServer, BackendRef) of
+        {error, E} -> {error, E};
+        {ok, BackendRef} ->
+            case xmpp_util:get_xdata_values(<<"token">>, XData) of
+                [Base64Token] ->
+                    case catch base64:decode(Base64Token) of
+                        {'EXIT', _} -> {error, xmpp:err_bad_request()};
+                        Token -> mod_pushoff_mnesia:register_client(From, {LServer, BackendRef}, Token)
+                    end;
+                _ -> {error, xmpp:err_bad_request()}
+            end
     end;
 adhoc_perform_action(<<"register-push-fcm">>, #jid{lserver = LServer} = From, XData) ->
-    case xmpp_util:get_xdata_values(<<"token">>, XData) of
-        [AsciiToken] -> mod_pushoff_mnesia:register_client(From, {LServer, fcm}, AsciiToken);
-        _ -> {error, xmpp:err_bad_request()}
+    BackendRef = case xmpp_util:get_xdata_values(<<"backend_ref">>, XData) of
+        [Key] -> {fcm, Key};
+        _ -> fcm
+    end,
+    case validate_backend_ref(LServer, BackendRef) of
+        {error, E} -> {error, E};
+        {ok, BackendRef} ->
+            case xmpp_util:get_xdata_values(<<"token">>, XData) of
+                [AsciiToken] -> mod_pushoff_mnesia:register_client(From, {LServer, BackendRef}, AsciiToken);
+                _ -> {error, xmpp:err_bad_request()}
+            end
     end;
 adhoc_perform_action(<<"unregister-push">>, From, _) ->
     mod_pushoff_mnesia:unregister_client(From, undefined);
@@ -193,10 +209,10 @@ stop(Host) ->
     ok = ejabberd_hooks:delete(remove_user, Host, ?MODULE, remove_user, 50),
 
     [begin
-         Worker = backend_worker({Host, Type}),
+         Worker = backend_worker({Host, Ref}),
          supervisor:terminate_child(ejabberd_gen_mod_sup, Worker),
          supervisor:delete_child(ejabberd_gen_mod_sup, Worker)
-     end || #backend_config{type=Type} <- backend_configs(Host)],
+     end || #backend_config{ref=Ref} <- backend_configs(Host)],
     ok.
 
 depends(_, _) ->
@@ -205,27 +221,33 @@ depends(_, _) ->
 mod_opt_type(backends) -> fun ?MODULE:parse_backends/1;
 mod_opt_type(_) -> [backends].
 
+validate_backend_ref(Host, Ref) ->
+    case [R || #backend_config{ref=R} <- backend_configs(Host), R == Ref] of
+        [R] -> {ok, R};
+        _ -> {error, xmpp:err_bad_request()}
+    end.
+
+backend_ref(apns, undefined) -> apns;
+backend_ref(fcm, undefined) -> fcm;
+backend_ref(apns, K) -> {apns, K};
+backend_ref(fcm, K) -> {fcm, K}.
+
+backend_type({Type, _}) -> Type;
+backend_type(Type) -> Type.
+
 parse_backends(Plists) ->
     [parse_backend(Plist) || Plist <- Plists].
 
 parse_backend(Opts) ->
-    RawType = proplists:get_value(type, Opts),
-    Type =
-        case lists:member(RawType, [apns, fcm]) of
-            true -> RawType
-        end,
-    Gateway = proplists:get_value(gateway, Opts),
-    CertFile = proplists:get_value(certfile, Opts),
-    ApiKey = proplists:get_value(api_key, Opts),
-
+    Ref = backend_ref(proplists:get_value(type, Opts), proplists:get_value(backend_ref, Opts)),
     #backend_config{
-       type = Type,
+       ref = Ref,
        config =
-           case Type of
+           case backend_type(Ref) of
                apns ->
-                   #apns_config{certfile = CertFile, gateway = Gateway};
+                   #apns_config{certfile = proplists:get_value(certfile, Opts), gateway = proplists:get_value(gateway, Opts)};
                fcm ->
-                   #fcm_config{gateway = Gateway, api_key = ApiKey}
+                   #fcm_config{gateway = proplists:get_value(gateway, Opts), api_key = proplists:get_value(api_key, Opts)}
            end
       }.
 
@@ -235,32 +257,33 @@ parse_backend(Opts) ->
 
 -spec(backend_worker(backend_id()) -> atom()).
 
-backend_worker({Host, Type}) -> gen_mod:get_module_proc(Host, Type).
+backend_worker({Host, {T, R}}) -> gen_mod:get_module_proc(Host, binary_to_atom(<<(erlang:atom_to_binary(T, latin1))/binary, "_", R/binary>>, latin1));
+backend_worker({Host, Ref}) -> gen_mod:get_module_proc(Host, Ref).
 
 backend_configs(Host) ->
     gen_mod:get_module_opt(Host, ?MODULE, backends,
                            fun(O) when is_list(O) -> O end, []).
 
+backend_module(apns) -> ?MODULE_APNS;
+backend_module(fcm) -> ?MODULE_FCM.
+
 -spec(start_worker(Host :: binary(), Backend :: backend_config()) -> ok).
 
-start_worker(Host, #backend_config{type = Type, config = TypeConfig}) ->
-    Module = proplists:get_value(Type, [{apns, ?MODULE_APNS}, {fcm, ?MODULE_FCM}]),
-    Worker = backend_worker({Host, Type}),
-    BackendSpec = 
-    case Type of
+start_worker(Host, #backend_config{ref = Ref, config = Config}) ->
+    Worker = backend_worker({Host, Ref}),
+    BackendSpec =
+    case backend_type(Ref) of
         apns ->
                   {Worker,
                    {gen_server, start_link,
-                    [{local, Worker}, Module,
-                     %% TODO: mb i should send one record like BackendConfig#backend_config.config and parse it in each module
-                     [TypeConfig#apns_config.certfile, TypeConfig#apns_config.gateway], []]},
+                    [{local, Worker}, backend_module(backend_type(Ref)),
+                     [Config#apns_config.certfile, Config#apns_config.gateway], []]},
                    permanent, 1000, worker, [?MODULE]};
         fcm ->
                   {Worker,
                    {gen_server, start_link,
-                    [{local, Worker}, Module,
-                     %% TODO: mb i should send one record like BackendConfig#backend_config.config and parse it in each module
-                     [TypeConfig#fcm_config.gateway, TypeConfig#fcm_config.api_key], []]},
+                    [{local, Worker}, backend_module(backend_type(Ref)),
+                     [Config#fcm_config.gateway, Config#fcm_config.api_key], []]},
                    permanent, 1000, worker, [?MODULE]}
     end,
 
