Merge pull request #4350 from badlop/define_keyword

New define_keyword option

Author: badlop

src/econf.erl

@@ -546,14 +546,10 @@ sip_uri() ->
 -spec host() -> yconf:validator(binary()).
 host() ->
     fun(Domain) ->
-	    Host = ejabberd_config:get_myname(),
 	    Hosts = ejabberd_config:get_option(hosts),
-	    Domain1 = (binary())(Domain),
-	    Domain2 = misc:expand_keyword(<<"@HOST@">>, Domain1, Host),
-	    Domain3 = (domain())(Domain2),
-	    case lists:member(Domain3, Hosts) of
-		true -> fail({route_conflict, Domain3});
-		false -> Domain3
+	    case lists:member(Domain, Hosts) of
+		true -> fail({route_conflict, Domain});
+		false -> Domain
 	    end
     end.
 

src/ejabberd_config.erl

@@ -38,6 +38,7 @@
 -export([dump/0, dump/1, convert_to_yaml/1, convert_to_yaml/2]).
 -export([callback_modules/1]).
 -export([set_option/2]).
+-export([get_defined_keywords/1, get_predefined_keywords/1, replace_keywords/2, replace_keywords/3]).
 
 %% Deprecated functions
 -export([get_option/2]).
@@ -342,12 +343,20 @@ env_binary_to_list(Application, Parameter) ->
             Other
     end.
 
+%% ejabberd_options calls this function when parsing options inside host_config
 -spec validators([atom()]) -> {econf:validators(), [atom()]}.
 validators(Disallowed) ->
+    Host = global,
+    DefinedKeywords = get_defined_keywords(Host),
+    validators(Disallowed, DefinedKeywords).
+
+%% validate/1 calls this function when parsing toplevel options
+-spec validators([atom()], [any()]) -> {econf:validators(), [atom()]}.
+validators(Disallowed, DK) ->
     Modules = callback_modules(all),
     Validators = lists:foldl(
 		   fun(M, Vs) ->
-			   maps:merge(Vs, validators(M, Disallowed))
+			   maps:merge(Vs, validators(M, Disallowed, DK))
 		   end, #{}, Modules),
     Required = lists:flatmap(
 		 fun(M) ->
@@ -404,6 +413,93 @@ format_error({error, {exception, Class, Reason, St}}) ->
 	"file attached and the following stacktrace included:~n** ~ts",
 	[misc:format_exception(2, Class, Reason, St)])).
 
+%% @format-begin
+
+replace_keywords(Host, Value) ->
+    Keywords = get_defined_keywords(Host) ++ get_predefined_keywords(Host),
+    replace_keywords(Host, Value, Keywords).
+
+replace_keywords(Host, List, Keywords) when is_list(List) ->
+    [replace_keywords(Host, Element, Keywords) || Element <- List];
+replace_keywords(_Host, Atom, Keywords) when is_atom(Atom) ->
+    Str = atom_to_list(Atom),
+    case Str == string:uppercase(Str) of
+        false ->
+            Atom;
+        true ->
+            MacroName = iolist_to_binary(Str),
+            case proplists:get_value(MacroName, Keywords) of
+                undefined ->
+                    Atom;
+                Replacement ->
+                    Replacement
+            end
+    end;
+replace_keywords(_Host, Binary, Keywords) when is_binary(Binary) ->
+    lists:foldl(fun ({Key, Replacement}, V) when is_binary(Replacement) ->
+                        misc:expand_keyword(<<"@", Key/binary, "@">>, V, Replacement);
+                    ({_, _}, V) ->
+                        V
+                end,
+                Binary,
+                Keywords);
+replace_keywords(Host, {Element1, Element2}, Keywords) ->
+    {Element1, replace_keywords(Host, Element2, Keywords)};
+replace_keywords(_Host, Value, _DK) ->
+    Value.
+
+get_defined_keywords(Host) ->
+    Tab = case get_tmp_config() of
+              undefined ->
+                  ejabberd_options;
+              T ->
+                  T
+          end,
+    get_defined_keywords(Tab, Host).
+
+get_defined_keywords(Tab, Host) ->
+    KeysHost =
+        case ets:lookup(Tab, {define_keyword, Host}) of
+            [{_, List}] ->
+                List;
+            _ ->
+                []
+        end,
+    KeysGlobal =
+        case Host /= global andalso ets:lookup(Tab, {define_keyword, global}) of
+            [{_, ListG}] ->
+                ListG;
+            _ ->
+                []
+        end,
+    %% Trying to get defined keywords in host_config when starting ejabberd,
+    %% the options are not yet stored in ets
+    KeysTemp = case not is_atom(Tab) andalso KeysHost == [] andalso KeysGlobal == [] of
+                   true ->
+		       get_defined_keywords_yaml_config(ets:lookup_element(Tab, {yaml_config, global}, 2));
+                   false ->
+                       []
+               end,
+    lists:reverse(KeysTemp ++ KeysGlobal ++ KeysHost).
+
+get_defined_keywords_yaml_config(Y) ->
+    [{erlang:atom_to_binary(KwAtom, latin1), KwValue}
+     || {KwAtom, KwValue} <- proplists:get_value(define_keyword, Y, [])].
+
+get_predefined_keywords(Host) ->
+    HostList = case Host of
+        global -> [];
+        _ -> [{<<"HOST">>, Host}]
+    end,
+    {ok, [[Home]]} = init:get_argument(home),
+    HostList ++
+    [{<<"HOME">>, list_to_binary(Home)},
+     {<<"SEMVER">>, ejabberd_option:version()},
+     {<<"VERSION">>,
+      misc:semver_to_xxyy(
+          ejabberd_option:version())}].
+%% @format-end
+
 %%%===================================================================
 %%% Internal functions
 %%%===================================================================
@@ -470,21 +566,37 @@ callback_modules(external) ->
 	      end
       end, beams(external));
 callback_modules(all) ->
-    callback_modules(local) ++ callback_modules(external).
+    lists_uniq(callback_modules(local) ++ callback_modules(external)).
+
+-ifdef(OTP_BELOW_25).
+lists_uniq(List) ->
+    lists:usort(List).
+-else.
+lists_uniq(List) ->
+    lists:uniq(List).
+-endif.
 
--spec validators(module(), [atom()]) -> econf:validators().
-validators(Mod, Disallowed) ->
+-spec validators(module(), [atom()], [any()]) -> econf:validators().
+validators(Mod, Disallowed, DK) ->
+    Keywords = DK ++ get_predefined_keywords(global),
     maps:from_list(
       lists:filtermap(
 	fun(O) ->
 		case lists:member(O, Disallowed) of
 		    true -> false;
 		    false ->
-			{true,
-			 try {O, Mod:opt_type(O)}
+			Type =
+			 try Mod:opt_type(O)
 			 catch _:_ ->
-				 {O, ejabberd_options:opt_type(O)}
-			 end}
+				 ejabberd_options:opt_type(O)
+			 end,
+                         TypeProcessed =
+                             econf:and_then(
+                                  fun(B) ->
+                                      replace_keywords(global, B, Keywords)
+                                  end,
+                              Type),
+			{true, {O, TypeProcessed}}
 		end
 	end, proplists:get_keys(Mod:options()))).
 
@@ -577,12 +689,13 @@ validate(Y1) ->
 		{ok, Y3} ->
 		    Hosts = proplists:get_value(hosts, Y3),
 		    Version = proplists:get_value(version, Y3, version()),
+		    DK = get_defined_keywords_yaml_config(Y3),
 		    create_tmp_config(),
 		    set_option(hosts, Hosts),
 		    set_option(host, hd(Hosts)),
 		    set_option(version, Version),
 		    set_option(yaml_config, Y3),
-		    {Validators, Required} = validators([]),
+		    {Validators, Required} = validators([], DK),
 		    Validator = econf:options(Validators,
 					      [{required, Required},
 					       unique]),

src/ejabberd_config_transformer.erl

@@ -128,6 +128,11 @@ transform(Host, s2s_use_starttls, required_trusted, Acc) ->
     Hosts = maps:get(remove_s2s_dialback, Acc, []),
     Acc1 = maps:put(remove_s2s_dialback, [Host|Hosts], Acc),
     {{true, {s2s_use_starttls, required}}, Acc1};
+transform(Host, define_macro, Macro, Acc) when is_binary(Host) ->
+    ?WARNING_MSG("The option 'define_macro' is not supported inside 'host_config'. "
+		 "Consequently those macro definitions for host '~ts' are unused: ~ts",
+		 [Host, io_lib:format("~p", [Macro])]),
+    {true, Acc};
 transform(_Host, _Opt, _Val, Acc) ->
     {true, Acc}.
 

src/ejabberd_http.erl

@@ -932,12 +932,7 @@ listen_opt_type(default_host) ->
 listen_opt_type(custom_headers) ->
     econf:map(
       econf:binary(),
-      econf:and_then(
-	econf:binary(),
-	fun(V) ->
-		misc:expand_keyword(<<"@VERSION@">>, V,
-				    ejabberd_option:version())
-	end)).
+      econf:binary()).
 
 listen_options() ->
     [{ciphers, undefined},

src/ejabberd_listener.erl

@@ -677,13 +677,21 @@ validator(M, T) ->
 		    true ->
 			 []
 		 end,
+    Keywords = ejabberd_config:get_defined_keywords(global) ++ ejabberd_config:get_predefined_keywords(global),
     Validator = maps:from_list(
 		  lists:map(
 		    fun(Opt) ->
-			    try {Opt, M:listen_opt_type(Opt)}
+			    Type = try M:listen_opt_type(Opt)
 			    catch _:_ when M /= ?MODULE ->
-				    {Opt, listen_opt_type(Opt)}
-			    end
+				    listen_opt_type(Opt)
+			    end,
+			    TypeProcessed =
+			        econf:and_then(
+			             fun(B) ->
+			                 ejabberd_config:replace_keywords(global, B, Keywords)
+			             end,
+			             Type),
+			    {Opt, TypeProcessed}
 		    end, proplists:get_keys(Options))),
     econf:options(
       Validator,

src/ejabberd_option.erl

@@ -38,6 +38,7 @@
 -export([cluster_nodes/0]).
 -export([default_db/0, default_db/1]).
 -export([default_ram_db/0, default_ram_db/1]).
+-export([define_keyword/0, define_keyword/1]).
 -export([define_macro/0]).
 -export([disable_sasl_mechanisms/0, disable_sasl_mechanisms/1]).
 -export([disable_sasl_scram_downgrade_protection/0, disable_sasl_scram_downgrade_protection/1]).
@@ -372,6 +373,13 @@ default_ram_db() ->
 default_ram_db(Host) ->
     ejabberd_config:get_option({default_ram_db, Host}).
 
+-spec define_keyword() -> any().
+define_keyword() ->
+    define_keyword(global).
+-spec define_keyword(global | binary()) -> any().
+define_keyword(Host) ->
+    ejabberd_config:get_option({define_keyword, Host}).
+
 -spec define_macro() -> any().
 define_macro() ->
     ejabberd_config:get_option({define_macro, global}).

src/ejabberd_options.erl

@@ -112,14 +112,7 @@ opt_type(cache_missed) ->
 opt_type(cache_size) ->
     econf:pos_int(infinity);
 opt_type(captcha_cmd) ->
-    econf:and_then(
-	econf:binary(),
-	fun(V) ->
-		V2 = misc:expand_keyword(<<"@SEMVER@">>, V,
-				    ejabberd_option:version()),
-		misc:expand_keyword(<<"@VERSION@">>, V2,
-				    misc:semver_to_xxyy(ejabberd_option:version()))
-	end);
+    econf:binary();
 opt_type(captcha_host) ->
     econf:binary();
 opt_type(captcha_limit) ->
@@ -138,6 +131,8 @@ opt_type(default_db) ->
     econf:enum([mnesia, sql]);
 opt_type(default_ram_db) ->
     econf:enum([mnesia, sql, redis]);
+opt_type(define_keyword) ->
+    econf:map(econf:binary(), econf:any(), [unique]);
 opt_type(define_macro) ->
     econf:map(econf:binary(), econf:any(), [unique]);
 opt_type(disable_sasl_scram_downgrade_protection) ->
@@ -491,7 +486,6 @@ opt_type(jwt_auth_only_rule) ->
 		    {c2s_protocol_options, undefined | binary()} |
                     {s2s_ciphers, undefined | binary()} |
                     {c2s_ciphers, undefined | binary()} |
-		    {captcha_cmd, undefined | binary()} |
 		    {websocket_origin, [binary()]} |
 		    {disable_sasl_mechanisms, [binary()]} |
 		    {s2s_zlib, boolean()} |
@@ -510,6 +504,7 @@ opt_type(jwt_auth_only_rule) ->
 		    {jwt_key, jose_jwk:key() | undefined} |
 		    {append_host_config, [{binary(), any()}]} |
 		    {host_config, [{binary(), any()}]} |
+		    {define_keyword, any()} |
 		    {define_macro, any()} |
 		    {include_config_file, any()} |
 		    {atom(), any()}].
@@ -567,6 +562,7 @@ options() ->
      {certfiles, undefined},
      {cluster_backend, mnesia},
      {cluster_nodes, []},
+     {define_keyword, []},
      {define_macro, []},
      {disable_sasl_scram_downgrade_protection, false},
      {disable_sasl_mechanisms, []},

src/ejabberd_options_doc.erl

@@ -534,18 +534,26 @@ doc() ->
             ?T("A list of Erlang nodes to connect on ejabberd startup. "
                "This option is mostly intended for ejabberd customization "
                "and sophisticated setups. The default value is an empty list.")}},
+     {define_keyword,
+      #{value => "{NAME: Value}",
+        desc =>
+            ?T("Allows to define configuration "
+                "_`../configuration/file-format.md#keywords|keywords`_. "),
+        example =>
+            ["define_keyword:",
+             "  SQL_USERNAME: \"eja.global\"",
+             "",
+             "host_config:",
+             "  localhost:",
+             "    define_keyword:",
+             "      SQL_USERNAME: \"eja.localhost\"",
+             "",
+             "sql_username: \"prefix.@SQL_USERNAME@\""]}},
      {define_macro,
-      #{value => "{MacroName: MacroValue}",
-        desc =>
-            ?T("Defines a "
-               "_`../configuration/file-format.md#macros-in-configuration-file|macro`_. "
-               "The value can be any valid arbitrary "
-               "YAML value. For convenience, it's recommended to define "
-               "a 'MacroName' in capital letters. Duplicated macros are not allowed. "
-               "Macros are processed after additional configuration files have "
-               "been included, so it is possible to use macros that are defined "
-               "in configuration files included before the usage. "
-               "It is possible to use a 'MacroValue' in the definition of another macro."),
+      #{value => "{NAME: Value}",
+        desc =>
+            ?T("Allows to define configuration "
+                "_`../configuration/file-format.md#macros|macros`_. "),
         example =>
             ["define_macro:",
              "  DEBUG: debug",

src/gen_mod.erl

@@ -551,10 +551,10 @@ validator(Host, Module, Opts) ->
 		  lists:mapfoldl(
 		    fun({Opt, Def}, {DAcc1, VAcc1}) ->
 			    {[], {DAcc1#{Opt => Def},
-				  VAcc1#{Opt => get_opt_type(Module, M, Opt)}}};
+				  VAcc1#{Opt => get_opt_type(Host, Module, M, Opt)}}};
 		       (Opt, {DAcc1, VAcc1}) ->
 			    {[Opt], {DAcc1,
-				     VAcc1#{Opt => get_opt_type(Module, M, Opt)}}}
+				     VAcc1#{Opt => get_opt_type(Host, Module, M, Opt)}}}
 		    end, {DAcc, VAcc}, DefOpts)
 	  end, {#{}, #{}}, get_defaults(Host, Module, Opts)),
     econf:and_then(
@@ -604,11 +604,16 @@ get_defaults(Host, Module, Opts) ->
 	       false
        end, DefaultOpts)].
 
--spec get_opt_type(module(), module(), atom()) -> econf:validator().
-get_opt_type(Mod, SubMod, Opt) ->
-    try SubMod:mod_opt_type(Opt)
+-spec get_opt_type(binary(), module(), module(), atom()) -> econf:validator().
+get_opt_type(Host, Mod, SubMod, Opt) ->
+    Type = try SubMod:mod_opt_type(Opt)
     catch _:_ -> Mod:mod_opt_type(Opt)
-    end.
+    end,
+    econf:and_then(
+      fun(B) ->
+              ejabberd_config:replace_keywords(Host, B)
+      end,
+      Type).
 
 -spec sort_modules(binary(), [{module(), opts()}]) -> {ok, [{module(), opts(), integer()}]}.
 sort_modules(Host, ModOpts) ->