yuanbiao
/
emqx
1
0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branches 'origin/release-50' and 'origin/master' into release-51

This commit is contained in:
Zaiming (Stone) Shi 2023-05-30 07:54:34 +02:00
parent 2a46d986bf 67e182e0c9
commit 747eb6fcff
130 changed files with 354 additions and 9058 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Makefile
View File

@ -104,7 +104,7 @@ APPS=$(shell $(SCRIPTS)/find-apps.sh)
.PHONY: $(APPS:%=%-ct)
define gen-app-ct-target
$1-ct: $(REBAR) merge-config
$1-ct: $(REBAR) merge-config clean-test-cluster-config
$(eval SUITES := $(shell $(SCRIPTS)/find-suites.sh $1))
ifneq ($(SUITES),)
@ENABLE_COVER_COMPILE=1 $(REBAR) ct -c -v \
@ -127,7 +127,7 @@ endef
$(foreach app,$(APPS),$(eval $(call gen-app-prop-target,$(app))))
.PHONY: ct-suite
ct-suite: $(REBAR) merge-config
ct-suite: $(REBAR) merge-config clean-test-cluster-config
ifneq ($(TESTCASE),)
ifneq ($(GROUP),)
$(REBAR) ct -v --readable=$(CT_READABLE) --name $(CT_NODE_NAME) --suite $(SUITE) --case $(TESTCASE) --group $(GROUP)
@ -294,3 +294,7 @@ fmt: $(REBAR)
@$(SCRIPTS)/erlfmt -w '{apps,lib-ee}/*/{src,include,test}/**/*.{erl,hrl,app.src}'
@$(SCRIPTS)/erlfmt -w 'rebar.config.erl'
@mix format
.PHONY: clean-test-cluster-config
clean-test-cluster-config:
@rm -f apps/emqx_conf/data/configs/cluster.hocon || true

2
apps/emqx/test/emqx_authentication_SUITE.erl
View File

@ -98,6 +98,8 @@ init_per_suite(Config) ->
LogLevel = emqx_logger:get_primary_log_level(),
ok = emqx_logger:set_log_level(debug),
application:set_env(ekka, strict_mode, true),
emqx_config:erase_all(),
emqx_common_test_helpers:stop_apps([]),
emqx_common_test_helpers:boot_modules(all),
emqx_common_test_helpers:start_apps([]),
[{log_level, LogLevel} | Config].

27
apps/emqx_bridge/src/emqx_bridge.erl
View File

@ -227,9 +227,13 @@ post_config_update(_, _Req, NewConf, OldConf, _AppEnv) ->
diff_confs(NewConf, OldConf),
%% The config update will be failed if any task in `perform_bridge_changes` failed.
Result = perform_bridge_changes([
{fun emqx_bridge_resource:remove/4, Removed},
{fun emqx_bridge_resource:create/4, Added},
{fun emqx_bridge_resource:update/4, Updated}
#{action => fun emqx_bridge_resource:remove/4, data => Removed},
#{
action => fun emqx_bridge_resource:create/4,
data => Added,
on_exception_fn => fun emqx_bridge_resource:remove/4
},
#{action => fun emqx_bridge_resource:update/4, data => Updated}
]),
ok = unload_hook(),
ok = load_hook(NewConf),
@ -345,7 +349,8 @@ perform_bridge_changes(Tasks) ->
perform_bridge_changes([], Result) ->
Result;
perform_bridge_changes([{Action, MapConfs} | Tasks], Result0) ->
perform_bridge_changes([#{action := Action, data := MapConfs} = Task | Tasks], Result0) ->
OnException = maps:get(on_exception_fn, Task, fun(_Type, _Name, _Conf, _Opts) -> ok end),
Result = maps:fold(
fun
({_Type, _Name}, _Conf, {error, Reason}) ->
@ -359,9 +364,21 @@ perform_bridge_changes([{Action, MapConfs} | Tasks], Result0) ->
end;
({Type, Name}, Conf, _) ->
ResOpts = emqx_resource:fetch_creation_opts(Conf),
case Action(Type, Name, Conf, ResOpts) of
try Action(Type, Name, Conf, ResOpts) of
{error, Reason} -> {error, Reason};
Return -> Return
catch
Kind:Error:Stacktrace ->
?SLOG(error, #{
msg => "bridge_config_update_exception",
kind => Kind,
error => Error,
type => Type,
name => Name,
stacktrace => Stacktrace
}),
OnException(Type, Name, Conf, ResOpts),
erlang:raise(Kind, Error, Stacktrace)
end
end,
Result0,

2
apps/emqx_bridge_kafka/src/emqx_bridge_kafka.app.src
View File

@ -1,6 +1,6 @@
{application, emqx_bridge_kafka, [
{description, "EMQX Enterprise Kafka Bridge"},
{vsn, "0.1.2"},
{vsn, "0.1.3"},
{registered, [emqx_bridge_kafka_consumer_sup]},
{applications, [
kernel,

58
apps/emqx_bridge_kafka/src/emqx_bridge_kafka_impl_consumer.erl
View File

@ -101,6 +101,10 @@
" the connection parameters."
).
%% Allocatable resources
-define(kafka_client_id, kafka_client_id).
-define(kafka_subscriber_id, kafka_subscriber_id).
%%-------------------------------------------------------------------------------------
%% `emqx_resource' API
%%-------------------------------------------------------------------------------------
@ -140,6 +144,7 @@ on_start(ResourceId, Config) ->
Auth -> [{sasl, emqx_bridge_kafka_impl:sasl(Auth)}]
end,
ClientOpts = add_ssl_opts(ClientOpts0, SSL),
ok = emqx_resource:allocate_resource(ResourceId, ?kafka_client_id, ClientID),
case brod:start_client(BootstrapHosts, ClientID, ClientOpts) of
ok ->
?tp(
@ -163,7 +168,21 @@ on_start(ResourceId, Config) ->
start_consumer(Config, ResourceId, ClientID).
-spec on_stop(resource_id(), state()) -> ok.
on_stop(_ResourceID, State) ->
on_stop(ResourceId, _State = undefined) ->
case emqx_resource:get_allocated_resources(ResourceId) of
#{?kafka_client_id := ClientID, ?kafka_subscriber_id := SubscriberId} ->
stop_subscriber(SubscriberId),
stop_client(ClientID),
?tp(kafka_consumer_subcriber_and_client_stopped, #{}),
ok;
#{?kafka_client_id := ClientID} ->
stop_client(ClientID),
?tp(kafka_consumer_just_client_stopped, #{}),
ok;
_ ->
ok
end;
on_stop(_ResourceId, State) ->
#{
subscriber_id := SubscriberId,
kafka_client_id := ClientID
@ -333,6 +352,9 @@ start_consumer(Config, ResourceId, ClientID) ->
%% spawns one worker for each assigned topic-partition
%% automatically, so we should not spawn duplicate workers.
SubscriberId = make_subscriber_id(BridgeName),
?tp(kafka_consumer_about_to_start_subscriber, #{}),
ok = emqx_resource:allocate_resource(ResourceId, ?kafka_subscriber_id, SubscriberId),
?tp(kafka_consumer_subscriber_allocated, #{}),
case emqx_bridge_kafka_consumer_sup:start_child(SubscriberId, GroupSubscriberConfig) of
{ok, _ConsumerPid} ->
?tp(
@ -359,7 +381,13 @@ start_consumer(Config, ResourceId, ClientID) ->
stop_subscriber(SubscriberId) ->
_ = log_when_error(
fun() ->
emqx_bridge_kafka_consumer_sup:ensure_child_deleted(SubscriberId)
try
emqx_bridge_kafka_consumer_sup:ensure_child_deleted(SubscriberId)
catch
exit:{noproc, _} ->
%% may happen when node is shutting down
ok
end
end,
#{
msg => "failed_to_delete_kafka_subscriber",
@ -443,16 +471,22 @@ do_get_topic_status(ClientID, KafkaTopic, SubscriberId, NPartitions) ->
end.
are_subscriber_workers_alive(SubscriberId) ->
Children = supervisor:which_children(emqx_bridge_kafka_consumer_sup),
case lists:keyfind(SubscriberId, 1, Children) of
false ->
false;
{_, Pid, _, _} ->
Workers = brod_group_subscriber_v2:get_workers(Pid),
%% we can't enforce the number of partitions on a single
%% node, as the group might be spread across an emqx
%% cluster.
lists:all(fun is_process_alive/1, maps:values(Workers))
try
Children = supervisor:which_children(emqx_bridge_kafka_consumer_sup),
case lists:keyfind(SubscriberId, 1, Children) of
false ->
false;
{_, Pid, _, _} ->
Workers = brod_group_subscriber_v2:get_workers(Pid),
%% we can't enforce the number of partitions on a single
%% node, as the group might be spread across an emqx
%% cluster.
lists:all(fun is_process_alive/1, maps:values(Workers))
end
catch
exit:{shutdown, _} ->
%% may happen if node is shutting down
false
end.
log_when_error(Fun, Log) ->

85
apps/emqx_bridge_kafka/src/emqx_bridge_kafka_impl_producer.erl
View File

@ -23,6 +23,11 @@
-include_lib("emqx/include/logger.hrl").
%% Allocatable resources
-define(kafka_resource_id, kafka_resource_id).
-define(kafka_client_id, kafka_client_id).
-define(kafka_producers, kafka_producers).
%% TODO: rename this to `kafka_producer' after alias support is added
%% to hocon; keeping this as just `kafka' for backwards compatibility.
-define(BRIDGE_TYPE, kafka).
@ -46,9 +51,11 @@ on_start(InstId, Config) ->
} = Config,
BridgeType = ?BRIDGE_TYPE,
ResourceId = emqx_bridge_resource:resource_id(BridgeType, BridgeName),
ok = emqx_resource:allocate_resource(InstId, ?kafka_resource_id, ResourceId),
_ = maybe_install_wolff_telemetry_handlers(ResourceId),
Hosts = emqx_bridge_kafka_impl:hosts(Hosts0),
ClientId = emqx_bridge_kafka_impl:make_client_id(BridgeType, BridgeName),
ok = emqx_resource:allocate_resource(InstId, ?kafka_client_id, ClientId),
ClientConfig = #{
min_metadata_refresh_interval => MinMetaRefreshInterval,
connect_timeout => ConnTimeout,
@ -86,6 +93,7 @@ on_start(InstId, Config) ->
WolffProducerConfig = producers_config(BridgeName, ClientId, KafkaConfig, IsDryRun),
case wolff:ensure_supervised_producers(ClientId, KafkaTopic, WolffProducerConfig) of
{ok, Producers} ->
ok = emqx_resource:allocate_resource(InstId, ?kafka_producers, Producers),
{ok, #{
message_template => compile_message_template(MessageTemplate),
client_id => ClientId,
@ -120,28 +128,63 @@ on_start(InstId, Config) ->
)
end.
on_stop(_InstanceID, #{client_id := ClientID, producers := Producers, resource_id := ResourceID}) ->
_ = with_log_at_error(
fun() -> wolff:stop_and_delete_supervised_producers(Producers) end,
on_stop(InstanceId, _State) ->
case emqx_resource:get_allocated_resources(InstanceId) of
#{
msg => "failed_to_delete_kafka_producer",
client_id => ClientID
}
),
_ = with_log_at_error(
fun() -> wolff:stop_and_delete_supervised_client(ClientID) end,
#{
msg => "failed_to_delete_kafka_client",
client_id => ClientID
}
),
with_log_at_error(
fun() -> uninstall_telemetry_handlers(ResourceID) end,
#{
msg => "failed_to_uninstall_telemetry_handlers",
client_id => ClientID
}
).
?kafka_client_id := ClientId,
?kafka_producers := Producers,
?kafka_resource_id := ResourceId
} ->
_ = with_log_at_error(
fun() -> wolff:stop_and_delete_supervised_producers(Producers) end,
#{
msg => "failed_to_delete_kafka_producer",
client_id => ClientId
}
),
_ = with_log_at_error(
fun() -> wolff:stop_and_delete_supervised_client(ClientId) end,
#{
msg => "failed_to_delete_kafka_client",
client_id => ClientId
}
),
_ = with_log_at_error(
fun() -> uninstall_telemetry_handlers(ResourceId) end,
#{
msg => "failed_to_uninstall_telemetry_handlers",
resource_id => ResourceId
}
),
ok;
#{?kafka_client_id := ClientId, ?kafka_resource_id := ResourceId} ->
_ = with_log_at_error(
fun() -> wolff:stop_and_delete_supervised_client(ClientId) end,
#{
msg => "failed_to_delete_kafka_client",
client_id => ClientId
}
),
_ = with_log_at_error(
fun() -> uninstall_telemetry_handlers(ResourceId) end,
#{
msg => "failed_to_uninstall_telemetry_handlers",
resource_id => ResourceId
}
),
ok;
#{?kafka_resource_id := ResourceId} ->
_ = with_log_at_error(
fun() -> uninstall_telemetry_handlers(ResourceId) end,
#{
msg => "failed_to_uninstall_telemetry_handlers",
resource_id => ResourceId
}
),
ok;
_ ->
ok
end.
on_query(
_InstId,

138
apps/emqx_bridge_kafka/test/emqx_bridge_kafka_impl_consumer_SUITE.erl
View File

@ -59,7 +59,9 @@ only_once_tests() ->
t_cluster_group,
t_node_joins_existing_cluster,
t_cluster_node_down,
t_multiple_topic_mappings
t_multiple_topic_mappings,
t_resource_manager_crash_after_subscriber_started,
t_resource_manager_crash_before_subscriber_started
].
init_per_suite(Config) ->
@ -333,6 +335,7 @@ init_per_testcase(TestCase, Config) ->
common_init_per_testcase(TestCase, Config0) ->
ct:timetrap(timer:seconds(60)),
delete_all_bridges(),
emqx_config:delete_override_conf_files(),
KafkaTopic =
<<
(atom_to_binary(TestCase))/binary,
@ -1117,6 +1120,24 @@ stop_async_publisher(Pid) ->
end,
ok.
kill_resource_managers() ->
ct:pal("gonna kill resource managers"),
lists:foreach(
fun({_, Pid, _, _}) ->
ct:pal("terminating resource manager ~p", [Pid]),
Ref = monitor(process, Pid),
exit(Pid, kill),
receive
{'DOWN', Ref, process, Pid, killed} ->
ok
after 500 ->
ct:fail("pid ~p didn't die!", [Pid])
end,
ok
end,
supervisor:which_children(emqx_resource_manager_sup)
).
%%------------------------------------------------------------------------------
%% Testcases
%%------------------------------------------------------------------------------
@ -2019,3 +2040,118 @@ t_begin_offset_earliest(Config) ->
end
),
ok.
t_resource_manager_crash_after_subscriber_started(Config) ->
?check_trace(
begin
?force_ordering(
#{?snk_kind := kafka_consumer_subscriber_allocated},
#{?snk_kind := will_kill_resource_manager}
),
?force_ordering(
#{?snk_kind := resource_manager_killed},
#{?snk_kind := kafka_consumer_subscriber_started}
),
spawn_link(fun() ->
?tp(will_kill_resource_manager, #{}),
kill_resource_managers(),
?tp(resource_manager_killed, #{}),
ok
end),
%% even if the resource manager is dead, we can still
%% clear the allocated resources.
%% We avoid asserting only the `config_update_crashed'
%% error here because there's a race condition (just a
%% problem for the test assertion below) in which the
%% `emqx_resource_manager:create/5' call returns a failure
%% (not checked) and then `lookup' in that module is
%% delayed enough so that the manager supervisor has time
%% to restart the manager process and for the latter to
%% startup successfully. Occurs frequently in CI...
{Res, {ok, _}} =
?wait_async_action(
create_bridge(Config),
#{?snk_kind := kafka_consumer_subcriber_and_client_stopped},
10_000
),
case Res of
{error, {config_update_crashed, {killed, _}}} ->
ok;
{ok, _} ->
%% the new manager may have had time to startup
%% before the resource status cache is read...
ok;
_ ->
ct:fail("unexpected result: ~p", [Res])
end,
?assertMatch({ok, _}, delete_bridge(Config)),
?retry(
_Sleep = 50,
_Attempts = 50,
?assertEqual([], supervisor:which_children(emqx_bridge_kafka_consumer_sup))
),
ok
end,
[]
),
ok.
t_resource_manager_crash_before_subscriber_started(Config) ->
?check_trace(
begin
?force_ordering(
#{?snk_kind := kafka_consumer_client_started},
#{?snk_kind := will_kill_resource_manager}
),
?force_ordering(
#{?snk_kind := resource_manager_killed},
#{?snk_kind := kafka_consumer_about_to_start_subscriber}
),
spawn_link(fun() ->
?tp(will_kill_resource_manager, #{}),
kill_resource_managers(),
?tp(resource_manager_killed, #{}),
ok
end),
%% even if the resource manager is dead, we can still
%% clear the allocated resources.
%% We avoid asserting only the `config_update_crashed'
%% error here because there's a race condition (just a
%% problem for the test assertion below) in which the
%% `emqx_resource_manager:create/5' call returns a failure
%% (not checked) and then `lookup' in that module is
%% delayed enough so that the manager supervisor has time
%% to restart the manager process and for the latter to
%% startup successfully. Occurs frequently in CI...
{Res, {ok, _}} =
?wait_async_action(
create_bridge(Config),
#{?snk_kind := kafka_consumer_just_client_stopped},
10_000
),
case Res of
{error, {config_update_crashed, {killed, _}}} ->
ok;
{ok, _} ->
%% the new manager may have had time to startup
%% before the resource status cache is read...
ok;
_ ->
ct:fail("unexpected result: ~p", [Res])
end,
?assertMatch({ok, _}, delete_bridge(Config)),
?retry(
_Sleep = 50,
_Attempts = 50,
?assertEqual([], supervisor:which_children(emqx_bridge_kafka_consumer_sup))
),
ok
end,
[]
),
ok.

2
apps/emqx_bridge_kafka/test/emqx_bridge_kafka_impl_producer_SUITE.erl
View File

@ -446,6 +446,8 @@ t_failed_creation_then_fix(Config) ->
?assertMatch(#kafka_message{key = BinTime}, KafkaMsg),
%% TODO: refactor those into init/end per testcase
ok = ?PRODUCER:on_stop(ResourceId, State),
?assertEqual([], supervisor:which_children(wolff_client_sup)),
?assertEqual([], supervisor:which_children(wolff_producers_sup)),
ok = emqx_bridge_resource:remove(BridgeId),
delete_all_bridges(),
ok.

12
apps/emqx_bridge_pulsar/src/emqx_bridge_pulsar_impl_producer.erl
View File

@ -60,6 +60,10 @@
sync_timeout := emqx_schema:duration_ms()
}.
%% Allocatable resources
-define(pulsar_client_id, pulsar_client_id).
-define(pulsar_producers, pulsar_producers).
%%-------------------------------------------------------------------------------------
%% `emqx_resource' API
%%-------------------------------------------------------------------------------------
@ -81,7 +85,7 @@ on_start(InstanceId, Config) ->
} = Config,
Servers = format_servers(Servers0),
ClientId = make_client_id(InstanceId, BridgeName),
ok = emqx_resource:allocate_resource(InstanceId, pulsar_client_id, ClientId),
ok = emqx_resource:allocate_resource(InstanceId, ?pulsar_client_id, ClientId),
SSLOpts = emqx_tls_lib:to_client_opts(SSL),
ConnectTimeout = maps:get(connect_timeout, Config, timer:seconds(5)),
ClientOpts = #{
@ -119,7 +123,7 @@ on_start(InstanceId, Config) ->
-spec on_stop(resource_id(), state()) -> ok.
on_stop(InstanceId, _State) ->
case emqx_resource:get_allocated_resources(InstanceId) of
#{pulsar_client_id := ClientId, pulsar_producers := Producers} ->
#{?pulsar_client_id := ClientId, ?pulsar_producers := Producers} ->
stop_producers(ClientId, Producers),
stop_client(ClientId),
?tp(pulsar_bridge_stopped, #{
@ -128,7 +132,7 @@ on_stop(InstanceId, _State) ->
pulsar_producers => Producers
}),
ok;
#{pulsar_client_id := ClientId} ->
#{?pulsar_client_id := ClientId} ->
stop_client(ClientId),
?tp(pulsar_bridge_stopped, #{
instance_id => InstanceId,
@ -340,7 +344,7 @@ start_producer(Config, InstanceId, ClientId, ClientOpts) ->
?tp(pulsar_producer_about_to_start_producers, #{producer_name => ProducerName}),
try pulsar:ensure_supervised_producers(ClientId, PulsarTopic, ProducerOpts) of
{ok, Producers} ->
ok = emqx_resource:allocate_resource(InstanceId, pulsar_producers, Producers),
ok = emqx_resource:allocate_resource(InstanceId, ?pulsar_producers, Producers),
?tp(pulsar_producer_producers_allocated, #{}),
State = #{
pulsar_client_id => ClientId,

17
apps/emqx_bridge_pulsar/test/emqx_bridge_pulsar_impl_producer_SUITE.erl
View File

@ -285,6 +285,11 @@ create_bridge(Config, Overrides) ->
PulsarConfig = emqx_utils_maps:deep_merge(PulsarConfig0, Overrides),
emqx_bridge:create(Type, Name, PulsarConfig).
delete_bridge(Config) ->
Type = ?BRIDGE_TYPE_BIN,
Name = ?config(pulsar_name, Config),
emqx_bridge:remove(Type, Name).
create_bridge_api(Config) ->
create_bridge_api(Config, _Overrides = #{}).
@ -541,8 +546,14 @@ kill_resource_managers() ->
lists:foreach(
fun({_, Pid, _, _}) ->
ct:pal("terminating resource manager ~p", [Pid]),
%% sys:terminate(Pid, stop),
Ref = monitor(process, Pid),
exit(Pid, kill),
receive
{'DOWN', Ref, process, Pid, killed} ->
ok
after 500 ->
ct:fail("pid ~p didn't die!", [Pid])
end,
ok
end,
supervisor:which_children(emqx_resource_manager_sup)
@ -1002,6 +1013,8 @@ t_resource_manager_crash_after_producers_started(Config) ->
Producers =/= undefined,
10_000
),
?assertMatch({ok, _}, delete_bridge(Config)),
?assertEqual([], get_pulsar_producers()),
ok
end,
[]
@ -1033,6 +1046,8 @@ t_resource_manager_crash_before_producers_started(Config) ->
#{?snk_kind := pulsar_bridge_stopped, pulsar_producers := undefined},
10_000
),
?assertMatch({ok, _}, delete_bridge(Config)),
?assertEqual([], get_pulsar_producers()),
ok
end,
[]

12
apps/emqx_conf/test/emqx_conf_schema_tests.erl
View File

@ -414,17 +414,7 @@ doc_gen_test() ->
60,
fun() ->
Dir = "tmp",
ok = filelib:ensure_dir(filename:join("tmp", foo)),
I18nFile = filename:join([
"_build",
"test",
"lib",
"emqx_dashboard",
"priv",
"i18n.conf"
]),
_ = emqx_conf:dump_schema(Dir, emqx_conf_schema, I18nFile),
ok
ok = emqx_conf:dump_schema(Dir, emqx_conf_schema)
end
}.

9
apps/emqx_dashboard/src/emqx_dashboard_desc_cache.erl
View File

@ -27,15 +27,12 @@
%% @doc Global ETS table to cache the description of the configuration items.
%% The table is owned by the emqx_dashboard_sup the root supervisor of emqx_dashboard.
%% The cache is initialized with the default language (English) and
%% all the desc.<lang>.hocon files in the www/static directory (extracted from dashboard package).
%% all the desc.<lang>.hocon files in the app's priv directory
init() ->
ok = ensure_app_loaded(emqx_dashboard),
PrivDir = code:priv_dir(emqx_dashboard),
EngDesc = filename:join([PrivDir, "desc.en.hocon"]),
WwwStaticDir = filename:join([PrivDir, "www", "static"]),
OtherLangDesc0 = filelib:wildcard("desc.*.hocon", WwwStaticDir),
OtherLangDesc = lists:map(fun(F) -> filename:join([WwwStaticDir, F]) end, OtherLangDesc0),
Files = [EngDesc | OtherLangDesc],
Files0 = filelib:wildcard("desc.*.hocon", PrivDir),
Files = lists:map(fun(F) -> filename:join([PrivDir, F]) end, Files0),
ok = emqx_utils_ets:new(?MODULE, [public, ordered_set, {read_concurrency, true}]),
ok = lists:foreach(fun(F) -> load_desc(?MODULE, F) end, Files).

5
apps/emqx_dashboard/test/emqx_dashboard_api_test_helpers.erl
View File

@ -64,11 +64,6 @@ set_default_config(DefaultUsername, HAProxyEnabled, Opts) ->
i18n_lang => en
},
emqx_config:put([dashboard], Config),
I18nFile = filename:join([
code:priv_dir(emqx_dashboard),
"i18n.conf"
]),
application:set_env(emqx_dashboard, i18n_file, I18nFile),
ok.
request(Method, Url) ->

3
apps/emqx_enterprise/README.md
View File

@ -1,6 +1,5 @@
# EMQX Enterprise Application
This application so fart only holds EMQX config schema for enterprise edition.
This application only holds EMQX config schema for enterprise edition so far.
In the future this application will collect more responsibilities in managing
enterprise edition specific features.

2
apps/emqx_enterprise/src/emqx_enterprise_schema.erl
View File

@ -64,7 +64,7 @@ redefine_roots(Roots) ->
override(Roots, Overrides).
redefine_node(Fields) ->
Overrides = [{"applications", #{default => <<"emqx_license">>}}],
Overrides = [],
override(Fields, Overrides).
override(Fields, []) ->

12
apps/emqx_enterprise/test/emqx_enterprise_schema_tests.erl
View File

@ -13,16 +13,6 @@ doc_gen_test() ->
60,
fun() ->
Dir = "tmp",
ok = filelib:ensure_dir(filename:join("tmp", foo)),
I18nFile = filename:join([
"_build",
"test",
"lib",
"emqx_dashboard",
"priv",
"i18n.conf"
]),
_ = emqx_conf:dump_schema(Dir, emqx_enterprise_schema, I18nFile),
ok
ok = emqx_conf:dump_schema(Dir, emqx_enterprise_schema)
end
}.

2
apps/emqx_resource/src/emqx_resource.erl
View File

@ -533,7 +533,7 @@ clean_allocated_resources(ResourceId, ResourceMod) ->
true ->
%% The resource entries in the ETS table are erased inside
%% `call_stop' if the call is successful.
ok = emqx_resource:call_stop(ResourceId, ResourceMod, _ResourceState = undefined),
ok = call_stop(ResourceId, ResourceMod, _ResourceState = undefined),
ok;
false ->
ok

3
apps/emqx_resource/src/emqx_resource_manager.erl
View File

@ -192,14 +192,13 @@ remove(ResId) when is_binary(ResId) ->
%% @doc Stops a running resource_manager and optionally clears the metrics for the resource
-spec remove(resource_id(), boolean()) -> ok | {error, Reason :: term()}.
remove(ResId, ClearMetrics) when is_binary(ResId) ->
ResourceManagerPid = gproc:whereis_name(?NAME(ResId)),
try
safe_call(ResId, {remove, ClearMetrics}, ?T_OPERATION)
after
%% Ensure the supervisor has it removed, otherwise the immediate re-add will see a stale process
%% If the 'remove' call babove had succeeded, this is mostly a no-op but still needed to avoid race condition.
%% Otherwise this is a 'infinity' shutdown, so it may take arbitrary long.
emqx_resource_manager_sup:delete_child(ResourceManagerPid)
emqx_resource_manager_sup:delete_child(ResId)
end.
%% @doc Stops and then starts an instance that was already running

37
apps/emqx_resource/src/emqx_resource_manager_sup.erl
View File

@ -26,12 +26,12 @@
-export([init/1]).
ensure_child(ResId, Group, ResourceType, Config, Opts) ->
_ = supervisor:start_child(?MODULE, [ResId, Group, ResourceType, Config, Opts]),
_ = supervisor:start_child(?MODULE, child_spec(ResId, Group, ResourceType, Config, Opts)),
ok.
delete_child(Pid) ->
_ = supervisor:terminate_child(?MODULE, Pid),
_ = supervisor:delete_child(?MODULE, Pid),
delete_child(ResId) ->
_ = supervisor:terminate_child(?MODULE, ResId),
_ = supervisor:delete_child(?MODULE, ResId),
ok.
start_link() ->
@ -44,18 +44,19 @@ init([]) ->
public,
{read_concurrency, true}
]),
ChildSpecs = [
#{
id => emqx_resource_manager,
start => {emqx_resource_manager, start_link, []},
restart => transient,
%% never force kill a resource manager.
%% becasue otherwise it may lead to release leak,
%% resource_manager's terminate callback calls resource on_stop
shutdown => infinity,
type => worker,
modules => [emqx_resource_manager]
}
],
SupFlags = #{strategy => simple_one_for_one, intensity => 10, period => 10},
ChildSpecs = [],
SupFlags = #{strategy => one_for_one, intensity => 10, period => 10},
{ok, {SupFlags, ChildSpecs}}.
child_spec(ResId, Group, ResourceType, Config, Opts) ->
#{
id => ResId,
start => {emqx_resource_manager, start_link, [ResId, Group, ResourceType, Config, Opts]},
restart => transient,
%% never force kill a resource manager.
%% becasue otherwise it may lead to release leak,
%% resource_manager's terminate callback calls resource on_stop
shutdown => infinity,
type => worker,
modules => [emqx_resource_manager]
}.

2
changes/ee/feat-10778.en.md
View File

@ -1 +1 @@
Refactored Pulsar Producer bridge to avoid leaking resources during crashes.
Refactored Pulsar Producer bridge to avoid leaking resources during crashes at creation.

1
changes/ee/feat-10813.en.md Normal file
View File

@ -0,0 +1 @@
Refactored Kafka Producer and Consumer bridges to avoid leaking resources during crashes at creation.

2
lib-ee/emqx_license/src/emqx_license_schema.erl
View File

@ -82,7 +82,7 @@ check_license_watermark(Conf) ->
%% @doc The default license key.
%% This default license has 1000 connections limit.
%% It is issued on 2023-01-09 and valid for 5 years (1825 days)
%% NOTE: when updating a new key, the schema doc in emqx_license_schema_i18n.conf
%% NOTE: when updating a new key, the schema doc in emqx_license_schema.hocon
%% should be updated accordingly
default_license() ->
<<

96
rel/i18n/zh/emqx_authn_api.hocon
View File

@ -1,96 +0,0 @@
emqx_authn_api {
authentication_get.desc:
"""列出全局认证链上的认证器。"""
authentication_id_delete.desc:
"""删除全局认证链上的指定认证器。"""
authentication_id_get.desc:
"""获取全局认证链上的指定认证器。"""
authentication_id_position_put.desc:
"""更改全局认证链上指定认证器的顺序。"""
authentication_id_put.desc:
"""更新全局认证链上的指定认证器。"""
authentication_id_status_get.desc:
"""获取全局认证链上指定认证器的状态。"""
authentication_id_users_get.desc:
"""获取全局认证链上指定认证器中的用户数据。"""
authentication_id_users_post.desc:
"""为全局认证链上的指定认证器创建用户数据。"""
authentication_id_users_user_id_delete.desc:
"""删除全局认证链上指定认证器中的指定用户数据。"""
authentication_id_users_user_id_get.desc:
"""获取全局认证链上指定认证器中的指定用户数据。"""
authentication_id_users_user_id_put.desc:
"""更新全局认证链上指定认证器中的指定用户数据。"""
authentication_post.desc:
"""为全局认证链创建认证器。"""
is_superuser.desc:
"""是否是超级用户"""
like_user_id.desc:
"""使用用户 ID （username 或 clientid）模糊查询。"""
like_user_id.label:
"""like_user_id"""
listeners_listener_id_authentication_get.desc:
"""列出监听器认证链上的认证器。"""
listeners_listener_id_authentication_id_delete.desc:
"""删除监听器认证链上的指定认证器。"""
listeners_listener_id_authentication_id_get.desc:
"""获取监听器认证链上的指定认证器。"""
listeners_listener_id_authentication_id_position_put.desc:
"""更改监听器认证链上指定认证器的顺序。"""
listeners_listener_id_authentication_id_put.desc:
"""更新监听器认证链上的指定认证器。"""
listeners_listener_id_authentication_id_status_get.desc:
"""获取监听器认证链上指定认证器的状态。"""
listeners_listener_id_authentication_id_users_get.desc:
"""列出监听器认证链上指定认证器中的用户数据。"""
listeners_listener_id_authentication_id_users_post.desc:
"""为监听器认证链上的指定认证器创建用户数据。"""
listeners_listener_id_authentication_id_users_user_id_delete.desc:
"""删除监听器认证链上指定认证器中的指定用户数据。"""
listeners_listener_id_authentication_id_users_user_id_get.desc:
"""获取监听器认证链上指定认证器中的指定用户数据。"""
listeners_listener_id_authentication_id_users_user_id_put.desc:
"""更新监听器认证链上指定认证器中的指定用户数据。"""
listeners_listener_id_authentication_post.desc:
"""在监听器认证链上创建认证器。"""
param_auth_id.desc:
"""认证器 ID。"""
param_listener_id.desc:
"""监听器 ID。"""
param_position.desc:
"""认证者在链中的位置。可能的值是 'front', 'rear', 'before:{other_authenticator}', 'after:{other_authenticator}'"""
param_user_id.desc:
"""用户 ID。"""
}

45
rel/i18n/zh/emqx_authn_http.hocon
View File

@ -1,45 +0,0 @@
emqx_authn_http {
body.desc:
"""HTTP request body。"""
body.label:
"""Request Body"""
get.desc:
"""使用 HTTP Server 作为认证服务的认证器的配置项 (使用 GET 请求)。"""
headers.desc:
"""HTTP Headers 列表"""
headers.label:
"""请求头"""
headers_no_content_type.desc:
"""HTTP Headers 列表 (无 <code>content-type</code>) 。"""
headers_no_content_type.label:
"""请求头(无 content-type)"""
method.desc:
"""HTTP 请求方法。"""
method.label:
"""请求方法"""
post.desc:
"""使用 HTTP Server 作为认证服务的认证器的配置项 (使用 POST 请求)。"""
request_timeout.desc:
"""HTTP 请求超时时长。"""
request_timeout.label:
"""请求超时时间"""
url.desc:
"""认证 HTTP 服务器地址。"""
url.label:
"""URL"""
}

118
rel/i18n/zh/emqx_authn_jwt.hocon
View File

@ -1,118 +0,0 @@
emqx_authn_jwt {
acl_claim_name.desc:
"""JWT claim name to use for getting ACL rules."""
acl_claim_name.label:
"""ACL claim name"""
algorithm.desc:
"""JWT 签名算法，支持 HMAC (配置为 <code>hmac-based</code>）和 RSA、ECDSA (配置为 <code>public-key</code>)。"""
algorithm.label:
"""JWT 签名算法"""
cacertfile.desc:
"""包含 PEM 编码的 CA 证书的文件的路径。"""
cacertfile.label:
"""CA 证书文件"""
certfile.desc:
"""包含用户证书的文件的路径。"""
certfile.label:
"""证书文件"""
enable.desc:
"""启用/禁用 SSL。"""
enable.label:
"""启用/禁用 SSL"""
endpoint.desc:
"""JWKS 端点， 它是一个以 JWKS 格式返回服务端的公钥集的只读端点。"""
endpoint.label:
"""JWKS Endpoint"""
from.desc:
"""要从中获取 JWT 的字段。"""
from.label:
"""源字段"""
jwt_hmac.desc:
"""用于认证的 JWT 使用 HMAC 算法签发时的配置。"""
jwt_jwks.desc:
"""用于认证的 JWTs 需要从 JWKS 端点获取时的配置。"""
keyfile.desc:
"""包含 PEM 编码的用户私钥的文件的路径。"""
keyfile.label:
"""私钥文件"""
jwt_public_key.desc:
"""用于认证的 JWT 使用 RSA 或 ECDSA 算法签发时的配置。"""
public_key.desc:
"""用于验证 JWT 的公钥。"""
public_key.label:
"""公钥"""
refresh_interval.desc:
"""JWKS 刷新间隔。"""
refresh_interval.label:
"""JWKS 刷新间隔"""
secret.desc:
"""使用 HMAC 算法时用于验证 JWT 的密钥"""
secret.label:
"""Secret"""
secret_base64_encoded.desc:
"""密钥是否为 Base64 编码。"""
secret_base64_encoded.label:
"""密钥是否为 Base64 编码"""
server_name_indication.desc:
"""服务器名称指示（SNI）。"""
server_name_indication.label:
"""服务器名称指示"""
ssl.desc:
"""SSL 选项。"""
ssl.label:
"""SSL 选项"""
use_jwks.desc:
"""是否使用 JWKS。"""
use_jwks.label:
"""是否使用 JWKS"""
verify.desc:
"""指定握手过程中是否校验对端证书。"""
verify.label:
"""Verify"""
verify_claims.desc:
"""需要验证的自定义声明列表，它是一个名称/值对列表。
值可以使用以下占位符：
- <code>${username}</code>: 将在运行时被替换为客户端连接时使用的用户名
- <code>${clientid}</code>: 将在运行时被替换为客户端连接时使用的客户端标识符
认证时将验证 JWT（取自 Password 字段）中 claims 的值是否与 <code>verify_claims</code> 中要求的相匹配。"""
verify_claims.label:
"""Verify Claims"""
}

12
rel/i18n/zh/emqx_authn_mnesia.hocon
View File

@ -1,12 +0,0 @@
emqx_authn_mnesia {
builtin_db.desc:
"""使用内置数据库作为认证数据源的认证器的配置项。"""
user_id_type.desc:
"""指定使用客户端ID `clientid` 还是用户名 `username` 进行认证。"""
user_id_type.label:
"""认证 ID 类型"""
}

45
rel/i18n/zh/emqx_authn_mongodb.hocon
View File

@ -1,45 +0,0 @@
emqx_authn_mongodb {
collection.desc:
"""存储认证数据的集合。"""
collection.label:
"""集合"""
filter.desc:
"""在查询中定义过滤条件的条件表达式。
过滤器支持如下占位符：
- <code>${username}</code>: 将在运行时被替换为客户端连接时使用的用户名
- <code>${clientid}</code>: 将在运行时被替换为客户端连接时使用的客户端标识符"""
filter.label:
"""过滤器"""
is_superuser_field.desc:
"""文档中用于定义用户是否具有超级用户权限的字段。"""
is_superuser_field.label:
"""超级用户字段"""
password_hash_field.desc:
"""文档中用于存放密码散列的字段。"""
password_hash_field.label:
"""密码散列字段"""
replica-set.desc:
"""使用 MongoDB (Replica Set) 作为认证数据源的认证器的配置项。"""
salt_field.desc:
"""文档中用于存放盐值的字段。"""
salt_field.label:
"""盐值字段"""
sharded-cluster.desc:
"""使用 MongoDB (Sharded Cluster) 作为认证数据源的认证器的配置项。"""
single.desc:
"""使用 MongoDB (Standalone) 作为认证数据源的认证器的配置项。"""
}

18
rel/i18n/zh/emqx_authn_mysql.hocon
View File

@ -1,18 +0,0 @@
emqx_authn_mysql {
mysql.desc:
"""使用 MySQL 作为认证数据源的认证器的配置项。"""
query.desc:
"""用于查询密码散列等用于认证的数据的 SQL 语句。"""
query.label:
"""查询语句"""
query_timeout.desc:
"""SQL 查询的超时时间。"""
query_timeout.label:
"""查询超时"""
}

12
rel/i18n/zh/emqx_authn_pgsql.hocon
View File

@ -1,12 +0,0 @@
emqx_authn_pgsql {
postgresql.desc:
"""使用 PostgreSQL 作为认证数据源的认证器的配置项。"""
query.desc:
"""用于查询密码散列等用于认证的数据的 SQL 语句。"""
query.label:
"""查询语句"""
}

18
rel/i18n/zh/emqx_authn_redis.hocon
View File

@ -1,18 +0,0 @@
emqx_authn_redis {
cluster.desc:
"""使用 Redis (Cluster) 作为认证数据源的认证器的配置项。"""
cmd.desc:
"""用于查询密码散列等用于认证的数据的 Redis Command，目前仅支持 <code>HGET</code> 与 <code>HMGET</code>。"""
cmd.label:
"""Command"""
sentinel.desc:
"""使用 Redis (Sentinel) 作为认证数据源的认证器的配置项。"""
single.desc:
"""使用 Redis (Standalone) 作为认证数据源的认证器的配置项。"""
}

135
rel/i18n/zh/emqx_authn_schema.hocon
View File

@ -1,135 +0,0 @@
emqx_authn_schema {
backend.desc:
"""后端类型。"""
backend.label:
"""后端类型"""
enable.desc:
"""设为 <code>true</code> 或 <code>false</code> 以启用或禁用此认证数据源。"""
enable.label:
"""启用"""
failed.desc:
"""请求失败次数。"""
failed.label:
"""失败"""
matched.desc:
"""请求命中次数。"""
matched.label:
"""已命中"""
mechanism.desc:
"""认证机制。"""
mechanism.label:
"""认证机制"""
metrics.desc:
"""资源统计指标。"""
metrics.label:
"""指标"""
metrics_failed.desc:
"""在当前实例中找到需要的认证信息，并且实例返回认证失败的次数。"""
metrics_failed.label:
"""实例认证失败的次数"""
metrics_nomatch.desc:
"""在当前实例中没有找到需要的认证信息，实例被忽略的次数。"""
metrics_nomatch.label:
"""实例被忽略的次数"""
metrics_rate.desc:
"""实例被触发的速率。触发速率等于匹配速率 + 忽略速率，单位：次/秒。"""
metrics_rate.label:
"""实例被触发的速率"""
metrics_rate_last5m.desc:
"""实例5分钟内平均触发速率，单位：次/秒。"""
metrics_rate_last5m.label:
"""实例5分钟内平均触发速率"""
metrics_rate_max.desc:
"""实例曾经达到的最高触发速率，单位：次/秒。"""
metrics_rate_max.label:
"""实例曾经达到的最高触发速率"""
metrics_success.desc:
"""在当前实例中找到需要的认证信息，并且实例返回认证成功的次数。"""
metrics_success.label:
"""实例认证成功的次数"""
metrics_total.desc:
"""当前实例被触发的总次数。"""
metrics_total.label:
"""当前实例被触发的总次数"""
node.desc:
"""节点名称。"""
node.label:
"""节点名称。"""
node_error.desc:
"""节点上产生的错误。"""
node_error.label:
"""节点产生的错误"""
node_metrics.desc:
"""每个节点上资源的统计指标。"""
node_metrics.label:
"""节点资源指标"""
node_status.desc:
"""每个节点上资源的状态。"""
node_status.label:
"""节点资源状态"""
rate.desc:
"""命中速率，单位：次/秒。"""
rate.label:
"""速率"""
rate_last5m.desc:
"""5分钟内平均命中速率，单位：次/秒。"""
rate_last5m.label:
"""5分钟内速率"""
rate_max.desc:
"""最大命中速率，单位：次/秒。"""
rate_max.label:
"""最大速率"""
status.desc:
"""资源状态。"""
status.label:
"""状态"""
success.desc:
"""请求成功次数。"""
success.label:
"""成功"""
}

9
rel/i18n/zh/emqx_authn_user_import_api.hocon
View File

@ -1,9 +0,0 @@
emqx_authn_user_import_api {
authentication_id_import_users_post.desc:
"""为全局认证链上的指定认证器导入用户数据。"""
listeners_listener_id_authentication_id_import_users_post.desc:
"""为监听器认证链上的指定认证器导入用户数据。"""
}

6
rel/i18n/zh/emqx_authz_api_cache.hocon
View File

@ -1,6 +0,0 @@
emqx_authz_api_cache {
authorization_cache_delete.desc:
"""清除集群中所有授权数据缓存。"""
}

87
rel/i18n/zh/emqx_authz_api_mnesia.hocon
View File

@ -1,87 +0,0 @@
emqx_authz_api_mnesia {
action.desc:
"""被授权的行为 (发布/订阅/所有)"""
action.label:
"""行为"""
clientid.desc:
"""客户端标识符"""
clientid.label:
"""客户端标识符"""
fuzzy_clientid.desc:
"""使用字串匹配模糊搜索客户端标识符"""
fuzzy_clientid.label:
"""客户端标识符子串"""
fuzzy_username.desc:
"""使用字串匹配模糊搜索用户名"""
fuzzy_username.label:
"""用户名子串"""
permission.desc:
"""权限"""
permission.label:
"""权限"""
rules_all_delete.desc:
"""删除 `all` 规则"""
rules_all_get.desc:
"""列出为所有客户端启用的规则列表"""
rules_all_post.desc:
"""创建/更新 为所有客户端启用的规则列表。"""
rules_delete.desc:
"""清除内置数据库中的所有类型（'users' 、'clients' 、'all'）的所有规则"""
topic.desc:
"""在指定主题上的规则"""
topic.label:
"""主题"""
user_clientid_delete.desc:
"""删除内置数据库中指定客户端标识符类型的规则记录"""
user_clientid_get.desc:
"""获取内置数据库中指定客户端标识符类型的规则记录"""
user_clientid_put.desc:
"""更新内置数据库中指定客户端标识符类型的规则记录"""
user_username_delete.desc:
"""删除内置数据库中指定用户名类型的规则记录"""
user_username_get.desc:
"""获取内置数据库中指定用户名类型的规则记录"""
user_username_put.desc:
"""更新内置数据库中指定用户名类型的规则记录"""
username.desc:
"""用户名"""
username.label:
"""用户名"""
users_clientid_get.desc:
"""获取内置数据库中所有客户端标识符类型的规则记录"""
users_clientid_post.desc:
"""添加内置数据库中客户端标识符类型的规则记录"""
users_username_get.desc:
"""获取内置数据库中所有用户名类型的规则记录"""
users_username_post.desc:
"""添加内置数据库中用户名类型的规则记录"""
}

90
rel/i18n/zh/emqx_authz_api_schema.hocon
View File

@ -1,90 +0,0 @@
emqx_authz_api_schema {
body.desc:
"""HTTP 请求体。"""
body.label:
"""请求体"""
cmd.desc:
"""访问控制数据查询命令。"""
cmd.label:
"""查询命令"""
collection.desc:
"""`MongoDB` 授权数据集。"""
collection.label:
"""数据集"""
enable.desc:
"""设为 <code>true</code> 或 <code>false</code> 以启用或禁用此访问控制数据源。"""
enable.label:
"""enable"""
filter.desc:
"""在查询中定义过滤条件的条件表达式。
过滤器支持如下占位符：
- <code>${username}</code>: 将在运行时被替换为客户端连接时使用的用户名
- <code>${clientid}</code>: 将在运行时被替换为客户端连接时使用的客户端标识符"""
filter.label:
"""过滤器"""
headers.desc:
"""HTTP Headers 列表"""
headers.label:
"""请求头"""
headers_no_content_type.desc:
"""HTTP Headers 列表（无 <code>content-type</code>）。"""
headers_no_content_type.label:
"""请求头(无 content-type)"""
method.desc:
"""HTTP 请求方法。"""
method.label:
"""method"""
position.desc:
"""认证数据源位置。"""
position.label:
"""位置"""
query.desc:
"""访问控制数据查询语句。"""
query.label:
"""查询语句"""
request_timeout.desc:
"""请求超时时间。"""
request_timeout.label:
"""请求超时"""
rules.desc:
"""静态授权文件规则。"""
rules.label:
"""规则"""
type.desc:
"""数据后端类型。"""
type.label:
"""type"""
url.desc:
"""认证服务器 URL。"""
url.label:
"""url"""
}

9
rel/i18n/zh/emqx_authz_api_settings.hocon
View File

@ -1,9 +0,0 @@
emqx_authz_api_settings {
authorization_settings_get.desc:
"""获取授权配置"""
authorization_settings_put.desc:
"""更新授权配置"""
}

48
rel/i18n/zh/emqx_authz_api_sources.hocon
View File

@ -1,48 +0,0 @@
emqx_authz_api_sources {
authorization_sources_get.desc:
"""列出所有授权数据源"""
authorization_sources_post.desc:
"""添加授权数据源"""
authorization_sources_type_delete.desc:
"""删除指定类型的授权数据源"""
authorization_sources_type_get.desc:
"""获取指定类型的授权数据源"""
authorization_sources_type_move_post.desc:
"""更新授权数据源的优先执行顺序"""
authorization_sources_type_put.desc:
"""更新指定类型的授权数据源"""
authorization_sources_type_status_get.desc:
"""获取指定授权数据源的状态"""
source.desc:
"""授权数据源"""
source.label:
"""数据源"""
source_config.desc:
"""数据源配置"""
source_config.label:
"""数据源配置"""
source_type.desc:
"""数据源类型"""
source_type.label:
"""数据源类型"""
sources.desc:
"""授权数据源列表"""
sources.label:
"""数据源列表"""
}

285
rel/i18n/zh/emqx_authz_schema.hocon
View File

@ -1,285 +0,0 @@
emqx_authz_schema {
deny.desc:
"""授权失败的次数。"""
deny.label:
"""授权失败次数"""
redis_sentinel.desc:
"""使用 Redis 授权（哨兵模式）。"""
redis_sentinel.label:
"""redis_sentinel"""
rate.desc:
"""命中速率，单位：次/秒。"""
rate.label:
"""速率"""
status.desc:
"""资源状态。"""
status.label:
"""状态"""
method.desc:
"""HTTP 请求方法"""
method.label:
"""method"""
query.desc:
"""访问控制数据查询语句/查询命令。"""
query.label:
"""查询语句"""
metrics_total.desc:
"""授权实例被触发的总次数。"""
metrics_total.label:
"""授权实例被触发的总次数"""
redis_cluster.desc:
"""使用 Redis 授权（集群模式）。"""
redis_cluster.label:
"""redis_cluster"""
mysql.desc:
"""使用 MySOL 数据库授权"""
mysql.label:
"""mysql"""
postgresql.desc:
"""使用 PostgreSQL 数据库授权"""
postgresql.label:
"""postgresql"""
mongo_rs.desc:
"""使用 MongoDB 授权（副本集模式）"""
mongo_rs.label:
"""mongo_rs"""
type.desc:
"""数据后端类型"""
type.label:
"""type"""
mongo_sharded.desc:
"""使用 MongoDB 授权（分片集群模式）。"""
mongo_sharded.label:
"""mongo_sharded"""
body.desc:
"""HTTP request body。"""
body.label:
"""Request Body"""
url.desc:
"""授权 HTTP 服务器地址。"""
url.label:
"""URL"""
node.desc:
"""节点名称。"""
node.label:
"""节点名称。"""
headers.desc:
"""HTTP Headers 列表"""
headers.label:
"""请求头"""
rate_last5m.desc:
"""5分钟内平均命中速率，单位：次/秒。"""
rate_last5m.label:
"""5分钟内速率"""
headers_no_content_type.desc:
"""HTTP Headers 列表 (无 <code>content-type</code>) 。"""
headers_no_content_type.label:
"""请求头(无 content-type)"""
node_error.desc:
"""节点上产生的错误。"""
node_error.label:
"""节点产生的错误"""
builtin_db.desc:
"""使用内部数据库授权（mnesia）。"""
builtin_db.label:
"""Buitin Database"""
enable.desc:
"""设为 <code>true</code> 或 <code>false</code> 以启用或禁用此访问控制数据源"""
enable.label:
"""enable"""
matched.desc:
"""请求命中次数。"""
matched.label:
"""已命中"""
node_status.desc:
"""每个节点上资源的状态。"""
node_status.label:
"""节点资源状态"""
rate_max.desc:
"""最大命中速率，单位：次/秒。"""
rate_max.label:
"""最大速率"""
filter.desc:
"""在查询中定义过滤条件的条件表达式。
过滤器支持如下占位符：<br/>
- <code>${username}</code>：将在运行时被替换为客户端连接时使用的用户名<br/>
- <code>${clientid}</code>：将在运行时被替换为客户端连接时使用的客户端标识符"""
filter.label:
"""过滤器"""
path.desc:
"""包含 ACL 规则的文件路径。
如果在启动 EMQX 节点前预先配置该路径，
那么可以将该文件置于任何 EMQX 可以访问到的位置。
如果从 EMQX Dashboard 或 HTTP API 创建或修改了规则集，
那么EMQX将会生成一个新的文件并将它存放在 `data_dir` 下的 `authz` 子目录中，
并从此弃用旧的文件。"""
path.label:
"""path"""
redis_single.desc:
"""使用 Redis 授权（单实例）。"""
redis_single.label:
"""redis_single"""
failed.desc:
"""请求失败次数。"""
failed.label:
"""失败"""
metrics.desc:
"""资源统计指标。"""
metrics.label:
"""指标"""
authorization.desc:
"""客户端授权相关配置"""
authorization.label:
"""授权"""
collection.desc:
"""`MongoDB` 授权数据集。"""
collection.label:
"""数据集"""
mongo_single.desc:
"""使用 MongoDB 授权（单实例）。"""
mongo_single.label:
"""mongo_single"""
file.desc:
"""使用静态文件授权"""
file.label:
"""文件"""
http_post.desc:
"""使用外部 HTTP 服务器授权(POST 请求)。"""
http_post.label:
"""http_post"""
request_timeout.desc:
"""HTTP 请求超时时长。"""
request_timeout.label:
"""请求超时时间"""
allow.desc:
"""授权成功的次数。"""
allow.label:
"""授权成功次数"""
cmd.desc:
"""访问控制数据查查询命令"""
cmd.label:
"""查询命令"""
nomatch.desc:
"""没有匹配到任何授权规则的次数。"""
nomatch.label:
"""没有匹配到任何授权规则的次数"""
sources.desc:
"""授权数据源。<br/>
授权（ACL）数据源的列表。
它被设计为一个数组，而不是一个散列映射，
所以可以作为链式访问控制。<br/>
当授权一个 'publish' 或 'subscribe' 行为时，
该配置列表中的所有数据源将按顺序进行检查。
如果在某个客户端未找到时(使用 ClientID 或 Username)。
将会移动到下一个数据源。直至得到 'allow' 或 'deny' 的结果。<br/>
如果在任何数据源中都未找到对应的客户端信息。
配置的默认行为 ('authorization.no_match') 将生效。<br/>
注意：
数据源使用 'type' 进行标识。
使用同一类型的数据源多于一次不被允许。"""
sources.label:
"""数据源"""
node_metrics.desc:
"""每个节点上资源的统计指标。"""
node_metrics.label:
"""节点资源指标"""
success.desc:
"""请求成功次数。"""
success.label:
"""成功"""
http_get.desc:
"""使用外部 HTTP 服务器授权(GET 请求)。"""
http_get.label:
"""http_get"""
}

12
rel/i18n/zh/emqx_auto_subscribe_api.hocon
View File

@ -1,12 +0,0 @@
emqx_auto_subscribe_api {
list_auto_subscribe_api.desc:
"""获取自动订阅主题列表"""
update_auto_subscribe_api.desc:
"""更新自动订阅主题列表"""
update_auto_subscribe_api_response409.desc:
"""超出自定订阅主题列表长度限制"""
}

48
rel/i18n/zh/emqx_auto_subscribe_schema.hocon
View File

@ -1,48 +0,0 @@
emqx_auto_subscribe_schema {
auto_subscribe.desc:
"""设备登录成功之后，通过预设的订阅表示符，为设备自动完成订阅。支持使用占位符。"""
auto_subscribe.label:
"""自动订阅"""
nl.desc:
"""缺省值为0，
MQTT v3.1.1：如果设备订阅了自己发布消息的主题，那么将收到自己发布的所有消息。
MQTT v5：如果设备在订阅时将此选项设置为 1，那么服务端将不会向设备转发自己发布的消息"""
nl.label:
"""No Local"""
qos.desc:
"""缺省值为 0，服务质量，
QoS 0：消息最多传递一次，如果当时客户端不可用，则会丢失该消息。
QoS 1：消息传递至少 1 次。
QoS 2：消息仅传送一次。"""
qos.label:
"""服务质量"""
rap.desc:
"""缺省值为 0，这一选项用来指定服务端向客户端转发消息时是否要保留其中的 RETAIN 标识，注意这一选项不会影响保留消息中的 RETAIN 标识。因此当 Retain As Publish 选项被设置为 0 时，客户端直接依靠消息中的 RETAIN 标识来区分这是一个正常的转发消息还是一个保留消息，而不是去判断消息是否是自己订阅后收到的第一个消息（转发消息甚至可能会先于保留消息被发送，视不同 Broker 的具体实现而定）。"""
rap.label:
"""Retain As Publish"""
rh.desc:
"""指定订阅建立时服务端是否向客户端发送保留消息，
可选值 0：只要客户端订阅成功，服务端就发送保留消息。
可选值 1：客户端订阅成功且该订阅此前不存在，服务端才发送保留消息。毕竟有些时候客户端重新发起订阅可能只是为了改变一下 QoS，并不意味着它想再次接收保留消息。
可选值 2：即便客户订阅成功，服务端也不会发送保留消息。"""
rh.label:
"""Retain Handling"""
topic.desc:
"""订阅标识符，支持使用占位符，例如 client/${clientid}/username/${username}/host/${host}/port/${port}
必填，且不可为空字符串"""
topic.label:
"""订阅标识符"""
}

100
rel/i18n/zh/emqx_bridge_api.hocon
View File

@ -1,100 +0,0 @@
emqx_bridge_api {
desc_api1.desc:
"""列出所有 Bridge"""
desc_api1.label:
"""列出所有 Bridge"""
desc_api2.desc:
"""通过类型和名字创建 Bridge"""
desc_api2.label:
"""创建 Bridge"""
desc_api3.desc:
"""通过 ID 获取 Bridge"""
desc_api3.label:
"""获取 Bridge"""
desc_api4.desc:
"""通过 ID 更新 Bridge"""
desc_api4.label:
"""更新 Bridge"""
desc_api5.desc:
"""通过 ID 删除 Bridge"""
desc_api5.label:
"""删除 Bridge"""
desc_api6.desc:
"""通过 ID 重置 Bridge 的计数"""
desc_api6.label:
"""重置 Bridge 计数"""
desc_api7.desc:
"""停止或启用所有节点上的桥接"""
desc_api7.label:
"""集群 Bridge 操作"""
desc_api8.desc:
"""在某个节点上停止/重新启动 Bridge。"""
desc_api8.label:
"""单节点 Bridge 操作"""
desc_api9.desc:
"""通过给定的 ID 测试创建一个新的桥接。 </br>
ID 的格式必须为 ’{type}:{name}”"""
desc_api9.label:
"""测试桥接创建"""
desc_bridge_metrics.desc:
"""通过 Id 来获取桥接的指标信息"""
desc_bridge_metrics.label:
"""获取桥接的指标"""
desc_enable_bridge.desc:
"""启用或禁用所有节点上的桥接"""
desc_enable_bridge.label:
"""是否启用集群内的桥接"""
desc_param_path_enable.desc:
"""是否启用桥接"""
desc_param_path_enable.label:
"""启用桥接"""
desc_param_path_id.desc:
"""Bridge ID ， 格式为 {type}:{name}"""
desc_param_path_id.label:
"""Bridge ID"""
desc_param_path_node.desc:
"""节点名，比如 emqx@127.0.0.1"""
desc_param_path_node.label:
"""节点名"""
desc_param_path_operation_cluster.desc:
"""集群可用操作：停止、重新启动"""
desc_param_path_operation_cluster.label:
"""集群可用操作"""
desc_param_path_operation_on_node.desc:
"""节点可用操作：停止、重新启动"""
desc_param_path_operation_on_node.label:
"""节点可用操作"""
}

46
rel/i18n/zh/emqx_bridge_clickhouse.hocon
View File

@ -1,46 +0,0 @@
emqx_bridge_clickhouse {
batch_value_separator.desc:
"""默认为逗号 ','，适用于 VALUE 格式。您也可以使用其他分隔符， 请参考 [INSERT INTO 语句](https://clickhouse.com/docs/en/sql-reference/statements/insert-into)。"""
batch_value_separator.label:
"""分隔符"""
config_enable.desc:
"""启用/禁用桥接"""
config_enable.label:
"""启用/禁用桥接"""
desc_config.desc:
"""Clickhouse 桥接配置"""
desc_config.label:
"""Clickhouse 桥接配置"""
desc_name.desc:
"""桥接名字"""
desc_name.label:
"""桥接名字"""
desc_type.desc:
"""Bridge 类型"""
desc_type.label:
"""桥接类型"""
local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 Clickhouse。 </br>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发。"""
local_topic.label:
"""本地 Topic"""
sql_template.desc:
"""可以使用 ${field} 占位符来引用消息与客户端上下文中的变量，请确保对应字段存在且数据格式符合预期。此处不支持 [SQL 预处理](https://docs.emqx.com/zh/enterprise/v5.0/data-integration/data-bridges.html#sql-预处理)。"""
sql_template.label:
"""SQL 模板"""
}

15
rel/i18n/zh/emqx_bridge_clickhouse_connector.hocon
View File

@ -1,15 +0,0 @@
emqx_bridge_clickhouse_connector {
base_url.desc:
"""你想连接到的Clickhouse服务器的HTTP URL（例如http://myhostname:8123）。"""
base_url.label:
"""服务器 URL"""
connect_timeout.desc:
"""连接HTTP服务器的超时时间。"""
connect_timeout.label:
"""连接超时"""
}

40
rel/i18n/zh/emqx_bridge_dynamo.hocon
View File

@ -1,40 +0,0 @@
emqx_bridge_dynamo {
config_enable.desc:
"""启用/禁用桥接"""
config_enable.label:
"""启用/禁用桥接"""
desc_config.desc:
"""DynamoDB 桥接配置"""
desc_config.label:
"""DynamoDB 桥接配置"""
desc_name.desc:
"""桥接名字"""
desc_name.label:
"""桥接名字"""
desc_type.desc:
"""Bridge 类型"""
desc_type.label:
"""桥接类型"""
local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 DynamoDB。 </br>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发。"""
local_topic.label:
"""本地 Topic"""
template.desc:
"""模板, 默认为空，为空时将会将整个消息存入数据库"""
template.label:
"""模板"""
}

27
rel/i18n/zh/emqx_bridge_dynamo_connector.hocon
View File

@ -1,27 +0,0 @@
emqx_bridge_dynamo_connector {
aws_access_key_id.desc:
"""DynamoDB 的访问 ID。"""
aws_access_key_id.label:
"""连接访问 ID"""
aws_secret_access_key.desc:
"""DynamoDB 的访问密钥。"""
aws_secret_access_key.label:
"""连接访问密钥"""
table.desc:
"""DynamoDB 的表。"""
table.label:
"""表"""
url.desc:
"""DynamoDB 的地址。"""
url.label:
"""DynamoDB 地址"""
}

77
rel/i18n/zh/emqx_bridge_gcp_pubsub.hocon
View File

@ -1,77 +0,0 @@
emqx_bridge_gcp_pubsub {
connect_timeout.desc:
"""连接 HTTP 服务器的超时时间。"""
connect_timeout.label:
"""连接超时"""
desc_config.desc:
"""GCP PubSub 桥接配置"""
desc_config.label:
"""GCP PubSub 桥接配置"""
desc_name.desc:
"""桥接名字，可读描述"""
desc_name.label:
"""桥接名字"""
desc_type.desc:
"""桥接类型"""
desc_type.label:
"""桥接类型"""
local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 GCP PubSub。 </br>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发到 GCP PubSub。"""
local_topic.label:
"""本地 Topic"""
max_retries.desc:
"""请求出错时的最大重试次数。"""
max_retries.label:
"""最大重试次数"""
payload_template.desc:
"""用于格式化外发信息的模板。 如果未定义，将以JSON格式发送所有可用的上下文。"""
payload_template.label:
"""HTTP 请求消息体模板"""
pipelining.desc:
"""正整数，设置最大可发送的异步 HTTP 请求数量。当设置为 1 时，表示每次发送完成 HTTP 请求后都需要等待服务器返回，再继续发送下一个请求。"""
pipelining.label:
"""HTTP 流水线"""
pool_size.desc:
"""连接池大小。"""
pool_size.label:
"""连接池大小"""
pubsub_topic.desc:
"""要发布消息的GCP PubSub主题。"""
pubsub_topic.label:
"""GCP PubSub 主题"""
request_timeout.desc:
"""废弃的。在缓冲区设置中配置请求超时。"""
request_timeout.label:
"""HTTP 请求超时"""
service_account_json.desc:
"""包含将与 PubSub 一起使用的 GCP 服务账户凭证的 JSON。
当创建GCP服务账户时（如https://developers.google.com/identity/protocols/oauth2/service-account#creatinganaccount），可以选择下载 JSON 形式的凭证，然后在该配置项中使用。"""
service_account_json.label:
"""GCP 服务账户凭证"""
}

47
rel/i18n/zh/emqx_bridge_influxdb.hocon
View File

@ -1,47 +0,0 @@
emqx_bridge_influxdb {
config_enable.desc:
"""启用/禁用桥接。"""
config_enable.label:
"""启用/禁用桥接"""
desc_config.desc:
"""InfluxDB 桥接配置。"""
desc_config.label:
"""InfluxDB 桥接配置"""
desc_name.desc:
"""桥接名称。"""
desc_name.label:
"""桥接名称"""
desc_type.desc:
"""桥接类型。"""
desc_type.label:
"""桥接类型"""
local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 InfluxDB。 </br>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发到 InfluxDB。"""
local_topic.label:
"""本地 Topic"""
write_syntax.desc:
"""使用 InfluxDB API Line Protocol 写入 InfluxDB 的数据，支持占位符</br>
参考 [InfluxDB 2.3 Line Protocol](https://docs.influxdata.com/influxdb/v2.3/reference/syntax/line-protocol/) 及
[InfluxDB 1.8 Line Protocol](https://docs.influxdata.com/influxdb/v1.8/write_protocols/line_protocol_tutorial/) </br>
TLDR: </br>
```
<measurement>[,<tag_key>=<tag_value>[,<tag_key>=<tag_value>]] <field_key>=<field_value>[,<field_key>=<field_value>] [<timestamp>]
```
注意，整形数值占位符后需要添加一个字符 `i` 类型标识。例如 `${payload.int_value}i`"""
write_syntax.label:
"""写语句"""
}

71
rel/i18n/zh/emqx_bridge_influxdb_connector.hocon
View File

@ -1,71 +0,0 @@
emqx_bridge_influxdb_connector {
bucket.desc:
"""InfluxDB bucket 名称。"""
bucket.label:
"""Bucket"""
database.desc:
"""InfluxDB 数据库。"""
database.label:
"""数据库"""
influxdb_api_v1.desc:
"""InfluxDB HTTP API 协议。支持 Influxdb v1.8 以及之前的版本。"""
influxdb_api_v1.label:
"""HTTP API 协议"""
influxdb_api_v2.desc:
"""InfluxDB HTTP API V2 协议。支持 Influxdb v2.0 以及之后的版本。"""
influxdb_api_v2.label:
"""HTTP API V2 协议"""
org.desc:
"""InfluxDB 组织名称。"""
org.label:
"""组织"""
password.desc:
"""InfluxDB 密码。"""
password.label:
"""密码"""
precision.desc:
"""InfluxDB 时间精度。"""
precision.label:
"""时间精度"""
protocol.desc:
"""InfluxDB 协议。HTTP API 或 HTTP API V2。"""
protocol.label:
"""协议"""
server.desc:
"""将要连接的 IPv4 或 IPv6 地址，或者主机名。</br>
主机名具有以下形式：`Host[:Port]`。</br>
如果未指定 `[:Port]`，则使用 InfluxDB 默认端口 8086。"""
server.label:
"""服务器地址"""
token.desc:
"""InfluxDB token。"""
token.label:
"""Token"""
username.desc:
"""InfluxDB 用户名。"""
username.label:
"""用户名"""
}

354
rel/i18n/zh/emqx_bridge_kafka.hocon
View File

@ -1,354 +0,0 @@
emqx_bridge_kafka {
connect_timeout.desc:
"""建立 TCP 连接时的最大等待时长（若启用认证，这个等待时长也包含完成认证所需时间）。"""
connect_timeout.label:
"""连接超时"""
producer_opts.desc:
"""本地 MQTT 数据源和 Kafka 桥接的配置。"""
producer_opts.label:
"""MQTT 到 Kafka"""
min_metadata_refresh_interval.desc:
"""刷新 Kafka broker 和 Kafka 主题元数据段最短时间间隔。设置太小可能会增加 Kafka 压力。"""
min_metadata_refresh_interval.label:
"""元数据刷新最小间隔"""
kafka_producer.desc:
"""Kafka Producer 配置。"""
kafka_producer.label:
"""Kafka Producer"""
producer_buffer.desc:
"""配置消息缓存的相关参数。
当 EMQX 需要发送的消息超过 Kafka 处理能力，或者当 Kafka 临时下线时，EMQX 内部会将消息缓存起来。"""
producer_buffer.label:
"""消息缓存"""
socket_send_buffer.desc:
"""TCP socket 的发送缓存调优。默认值是针对高吞吐量的一个推荐值。"""
socket_send_buffer.label:
"""Socket 发送缓存大小"""
desc_name.desc:
"""桥接名字，可读描述"""
desc_name.label:
"""桥接名字"""
consumer_offset_commit_interval_seconds.desc:
"""指定 Kafka 消费组偏移量提交的时间间隔。"""
consumer_offset_commit_interval_seconds.label:
"""偏移提交间隔"""
consumer_max_batch_bytes.desc:
"""设置每次从 Kafka 拉取数据的字节数。如该配置小于 Kafka 消息的大小，可能会影响消费性能。"""
consumer_max_batch_bytes.label:
"""拉取字节数"""
socket_receive_buffer.desc:
"""TCP socket 的收包缓存调优。默认值是针对高吞吐量的一个推荐值。"""
socket_receive_buffer.label:
"""Socket 收包缓存大小"""
consumer_topic_mapping.desc:
"""指定 Kafka 主题和 MQTT 主题之间的映射关系。 应至少包含一项。"""
consumer_topic_mapping.label:
"""主题映射关系"""
producer_kafka_opts.desc:
"""Kafka 生产者参数。"""
producer_kafka_opts.label:
"""生产者参数"""
kafka_topic.desc:
"""Kafka 主题名称"""
kafka_topic.label:
"""Kafka 主题名称"""
consumer_kafka_topic.desc:
"""指定从哪个 Kafka 主题消费消息。"""
consumer_kafka_topic.label:
"""Kafka 主题"""
auth_username_password.desc:
"""基于用户名密码的认证。"""
auth_username_password.label:
"""用户名密码认证"""
auth_sasl_password.desc:
"""SASL 认证的密码。"""
auth_sasl_password.label:
"""密码"""
kafka_message_timestamp.desc:
"""生成 Kafka 消息时间戳的模版。该时间必需是一个整型数值（可以是字符串格式）例如 <code>1661326462115</code> 或 <code>'1661326462115'</code>。当所需的输入字段不存在，或不是一个整型时，则会使用当前系统时间。"""
kafka_message_timestamp.label:
"""消息的时间戳"""
buffer_mode.desc:
"""消息缓存模式。
<code>memory</code>: 所有的消息都缓存在内存里。如果 EMQX 服务重启，缓存的消息会丢失。
<code>disk</code>: 缓存到磁盘上。EMQX 重启后会继续发送重启前未发送完成的消息。
<code>hybrid</code>: 先将消息缓存在内存中，当内存中的消息堆积超过一定限制（配置项 <code>segment_bytes</code> 描述了该限制）后，后续的消息会缓存到磁盘上。与 <code>memory</code> 模式一样，如果 EMQX 服务重启，缓存的消息会丢失。"""
buffer_mode.label:
"""缓存模式"""
consumer_mqtt_qos.desc:
"""转发 MQTT 消息时使用的 QoS。"""
consumer_mqtt_qos.label:
"""QoS"""
consumer_key_encoding_mode.desc:
"""通过 MQTT 转发之前，如何处理 Kafka 消息的 Key。<code>none</code> 使用 Kafka 消息中的 Key 原始值，不进行编码。 注意：在这种情况下，Key 必须是一个有效的 UTF-8 字符串。
<code>base64</code> 对收到的密钥或值使用 base-64 编码。"""
consumer_key_encoding_mode.label:
"""Key 编码模式"""
auth_gssapi_kerberos.desc:
"""使用 GSSAPI/Kerberos 认证。"""
auth_gssapi_kerberos.label:
"""GSSAPI/Kerberos"""
consumer_mqtt_opts.desc:
"""本地 MQTT 消息转发。"""
consumer_mqtt_opts.label:
"""MQTT 转发"""
auth_kerberos_principal.desc:
"""SASL GSSAPI 认证方法的 Kerberos principal，例如 <code>client_name@MY.KERBEROS.REALM.MYDOMAIN.COM</code>注意：这里使用的 realm 需要配置在 EMQX 服务器的 /etc/krb5.conf 中"""
auth_kerberos_principal.label:
"""Kerberos Principal"""
socket_opts.desc:
"""更多 Socket 参数设置。"""
socket_opts.label:
"""Socket 参数"""
consumer_mqtt_topic.desc:
"""设置 Kafka 消息向哪个本地 MQTT 主题转发消息。"""
consumer_mqtt_topic.label:
"""MQTT主题"""
consumer_offset_reset_policy.desc:
"""如不存在偏移量历史记录或历史记录失效，消费者应使用哪个偏移量开始消费。"""
consumer_offset_reset_policy.label:
"""偏移重置策略"""
partition_count_refresh_interval.desc:
"""配置 Kafka 刷新分区数量的时间间隔。
EMQX 发现 Kafka 分区数量增加后，会开始按 <code>partition_strategy<code> 配置，把消息发送到新的分区中。"""
partition_count_refresh_interval.label:
"""分区数量刷新间隔"""
max_batch_bytes.desc:
"""最大消息批量字节数。大多数 Kafka 环境的默认最低值是 1 MB，EMQX 的默认值比 1 MB 更小是因为需要补偿 Kafka 消息编码所需要的额外字节（尤其是当每条消息都很小的情况下）。当单个消息的大小超过该限制时，它仍然会被发送，（相当于该批量中只有单个消息）。"""
max_batch_bytes.label:
"""最大批量字节数"""
required_acks.desc:
"""设置 Kafka leader 在返回给 EMQX 确认之前需要等待多少个 follower 的确认。
<code>all_isr</code>: 需要所有的在线复制者都确认。
<code>leader_only</code>: 仅需要分区 leader 确认。
<code>none</code>: 无需 Kafka 回复任何确认。"""
required_acks.label:
"""Kafka 确认数量"""
metadata_request_timeout.desc:
"""刷新元数据时最大等待时长。"""
metadata_request_timeout.label:
"""元数据请求超时"""
desc_type.desc:
"""桥接类型"""
desc_type.label:
"""桥接类型"""
socket_nodelay.desc:
"""设置‘true’让系统内核立即发送。否则当需要发送的内容很少时，可能会有一定延迟（默认 40 毫秒）。"""
socket_nodelay.label:
"""是否关闭延迟发送"""
authentication.desc:
"""认证参数。"""
authentication.label:
"""认证"""
buffer_memory_overload_protection.desc:
"""缓存模式是 <code>memory</code> 或 <code>hybrid</code> 时适用。当系统处于高内存压力时，从队列中丢弃旧的消息以减缓内存增长。内存压力值由配置项 <code>sysmon.os.sysmem_high_watermark</code> 决定。注意，该配置仅在 Linux 系统中有效。"""
buffer_memory_overload_protection.label:
"""内存过载保护"""
auth_sasl_mechanism.desc:
"""SASL 认证方法名称。"""
auth_sasl_mechanism.label:
"""认证方法"""
config_enable.desc:
"""启用（true）或停用该（false）Kafka 数据桥接。"""
config_enable.label:
"""启用或停用"""
consumer_mqtt_payload.desc:
"""用于转换收到的 Kafka 消息的模板。 默认情况下，它将使用 JSON 格式来序列化来自 Kafka 的所有字段。 这些字段包括：<code>headers</code>：一个包含字符串键值对的 JSON 对象。
<code>key</code>：Kafka 消息的键（使用选择的编码方式编码）。
<code>offset</code>：消息的偏移量。
<code>topic</code>：Kafka 主题。
<code>ts</code>: 消息的时间戳。
<code>ts_type</code>：消息的时间戳类型，值可能是： <code>create</code>， <code>append</code> 或 <code>undefined</code>。
<code>value</code>: Kafka 消息值（使用选择的编码方式编码）。"""
consumer_mqtt_payload.label:
"""MQTT Payload Template"""
consumer_opts.desc:
"""本地 MQTT 转发 和 Kafka 消费者配置。"""
consumer_opts.label:
"""MQTT 到 Kafka"""
kafka_consumer.desc:
"""Kafka 消费者配置。"""
kafka_consumer.label:
"""Kafka 消费者"""
desc_config.desc:
"""Kafka 桥接配置"""
desc_config.label:
"""Kafka 桥接配置"""
consumer_value_encoding_mode.desc:
"""通过 MQTT 转发之前，如何处理 Kafka 消息的 Value。<code>none</code> 使用 Kafka 消息中的 Value 原始值，不进行编码。 注意：在这种情况下，Value 必须是一个有效的 UTF-8 字符串。
<code>base64</code> 对收到的 Value 使用 base-64 编码。"""
consumer_value_encoding_mode.label:
"""Value 编码模式"""
buffer_per_partition_limit.desc:
"""为每个 Kafka 分区设置的最大缓存字节数。当超过这个上限之后，老的消息会被丢弃，为新的消息腾出空间。"""
buffer_per_partition_limit.label:
"""Kafka 分区缓存上限"""
bootstrap_hosts.desc:
"""用逗号分隔的 <code>host[:port]</code> 主机列表。默认端口号为 9092。"""
bootstrap_hosts.label:
"""主机列表"""
consumer_max_rejoin_attempts.desc:
"""消费组成员允许重新加入小组的最大次数。如超过该配置次数后仍未能成功加入消费组，则会在等待一段时间后重试。"""
consumer_max_rejoin_attempts.label:
"""最大的重新加入尝试"""
kafka_message_key.desc:
"""生成 Kafka 消息 Key 的模版。如果模版生成后为空值，则会使用 Kafka 的 <code>NULL</code> ，而非空字符串。"""
kafka_message_key.label:
"""消息的 Key"""
kafka_message.desc:
"""用于生成 Kafka 消息的模版。"""
kafka_message.label:
"""Kafka 消息模版"""
mqtt_topic.desc:
"""MQTT 主题数据源由桥接指定，或留空由规则动作指定。"""
mqtt_topic.label:
"""源 MQTT 主题"""
kafka_message_value.desc:
"""生成 Kafka 消息 Value 的模版。如果模版生成后为空值，则会使用 Kafka 的 <code>NULL</code>，而非空字符串。"""
kafka_message_value.label:
"""消息的 Value"""
partition_strategy.desc:
"""设置消息发布时应该如何选择 Kafka 分区。
<code>random</code>: 为每个消息随机选择一个分区。
<code>key_dispatch</code>: Hash Kafka message key to a partition number"""
partition_strategy.label:
"""分区选择策略"""
buffer_segment_bytes.desc:
"""当缓存模式是 <code>disk</code> 或 <code>hybrid</code> 时适用。该配置用于指定缓存到磁盘上的文件的大小。"""
buffer_segment_bytes.label:
"""缓存文件大小"""
consumer_kafka_opts.desc:
"""Kafka消费者配置。"""
consumer_kafka_opts.label:
"""Kafka 消费者"""
max_inflight.desc:
"""设置 Kafka 生产者（每个分区一个）在收到 Kafka 的确认前最多发送多少个请求（批量）。调大这个值通常可以增加吞吐量，但是，当该值设置大于 1 时存在消息乱序的风险。"""
max_inflight.label:
"""飞行窗口"""
auth_sasl_username.desc:
"""SASL 认证的用户名。"""
auth_sasl_username.label:
"""用户名"""
auth_kerberos_keytab_file.desc:
"""SASL GSSAPI 认证方法的 Kerberos keytab 文件。注意：该文件需要上传到 EMQX 服务器中，且运行 EMQX 服务的系统账户需要有读取权限。"""
auth_kerberos_keytab_file.label:
"""Kerberos keytab 文件"""
compression.desc:
"""压缩方法。"""
compression.label:
"""压缩"""
}

21
rel/i18n/zh/emqx_bridge_mqtt_schema.hocon
View File

@ -1,21 +0,0 @@
emqx_bridge_mqtt_schema {
config.desc:
"""MQTT Bridge 的配置。"""
config.label:
"""配置"""
desc_name.desc:
"""Bridge 名字，Bridge 的可读描述"""
desc_name.label:
"""Bridge 名字"""
desc_type.desc:
"""Bridge 的类型"""
desc_type.label:
"""Bridge 类型"""
}

26
rel/i18n/zh/emqx_bridge_opents.hocon
View File

@ -1,26 +0,0 @@
emqx_bridge_opents {
config_enable.desc:
"""启用/禁用桥接"""
config_enable.label:
"启用/禁用桥接"
desc_config.desc:
"""OpenTSDB 桥接配置"""
desc_config.label:
"OpenTSDB 桥接配置"
desc_type.desc:
"""Bridge 类型"""
desc_type.label:
"桥接类型"
desc_name.desc:
"""桥接名字"""
desc_name.label:
"桥接名字"
}

20
rel/i18n/zh/emqx_bridge_opents_connector.hocon
View File

@ -1,20 +0,0 @@
emqx_bridge_opents_connector {
server.desc:
"""服务器的地址。"""
server.label:
"服务器地址"
summary.desc:
"""是否返回摘要信息。"""
summary.label:
"摘要信息"
details.desc:
"""是否返回详细信息。"""
details.label:
"详细信息"
}

56
rel/i18n/zh/emqx_bridge_oracle.hocon
View File

@ -1,56 +0,0 @@
emqx_bridge_oracle {
local_topic {
desc = "发送到 'local_topic' 的消息都会转发到 Oracle Database。 </br>"
"注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发。"
label = "本地 Topic"
}
sql_template {
desc = "SQL模板。模板字符串可以包含消息元数据和有效载荷字段的占位符。占位符"
"的插入不需要任何检查和特殊格式化，因此必须确保插入的数值格式化和转义正确。模板字符串可以包含占位符"
"模板字符串可以包含消息元数据和有效载荷字段的占位符。这些占位符被插入"
"所以必须确保插入的值的格式正确。因此，确保插入的值格式化和转义正确是非常重要的。模板字符串可以包含占位符"
"模板字符串可以包含消息元数据和有效载荷字段的占位符。这些占位符被插入"
"所以必须确保插入的值的格式正确。确保插入的值被正确地格式化和转义。"
label = "SQL 模板"
}
server {
desc = "将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>"
"主机名具有以下形式：`Host[:Port]`。<br/>"
"如果未指定 `[:Port]`，则使用 Oracle Database 默认端口 1521。"
label = "服务器地址"
}
sid {
desc = "Oracle Database Sid 名称"
label = "Oracle Database Sid"
}
service_name {
desc = "Oracle Database 服务名称。"
label = "Oracle Database 服务名称"
}
config_enable {
desc = "启用/禁用桥接"
label = "启用/禁用桥接"
}
desc_config {
desc = "Oracle Database 桥接配置"
label = "Oracle Database 桥接配置"
}
desc_type {
desc = "Bridge 类型"
label = "桥接类型"
}
desc_name {
desc = "桥接名字"
label = "桥接名字"
}
}

40
rel/i18n/zh/emqx_bridge_pgsql.hocon
View File

@ -1,40 +0,0 @@
emqx_bridge_pgsql {
config_enable.desc:
"""启用/禁用桥接"""
config_enable.label:
"""启用/禁用桥接"""
desc_config.desc:
"""PostgreSQL 桥接配置"""
desc_config.label:
"""PostgreSQL 桥接配置"""
desc_name.desc:
"""桥接名字"""
desc_name.label:
"""桥接名字"""
desc_type.desc:
"""Bridge 类型"""
desc_type.label:
"""桥接类型"""
local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 PostgreSQL。 </br>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发。"""
local_topic.label:
"""本地 Topic"""
sql_template.desc:
"""SQL 模板"""
sql_template.label:
"""SQL 模板"""
}

178
rel/i18n/zh/emqx_bridge_pulsar.hocon
View File

@ -1,178 +0,0 @@
emqx_bridge_pulsar {
pulsar_producer_struct {
desc = "Pulsar 桥接配置"
label = "Pulsar 桥接配置"
}
desc_type {
desc = "桥接类型"
label = "桥接类型"
}
desc_name {
desc = "桥接名字，可读描述"
label = "桥接名字"
}
config_enable {
desc = "启用（true）或停用（false）该 Pulsar 数据桥接。"
label = "启用或停用"
}
connect_timeout {
desc = "建立 TCP 连接时的最大等待时长（若启用认证，这个等待时长也包含完成认证所需时间）。"
label = "连接超时时间"
}
servers {
desc = "以逗号分隔的 <code>scheme://host[:port]</code> 格式的 Pulsar URL 列表，"
"支持的 scheme 有 <code>pulsar://</code> （默认）"
"和<code>pulsar+ssl://</code>。默认的端口是6650。"
label = "服务员"
}
authentication {
desc = "认证参数。"
label = "认证"
}
producer_batch_size {
desc = "在一个Pulsar消息中批处理的单个请求的最大数量。"
label = "批量大小"
}
producer_compression {
desc = "压缩方法。"
label = "压缩"
}
producer_send_buffer {
desc = "TCP socket 的发送缓存调优。默认值是针对高吞吐量的一个推荐值。"
label = "Socket 发送缓存大小"
}
producer_sync_timeout {
desc = "同步发布时，从Pulsar接收发送回执的最长等待时间。"
label = "同步发布超时"
}
auth_basic_username {
desc = "基本认证用户名。"
label = "用户名"
}
auth_basic_password {
desc = "基本认证密码。"
label = "密码"
}
auth_token_jwt {
desc = "JWT认证令牌。"
label = "JWT"
}
producer_max_batch_bytes {
desc = "最大消息批量字节数。"
"大多数 Pulsar 环境的默认最低值是 5 MB，EMQX 的默认值比 5 MB 更小是因为需要"
"补偿 Pulsar 消息编码所需要的额外字节（尤其是当每条消息都很小的情况下）。"
"当单个消息的大小超过该限制时，它仍然会被发送，（相当于该批量中只有单个消息）。"
label = "最大批量字节数"
}
producer_retention_period {
desc = "当没有连接到Pulsar代理时，信息将被缓冲的时间。 较长的时间意味着将使用更多的内存/磁盘"
label = "保留期"
}
producer_local_topic {
desc = "MQTT 主题数据源由桥接指定，或留空由规则动作指定。"
label = "源 MQTT 主题"
}
producer_pulsar_topic {
desc = "Pulsar 主题名称"
label = "Pulsar 主题名称"
}
producer_strategy {
desc = "设置消息发布时应该如何选择 Pulsar 分区。\n\n"
"<code>random</code>: 为每个消息随机选择一个分区。\n"
"<code>roundrobin</code>: 依次为每条信息挑选可用的生产商。\n"
"<code>key_dispatch</code>: 将一批信息中的第一条信息的Pulsar信息密钥哈希到一个分区编号。"
label = "分区选择策略"
}
producer_buffer {
desc = "配置消息缓存的相关参数。\n\n"
"当 EMQX 需要发送的消息超过 Pulsar 处理能力，或者当 Pulsar 临时下线时，EMQX 内部会将消息缓存起来。"
label = "消息缓存"
}
buffer_mode {
desc = "消息缓存模式。\n"
"<code>memory</code>: 所有的消息都缓存在内存里。如果 EMQX 服务重启，缓存的消息会丢失。\n"
"<code>disk</code>: 缓存到磁盘上。EMQX 重启后会继续发送重启前未发送完成的消息。\n"
"<code>hybrid</code>: 先将消息缓存在内存中，当内存中的消息堆积超过一定限制"
"（配置项 <code>segment_bytes</code> 描述了该限制）后，后续的消息会缓存到磁盘上。"
"与 <code>memory</code> 模式一样，如果 EMQX 服务重启，缓存的消息会丢失。"
label = "缓存模式"
}
buffer_per_partition_limit {
desc = "为每个 Pulsar 分区设置的最大缓存字节数。当超过这个上限之后，老的消息会被丢弃，"
"为新的消息腾出空间。"
label = "Pulsar 分区缓存上限"
}
buffer_segment_bytes {
desc = "当缓存模式是 <code>disk</code> 或 <code>hybrid</code> 时适用。"
"该配置用于指定缓存到磁盘上的文件的大小。"
label = "缓存文件大小"
}
buffer_memory_overload_protection {
desc = "缓存模式是 <code>memory</code> 或 <code>hybrid</code> 时适用。"
"当系统处于高内存压力时，从队列中丢弃旧的消息以减缓内存增长。"
"内存压力值由配置项 <code>sysmon.os.sysmem_high_watermark</code> 决定。"
"注意，该配置仅在 Linux 系统中有效。"
label = "内存过载保护"
}
producer_message_opts {
desc = "用于生成 Pulsar 消息的模版。"
label = "Pulsar 消息模版"
}
producer_key_template {
desc = "生成 Pulsar 消息 Key 的模版。"
label = "消息的 Key"
}
producer_value_template {
desc = "生成 Pulsar 消息 Value 的模版。"
label = "消息的 Value"
}
auth_basic {
desc = "基本认证的参数。"
label = "基本认证参数"
}
auth_token {
desc = "令牌认证的参数。"
label = "Token auth params"
}
producer_buffer {
desc = "配置消息缓存的相关参数。\n\n"
"当 EMQX 需要发送的消息超过 Pulsar 处理能力，或者当 Pulsar 临时下线时，EMQX 内部会将消息缓存起来。"
label = "消息缓存"
}
producer_pulsar_message {
desc = "用于生成 Pulsar 消息的模版。"
label = "Pulsar 消息模版"
}
}

43
rel/i18n/zh/emqx_bridge_rocketmq.hocon
View File

@ -1,43 +0,0 @@
emqx_bridge_rocketmq {
config_enable.desc:
"""启用/禁用桥接"""
config_enable.label:
"""启用/禁用桥接"""
desc_config.desc:
"""RocketMQ 桥接配置"""
desc_config.label:
"""RocketMQ 桥接配置"""
desc_name.desc:
"""桥接名字"""
desc_name.label:
"""桥接名字"""
desc_type.desc:
"""Bridge 类型"""
desc_type.label:
"""桥接类型"""
local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 RocketMQ。 </br>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发。"""
local_topic.label:
"""本地 Topic"""
template.desc:
"""模板, 默认为空，为空时将会将整个消息转发给 RocketMQ。 <br>
模板可以是任意带有占位符的合法字符串, 例如:<br>
- ${id}, ${username}, ${clientid}, ${timestamp}<br>
- {"id" : ${id}, "username" : ${username}}"""
template.label:
"""模板"""
}

53
rel/i18n/zh/emqx_bridge_rocketmq_connector.hocon
View File

@ -1,53 +0,0 @@
emqx_bridge_rocket_connector {
access_key.desc:
"""RocketMQ 服务器的 `accessKey`。"""
access_key.label:
"""AccessKey"""
refresh_interval.desc:
"""RocketMQ 主题路由更新间隔。"""
refresh_interval.label:
"""主题路由更新间隔"""
secret_key.desc:
"""RocketMQ 服务器的 `secretKey`。"""
secret_key.label:
"""SecretKey"""
security_token.desc:
"""RocketMQ 服务器安全令牌"""
security_token.label:
"""安全令牌"""
send_buffer.desc:
"""RocketMQ 驱动的套字节发送消息的缓冲区大小"""
send_buffer.label:
"""发送消息的缓冲区大小"""
servers.desc:
"""将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>
主机名具有以下形式：`Host[:Port]`。<br/>
如果未指定 `[:Port]`，则使用 RocketMQ 默认端口 9876。"""
servers.label:
"""服务器地址"""
sync_timeout.desc:
"""RocketMQ 驱动同步调用的超时时间。"""
sync_timeout.label:
"""同步调用超时时间"""
topic.desc:
"""RocketMQ 主题"""
topic.label:
"""RocketMQ 主题"""
}

158
rel/i18n/zh/emqx_bridge_schema.hocon
View File

@ -1,158 +0,0 @@
emqx_bridge_schema {
bridges_mqtt.desc:
"""桥接到另一个 MQTT Broker 的 MQTT Bridge"""
bridges_mqtt.label:
"""MQTT Bridge"""
bridges_webhook.desc:
"""转发消息到 HTTP 服务器的 WebHook"""
bridges_webhook.label:
"""WebHook"""
desc_bridges.desc:
"""MQTT Bridge 配置"""
desc_bridges.label:
"""MQTT Bridge 配置"""
desc_enable.desc:
"""启用/禁用 Bridge"""
desc_enable.label:
"""启用/禁用 Bridge"""
desc_metrics.desc:
"""Bridge 计数"""
desc_metrics.label:
"""Bridge 计数"""
desc_node_metrics.desc:
"""节点的计数器"""
desc_node_metrics.label:
"""节点的计数器"""
desc_node_name.desc:
"""节点的名字"""
desc_node_name.label:
"""节点名字"""
desc_node_status.desc:
"""节点的状态"""
desc_node_status.label:
"""节点的状态"""
desc_status.desc:
"""Bridge 的连接状态<br/>
- <code>connecting</code>: 启动时的初始状态。<br/>
- <code>connected</code>: 桥接驱动健康检查正常。<br/>
- <code>disconnected</code>: 当桥接无法通过健康检查。<br/>
- <code>stopped</code>: 桥接处于停用状态。<br/>
- <code>inconsistent</code>: 集群中有各节点汇报的状态不一致。"""
desc_status.label:
"""Bridge 状态"""
desc_status_reason.desc:
"""桥接连接失败的原因。"""
desc_status_reason.label:
"""失败原因"""
metric_dropped.desc:
"""被丢弃的消息个数。"""
metric_dropped.label:
"""丢弃"""
metric_dropped_other.desc:
"""因为其他原因被丢弃的消息个数。"""
metric_dropped_other.label:
"""其他丢弃"""
metric_dropped_queue_full.desc:
"""因为队列已满被丢弃的消息个数。"""
metric_dropped_queue_full.label:
"""队列已满被丢弃"""
metric_dropped_resource_not_found.desc:
"""因为资源不存在被丢弃的消息个数。"""
metric_dropped_resource_not_found.label:
"""资源不存在被丢弃"""
metric_dropped_resource_stopped.desc:
"""因为资源已停用被丢弃的消息个数。"""
metric_dropped_resource_stopped.label:
"""资源停用被丢弃"""
metric_inflight.desc:
"""已异步地发送但没有收到 ACK 的消息个数。"""
metric_inflight.label:
"""已发送未确认"""
metric_matched.desc:
"""Bridge 被匹配到（被请求）的次数。"""
metric_matched.label:
"""匹配次数"""
metric_queuing.desc:
"""当前被缓存到磁盘队列的消息个数。"""
metric_queuing.label:
"""被缓存"""
metric_rate.desc:
"""执行操作的速率，次/秒"""
metric_rate.label:
"""速率"""
metric_rate_last5m.desc:
"""5 分钟平均速率，次/秒"""
metric_rate_last5m.label:
"""5 分钟平均速率"""
metric_rate_max.desc:
"""执行操作的最大速率，次/秒"""
metric_rate_max.label:
"""执行操作的最大速率"""
metric_received.desc:
"""从远程系统收到的消息个数。"""
metric_received.label:
"""已接收"""
metric_retried.desc:
"""重试的次数。"""
metric_retried.label:
"""已重试"""
metric_sent_failed.desc:
"""发送失败的消息个数。"""
metric_sent_failed.label:
"""发送失败"""
metric_sent_success.desc:
"""已经发送成功的消息个数。"""
metric_sent_success.label:
"""发送成功"""
}

46
rel/i18n/zh/emqx_bridge_sqlserver.hocon
View File

@ -1,46 +0,0 @@
emqx_bridge_sqlserver {
config_enable.desc:
"""启用/禁用桥接"""
config_enable.label:
"""启用/禁用桥接"""
desc_config.desc:
"""Microsoft SQL Server 桥接配置"""
desc_config.label:
"""Microsoft SQL Server 桥接配置"""
desc_name.desc:
"""桥接名字"""
desc_name.label:
"""桥接名字"""
desc_type.desc:
"""Bridge 类型"""
desc_type.label:
"""桥接类型"""
driver.desc:
"""SQL Server Driver 名称"""
driver.label:
"""SQL Server Driver 名称"""
local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 Microsoft SQL Server。 </br>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发。"""
local_topic.label:
"""本地 Topic"""
sql_template.desc:
"""SQL 模板"""
sql_template.label:
"""SQL 模板"""
}

11
rel/i18n/zh/emqx_bridge_sqlserver_connector.hocon
View File

@ -1,11 +0,0 @@
emqx_bridge_sqlserver_connector {
server.desc:
"""将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>
主机名具有以下形式：`Host[:Port]`。<br/>
如果未指定 `[:Port]`，则使用 SQL Server 默认端口 1433。"""
server.label:
"""服务器地址"""
}

40
rel/i18n/zh/emqx_bridge_tdengine.hocon
View File

@ -1,40 +0,0 @@
emqx_bridge_tdengine {
config_enable.desc:
"""启用/禁用桥接"""
config_enable.label:
"""启用/禁用桥接"""
desc_config.desc:
"""TDengine 桥接配置"""
desc_config.label:
"""TDengine 桥接配置"""
desc_name.desc:
"""桥接名字"""
desc_name.label:
"""桥接名字"""
desc_type.desc:
"""Bridge 类型"""
desc_type.label:
"""桥接类型"""
local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 TDengine。 </br>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发。"""
local_topic.label:
"""本地 Topic"""
sql_template.desc:
"""SQL 模板"""
sql_template.label:
"""SQL 模板"""
}

11
rel/i18n/zh/emqx_bridge_tdengine_connector.hocon
View File

@ -1,11 +0,0 @@
emqx_bridge_tdengine_connector {
server.desc:
"""将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>
主机名具有以下形式：`Host[:Port]`。<br/>
如果未指定 `[:Port]`，则使用 TDengine 默认端口 6041。"""
server.label:
"""服务器地址"""
}

87
rel/i18n/zh/emqx_bridge_webhook_schema.hocon
View File

@ -1,87 +0,0 @@
emqx_bridge_webhook_schema {
config_body.desc:
"""HTTP 请求的正文。<br/>
如果没有设置该字段，请求正文将是包含所有可用字段的 JSON object。<br/>
如果该 webhook 是由于收到 MQTT 消息触发的，'所有可用字段' 将是 MQTT 消息的
上下文信息；如果该 webhook 是由于规则触发的，'所有可用字段' 则为触发事件的上下文信息。<br/>
允许使用带有变量的模板。"""
config_body.label:
"""HTTP 请求正文"""
config_direction.desc:
"""已废弃，Bridge 的方向，必须是 egress"""
config_direction.label:
"""Bridge 方向"""
config_enable.desc:
"""启用/禁用 Bridge"""
config_enable.label:
"""启用/禁用 Bridge"""
config_headers.desc:
"""HTTP 请求的标头。<br/>
允许使用带有变量的模板。"""
config_headers.label:
"""HTTP 请求标头"""
config_local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 HTTP 服务器。 <br/>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发到 HTTP 服务器。"""
config_local_topic.label:
"""本地 Topic"""
config_max_retries.desc:
"""HTTP 请求失败最大重试次数"""
config_max_retries.label:
"""HTTP 请求重试次数"""
config_method.desc:
"""HTTP 请求的方法。 所有可用的方法包括：post、put、get、delete。<br/>
允许使用带有变量的模板。"""
config_method.label:
"""HTTP 请求方法"""
config_request_timeout.desc:
"""HTTP 请求超时"""
config_request_timeout.label:
"""HTTP 请求超时"""
config_url.desc:
"""HTTP Bridge 的 URL。<br/>
路径中允许使用带变量的模板，但是 host， port 不允许使用变量模板。<br/>
例如，<code> http://localhost:9901/${topic} </code> 是允许的，
但是<code> http://${host}:9901/message </code>
或 <code> http://localhost:${port}/message </code>
不允许。"""
config_url.label:
"""HTTP Bridge"""
desc_config.desc:
"""HTTP Bridge 配置"""
desc_config.label:
"""HTTP Bridge 配置"""
desc_name.desc:
"""Bridge 名字，Bridge 的可读描述"""
desc_name.label:
"""Bridge 名字"""
desc_type.desc:
"""Bridge 类型"""
desc_type.label:
"""Bridge 类型"""
}

27
rel/i18n/zh/emqx_coap_api.hocon
View File

@ -1,27 +0,0 @@
emqx_coap_api {
content_type.desc:
"""Payload 类型"""
message_id.desc:
"""消息 ID"""
method.desc:
"""请求 Method 类型"""
payload.desc:
"""Payload 内容"""
response_code.desc:
"""应答码"""
send_coap_request.desc:
"""发送 CoAP 消息到指定客户端"""
timeout.desc:
"""请求超时时间"""
token.desc:
"""消息 Token, 可以为空"""
}

37
rel/i18n/zh/emqx_coap_schema.hocon
View File

@ -1,37 +0,0 @@
emqx_coap_schema {
coap.desc:
"""CoAP 网关配置。
该网关的实现基于 RFC-7252 和 https://core-wg.github.io/coap-pubsub/draft-ietf-core-pubsub.html"""
coap_connection_required.desc:
"""是否开启连接模式。
连接模式是非标准协议的功能。它维护 CoAP 客户端上线、认证、和连接状态的保持"""
coap_heartbeat.desc:
"""CoAP 网关要求客户端的最小心跳间隔时间。
当 <code>connection_required</code> 开启后，该参数用于检查客户端连接是否存活"""
coap_notify_type.desc:
"""投递给 CoAP 客户端的通知消息类型。当客户端 Observe 一个资源（或订阅某个主题）时，网关会向客户端推送新产生的消息。其消息类型可设置为：<br/>
- non: 不需要客户端返回确认消息;<br/>
- con: 需要客户端返回一个确认消息;<br/>
- qos: 取决于消息的 QoS 等级; QoS 0 会以 `non` 类型下发，QoS 1/2 会以 `con` 类型下发"""
coap_publish_qos.desc:
"""客户端发布请求的默认 QoS 等级。
当 CoAP 客户端发起发布请求时，如果未携带 `qos` 参数则会使用该默认值。默认值可设置为：<br>
- qos0、qos1、qos2: 设置为固定的 QoS 等级<br/>
- coap: 依据发布操作的 CoAP 报文类型来动态决定<br/>
* 当发布请求为 `non-confirmable` 类型时，取值为 qos0<br/>
* 当发布请求为 `confirmable` 类型时，取值为 qos1"""
coap_subscribe_qos.desc:
"""客户端订阅请求的默认 QoS 等级。
当 CoAP 客户端发起订阅请求时，如果未携带 `qos` 参数则会使用该默认值。默认值可设置为：<br/>
- qos0、 qos1、qos2: 设置为固定的 QoS 等级<br/>
- coap: 依据订阅操作的 CoAP 报文类型来动态决定<br/>
* 当订阅请求为 `non-confirmable` 类型时，取值为 qos0<br/>
* 当订阅请求为 `confirmable` 类型时，取值为 qos1"""
}

775
rel/i18n/zh/emqx_conf_schema.hocon
View File

@ -1,775 +0,0 @@
emqx_conf_schema {
common_handler_drop_mode_qlen.desc:
"""当缓冲的日志事件数大于此值时，新的日志事件将被丢弃。起到过载保护的功能。
为了使过载保护算法正常工作必须要：<code> sync_mode_qlen =< drop_mode_qlen =< flush_qlen </code> 且 drop_mode_qlen > 1
要禁用某些模式，请执行以下操作。
- 如果sync_mode_qlen被设置为0，所有的日志事件都被同步处理。也就是说，异步日志被禁用。
- 如果sync_mode_qlen被设置为与drop_mode_qlen相同的值，同步模式被禁用。也就是说，处理程序总是以异步模式运行，除非调用drop或flushing。
- 如果drop_mode_qlen被设置为与flush_qlen相同的值，则drop模式被禁用，永远不会发生。"""
common_handler_drop_mode_qlen.label:
"""进入丢弃模式的队列长度"""
cluster_mcast_addr.desc:
"""指定多播 IPv4 地址。
当 cluster.discovery_strategy 为 mcast 时，此配置项才有效。"""
cluster_mcast_addr.label:
"""多播地址"""
desc_cluster_dns.desc:
"""DNS SRV 记录服务发现。"""
desc_cluster_dns.label:
"""DNS SRV 记录服务发现"""
cluster_dns_name.desc:
"""指定 DNS A 记录的名字。emqx 会通过访问这个 DNS A 记录来获取 IP 地址列表。
当<code>cluster.discovery_strategy</code> 为 <code>dns</code> 时有效。"""
cluster_dns_name.label:
"""DNS名称"""
rpc_keyfile.desc:
"""<code>rpc.certfile</code> 的私钥文件的路径。<br/>
注意：此文件内容是私钥，所以需要设置权限为 600。"""
rpc_keyfile.label:
"""RPC 私钥文件"""
cluster_mcast_recbuf.desc:
"""接收数据报的内核级缓冲区的大小。
当 cluster.discovery_strategy 为 mcast 时，此配置项才有效。"""
cluster_mcast_recbuf.label:
"""多播接收数据缓冲区"""
cluster_autoheal.desc:
"""集群脑裂自动恢复机制开关。"""
cluster_autoheal.label:
"""节点脑裂自动修复机制"""
log_overload_kill_enable.desc:
"""日志处理进程过载时为保护自己节点其它的业务能正常，强制杀死日志处理进程。"""
log_overload_kill_enable.label:
"""日志处理进程过载保护"""
node_etc_dir.desc:
"""<code>etc</code> 存放目录"""
node_etc_dir.label:
"""Etc 目录"""
cluster_proto_dist.desc:
"""分布式 Erlang 集群协议类型。可选值为:<br/>
- inet_tcp: 使用 IPv4 <br/>
- inet_tls: 使用 TLS，需要配合 <code>etc/ssl_dist.conf</code> 一起使用。"""
cluster_proto_dist.label:
"""集群内部通信协议"""
log_burst_limit_enable.desc:
"""启用日志限流保护机制。"""
log_burst_limit_enable.label:
"""日志限流保护"""
dist_buffer_size.desc:
"""Erlang分布式缓冲区的繁忙阈值，单位是KB。"""
dist_buffer_size.label:
"""Erlang分布式缓冲区的繁忙阈值(KB)"""
common_handler_max_depth.desc:
"""Erlang 内部格式日志格式化和 Erlang 进程消息队列检查的最大深度。"""
common_handler_max_depth.label:
"""最大深度"""
desc_log.desc:
"""EMQX 支持同时多个日志输出，一个控制台输出，和多个文件输出。
默认情况下，EMQX 运行在容器中，或者在 'console' 或 'foreground' 模式下运行时，会输出到 控制台，否则输出到文件。"""
desc_log.label:
"""日志"""
common_handler_flush_qlen.desc:
"""如果缓冲日志事件的数量增长大于此阈值，则会发生冲刷（删除）操作。 日志处理进程会丢弃缓冲的日志消息。
来缓解自身不会由于内存瀑涨而影响其它业务进程。日志内容会提醒有多少事件被删除。"""
common_handler_flush_qlen.label:
"""冲刷阈值"""
common_handler_chars_limit.desc:
"""设置单个日志消息的最大长度。 如果超过此长度，则日志消息将被截断。最小可设置的长度为100。
注意：如果日志格式为 JSON，限制字符长度可能会导致截断不完整的 JSON 数据。"""
common_handler_chars_limit.label:
"""单条日志长度限制"""
cluster_k8s_namespace.desc:
"""当使用 k8s 方式并且 cluster.k8s.address_type 指定为 dns 类型时，
可设置 emqx 节点名的命名空间。与 cluster.k8s.suffix 一起使用用以拼接得到节点名列表。"""
cluster_k8s_namespace.label:
"""K8s 命名空间"""
node_name.desc:
"""节点名。格式为 \<name>@\<host>。其中 <host> 可以是 IP 地址，也可以是 FQDN。
详见 http://erlang.org/doc/reference_manual/distributed.html。"""
node_name.label:
"""节点名"""
rpc_port_discovery.desc:
"""<code>manual</code>: 通过 <code>tcp_server_port</code> 来发现端口。
<br/><code>stateless</code>: 使用无状态的方式来发现端口，使用如下算法。如果节点名称是 <code>
emqxN@127.0.0.1</code>, N 是一个数字，那么监听端口就是 5370 + N。"""
rpc_port_discovery.label:
"""RPC 端口发现策略"""
log_overload_kill_restart_after.desc:
"""处理进程停止后，会在该延迟时间后自动重新启动。除非该值设置为 <code>infinity</code>，这会阻止任何后续的重启。"""
log_overload_kill_restart_after.label:
"""处理进程重启延迟"""
log_file_handler_max_size.desc:
"""此参数控制日志文件轮换。 `infinity` 意味着日志文件将无限增长，否则日志文件将在达到 `max_size`（以字节为单位）时进行轮换。
与 rotation count配合使用。如果 counter 为 10，则是10个文件轮换。"""
log_file_handler_max_size.label:
"""日志文件轮换大小"""
desc_log_file_handler.desc:
"""日志处理进程将日志事件打印到文件。"""
desc_log_file_handler.label:
"""文件日志处理进程"""
rpc_socket_keepalive_count.desc:
"""keepalive 探测消息发送失败的次数，直到 RPC 连接被认为已经断开。"""
rpc_socket_keepalive_count.label:
"""RPC Socket Keepalive 次数"""
cluster_etcd_server.desc:
"""指定 etcd 服务的地址。如有多个服务使用逗号 , 分隔。
当 cluster.discovery_strategy 为 etcd 时，此配置项才有效。"""
cluster_etcd_server.label:
"""Etcd 服务器地址"""
db_backend.desc:
"""配置后端数据库驱动，默认值为 <code>rlog</code> 它适用于大规模的集群。
<code>mnesia</code> 是备选数据库，适合中小集群。"""
db_backend.label:
"""内置数据库"""
desc_authorization.desc:
"""授权相关"""
desc_authorization.label:
"""授权"""
cluster_etcd_ssl.desc:
"""当使用 TLS 连接 etcd 时的配置选项。
当 cluster.discovery_strategy 为 etcd 时，此配置项才有效。"""
cluster_etcd_ssl.label:
"""Etcd SSL 选项"""
rpc_insecure_fallback.desc:
"""兼容旧的无鉴权模式"""
rpc_insecure_fallback.label:
"""向后兼容旧的无鉴权模式"""
cluster_mcast_buffer.desc:
"""用户级缓冲区的大小。
当 cluster.discovery_strategy 为 mcast 时，此配置项才有效。"""
cluster_mcast_buffer.label:
"""多播用户级缓冲区"""
rpc_authentication_timeout.desc:
"""远程节点认证的超时时间。"""
rpc_authentication_timeout.label:
"""RPC 认证超时时间"""
cluster_call_retry_interval.desc:
"""当集群间调用出错时，多长时间重试一次。"""
cluster_call_retry_interval.label:
"""重试时间间隔"""
cluster_mcast_sndbuf.desc:
"""外发数据报的内核级缓冲区的大小。
当 cluster.discovery_strategy 为 mcast 时，此配置项才有效。"""
cluster_mcast_sndbuf.label:
"""多播发送缓存区"""
rpc_driver.desc:
"""集群间通信使用的传输协议。"""
rpc_driver.label:
"""RPC 驱动"""
max_ets_tables.desc:
"""Erlang ETS 表的最大数量"""
max_ets_tables.label:
"""Erlang 表的最大数量"""
desc_db.desc:
"""内置数据库的配置。"""
desc_db.label:
"""数据库"""
desc_cluster_etcd.desc:
"""使用 'etcd' 服务的服务发现。"""
desc_cluster_etcd.label:
"""'etcd' 服务的服务发现"""
cluster_name.desc:
"""EMQX集群名称。每个集群都有一个唯一的名称。服务发现时会用于做路径的一部分。"""
cluster_name.label:
"""集群名称"""
log_rotation_enable.desc:
"""启用日志轮换功能。启动后生成日志文件后缀会加上对应的索引数字，比如：log/emqx.log.1。
系统会默认生成<code>*.siz/*.idx</code>用于记录日志位置，请不要手动修改这两个文件。"""
log_rotation_enable.label:
"""日志轮换"""
cluster_call_cleanup_interval.desc:
"""清理过期事务的时间间隔"""
cluster_call_cleanup_interval.label:
"""清理间隔"""
desc_cluster_static.desc:
"""静态节点服务发现。新节点通过连接一个节点来加入集群。"""
desc_cluster_static.label:
"""静态节点服务发现"""
db_default_shard_transport.desc:
"""定义用于推送事务日志的默认传输。<br/>
这可以在 <code>db.shard_transports</code> 中基于每个分片被覆盖。
<code>gen_rpc</code> 使用 <code>gen_rpc</code> 库，
<code>distr</code> 使用 Erlang 发行版。"""
db_default_shard_transport.label:
"""事务日志传输默认协议"""
cluster_static_seeds.desc:
"""集群中的EMQX节点名称列表，
指定固定的节点列表，多个节点间使用逗号 , 分隔。
当 cluster.discovery_strategy 为 static 时，此配置项才有效。
适合于节点数量较少且固定的集群。"""
cluster_static_seeds.label:
"""集群静态节点"""
log_overload_kill_qlen.desc:
"""允许的最大队列长度。"""
log_overload_kill_qlen.label:
"""最大队列长度"""
node_backtrace_depth.desc:
"""错误信息中打印的最大堆栈层数"""
node_backtrace_depth.label:
"""最大堆栈导数"""
desc_log_burst_limit.desc:
"""短时间内产生的大量日志事件可能会导致问题，例如：
- 日志文件变得非常大
- 日志文件轮换过快，有用信息被覆盖
- 对系统的整体性能影响
日志突发限制功能可以暂时禁用日志记录以避免这些问题。"""
desc_log_burst_limit.label:
"""日志突发限制"""
common_handler_enable.desc:
"""启用此日志处理进程。"""
common_handler_enable.label:
"""启用日志处理进程"""
cluster_k8s_service_name.desc:
"""指定 Kubernetes 中 EMQX 的服务名。
当 cluster.discovery_strategy 为 k8s 时，此配置项才有效。"""
cluster_k8s_service_name.label:
"""K8s 服务别名"""
log_rotation_count.desc:
"""轮换的最大日志文件数。"""
log_rotation_count.label:
"""最大日志文件数"""
node_cookie.desc:
"""分布式 Erlang 集群使用的 cookie 值。集群间保持一致"""
node_cookie.label:
"""节点 Cookie"""
db_role.desc:
"""选择节点的角色。<br/>
<code>core</code> 节点提供数据的持久性，并负责写入。建议将核心节点放置在不同的机架或不同的可用区。<br/>
<code>repliant</code> 节点是临时工作节点。 从集群中删除它们，不影响数据库冗余<br/>
建议复制节点多于核心节点。<br/>
注意：该参数仅在设置<code>backend</code>时生效到 <code>rlog</code>。"""
db_role.label:
"""数据库角色"""
rpc_tcp_server_port.desc:
"""RPC 本地服务使用的 TCP 端口。<br/>
只有当 rpc.port_discovery 设置为 manual 时，此配置才会生效。"""
rpc_tcp_server_port.label:
"""RPC TCP 服务监听端口"""
desc_console_handler.desc:
"""日志处理进程将日志事件打印到 EMQX 控制台。"""
desc_console_handler.label:
"""Console Handler"""
node_applications.desc:
"""当新EMQX 加入集群时，应重启的Erlang应用程序的列表。"""
node_applications.label:
"""应用"""
log_burst_limit_max_count.desc:
"""在 `window_time` 间隔内处理的最大日志事件数。 达到限制后，将丢弃连续事件，直到 `window_time` 结束。"""
log_burst_limit_max_count.label:
"""日志事件数"""
rpc_tcp_client_num.desc:
"""设置本节点与远程节点之间的 RPC 通信通道的最大数量。"""
rpc_tcp_client_num.label:
"""RPC TCP 客户端数量"""
cluster_k8s_address_type.desc:
"""当使用 k8s 方式集群时，address_type 用来从 Kubernetes 接口的应答里获取什么形式的 Host 列表。
指定 <code>cluster.k8s.address_type</code> 为 <code>ip</code>，则将从 Kubernetes 接口中获取集群中其他节点
的IP地址。"""
cluster_k8s_address_type.label:
"""K8s 地址类型"""
rpc_socket_sndbuf.desc:
"""TCP 调节参数。TCP 发送缓冲区大小。"""
rpc_socket_sndbuf.label:
"""RPC 套接字发送缓冲区大小"""
cluster_mcast_ttl.desc:
"""指定多播的 Time-To-Live 值。
当 cluster.discovery_strategy 为 mcast 时，此配置项才有效。"""
cluster_mcast_ttl.label:
"""多播TTL"""
db_core_nodes.desc:
"""当前节点连接的核心节点列表。<br/>
注意：该参数仅在设置<code>backend</code>时生效到 <code>rlog</code>
并且设置<code>role</code>为<code>replicant</code>时生效。<br/>
该值需要在手动或静态集群发现机制下设置。<br/>
如果使用了自动集群发现机制（如<code>etcd</code>），则不需要设置该值。"""
db_core_nodes.label:
"""数据库核心节点"""
log_file_handler_file.desc:
"""日志文件路径及名字。"""
log_file_handler_file.label:
"""日志文件名字"""
node_dist_net_ticktime.desc:
"""系统调优参数，此配置将覆盖 vm.args 文件里的 -kernel net_ticktime 参数。当一个节点持续无响应多久之后，认为其已经宕机并断开连接。"""
node_dist_net_ticktime.label:
"""节点间心跳间隔"""
desc_cluster_k8s.desc:
"""Kubernetes 服务发现。"""
desc_cluster_k8s.label:
"""Kubernetes 服务发现"""
desc_cluster_mcast.desc:
"""UDP 组播服务发现。"""
desc_cluster_mcast.label:
"""UDP 组播服务发现"""
rpc_cacertfile.desc:
"""验证 <code>rpc.certfile</code> 的 CA 证书文件的路径。<br/>
注意：集群中所有节点的证书必须使用同一个 CA 签发。"""
rpc_cacertfile.label:
"""RPC CA 证书文件"""
desc_node.desc:
"""节点名称、Cookie、配置文件、数据目录和 Erlang 虚拟机（BEAM）启动参数。"""
desc_node.label:
"""节点"""
cluster_k8s_apiserver.desc:
"""指定 Kubernetes API Server。如有多个 Server 使用逗号 , 分隔。
当 cluster.discovery_strategy 为 k8s 时，此配置项才有效。"""
cluster_k8s_apiserver.label:
"""K8s 服务地址"""
common_handler_supervisor_reports.desc:
"""Supervisor 报告的类型。默认为 error 类型。<br/>
- <code>error</code>：仅记录 Erlang 进程中的错误。
- <code>progress</code>：除了 error 信息外，还需要记录进程启动的详细信息。"""
common_handler_supervisor_reports.label:
"""报告类型"""
node_data_dir.desc:
"""节点数据存放目录，可能会自动创建的子目录如下：<br/>
- `mnesia/<node_name>`。EMQX的内置数据库目录。例如，`mnesia/emqx@127.0.0.1`。<br/>
如果节点要被重新命名（例如，`emqx@10.0.1.1`）。旧目录应该首先被删除。<br/>
- `configs`。在启动时生成的配置，以及集群/本地覆盖的配置。<br/>
- `patches`: 热补丁文件将被放在这里。<br/>
- `trace`: 日志跟踪文件。<br/>
**注意**: 一个数据dir不能被两个或更多的EMQX节点同时使用。"""
node_data_dir.label:
"""节点数据目录"""
cluster_k8s_suffix.desc:
"""当使用 k8s 方式并且 cluster.k8s.address_type 指定为 dns 类型时，可设置 emqx 节点名的后缀。
与 cluster.k8s.namespace 一起使用用以拼接得到节点名列表。"""
cluster_k8s_suffix.label:
"""K8s 前缀"""
db_rpc_module.desc:
"""集群间推送事务日志到复制节点使用的协议。"""
db_rpc_module.label:
"""RPC协议"""
cluster_etcd_prefix.desc:
"""指定 etcd 路径的前缀。每个节点在 etcd 中都会创建一个路径:
v2/keys/<prefix>/<cluster.name>/<node.name> <br/>
当 cluster.discovery_strategy 为 etcd 时，此配置项才有效。"""
cluster_etcd_prefix.label:
"""Etcd 路径前缀"""
cluster_mcast_iface.desc:
"""指定节点发现服务需要绑定到本地 IP 地址。
当 cluster.discovery_strategy 为 mcast 时，此配置项才有效。"""
cluster_mcast_iface.label:
"""多播绑定地址"""
log_burst_limit_window_time.desc:
"""参考 <code>max_count</code>。"""
log_burst_limit_window_time.label:
"""Window Time"""
cluster_dns_record_type.desc:
"""DNS 记录类型。"""
cluster_dns_record_type.label:
"""DNS记录类型"""
cluster_autoclean.desc:
"""指定多久之后从集群中删除离线节点。"""
cluster_autoclean.label:
"""自动删除离线节点时间"""
process_limit.desc:
"""Erlang系统同时存在的最大进程数。
实际选择的最大值可能比设置的数字大得多。
参考: https://www.erlang.org/doc/man/erl.html"""
process_limit.label:
"""Erlang 最大进程数"""
max_ports.desc:
"""Erlang系统同时存在的最大端口数。
实际选择的最大值可能比设置的数字大得多。
参考: https://www.erlang.org/doc/man/erl.html"""
max_ports.label:
"""Erlang 最大端口数"""
desc_log_rotation.desc:
"""默认情况下，日志存储在 `./log` 目录（用于从 zip 文件安装）或 `/var/log/emqx`（用于二进制安装）。<br/>
这部分配置，控制每个日志处理进程保留的文件数量。"""
desc_log_rotation.label:
"""日志轮换"""
desc_log_overload_kill.desc:
"""日志过载终止，具有过载保护功能。当日志处理进程使用过多内存，或者缓存的日志消息过多时该功能被激活。<br/>
检测到过载时，日志处理进程将终止，并在冷却期后重新启动。"""
desc_log_overload_kill.label:
"""日志过载保护"""
authorization.desc:
"""授权（ACL）。EMQX 支持完整的客户端访问控制（ACL）。"""
authorization.label:
"""授权"""
rpc_socket_keepalive_idle.desc:
"""broker 之间的连接在最后一条消息发送后保持打开的时间。"""
rpc_socket_keepalive_idle.label:
"""RPC Socket Keepalive Idle"""
desc_cluster_call.desc:
"""集群调用功能的选项。"""
desc_cluster_call.label:
"""集群调用"""
cluster_mcast_ports.desc:
"""指定多播端口。如有多个端口使用逗号 , 分隔。
当 cluster.discovery_strategy 为 mcast 时，此配置项才有效。"""
cluster_mcast_ports.label:
"""多播端口"""
log_overload_kill_mem_size.desc:
"""日志处理进程允许使用的最大内存。"""
log_overload_kill_mem_size.label:
"""日志处理进程允许使用的最大内存"""
rpc_connect_timeout.desc:
"""建立 RPC 连接的超时时间。"""
rpc_connect_timeout.label:
"""RPC 连接超时时间"""
cluster_etcd_node_ttl.desc:
"""指定 etcd 中节点信息的过期时间。
当 cluster.discovery_strategy 为 etcd 时，此配置项才有效。"""
cluster_etcd_node_ttl.label:
"""Etcd 节点过期时间"""
rpc_call_receive_timeout.desc:
"""同步 RPC 的回复超时时间。"""
rpc_call_receive_timeout.label:
"""RPC 调用接收超时时间"""
rpc_socket_recbuf.desc:
"""TCP 调节参数。TCP 接收缓冲区大小。"""
rpc_socket_recbuf.label:
"""RPC 套接字接收缓冲区大小"""
db_tlog_push_mode.desc:
"""同步模式下，核心节点等待复制节点的确认信息，然后再发送下一条事务日志。"""
db_tlog_push_mode.label:
"""Tlog推送模式"""
node_crash_dump_bytes.desc:
"""限制崩溃文件的大小，当崩溃时节点内存太大，
如果为了保存现场，需要全部存到崩溃文件中，此处限制最多能保存多大的文件。
如果超过此限制，崩溃转储将被截断。如果设置为0，系统不会尝试写入崩溃转储文件。"""
node_crash_dump_bytes.label:
"""崩溃文件最大容量"""
rpc_certfile.desc:
"""TLS 证书文件的路径，用于验证集群节点的身份。
只有当 <code>rpc.driver</code> 设置为 <code>ssl</code> 时，此配置才会生效。"""
rpc_certfile.label:
"""RPC 证书文件"""
node_crash_dump_seconds.desc:
"""该配置给出了运行时系统允许花费的写入崩溃转储的秒数。当给定的秒数已经过去，运行时系统将被终止。<br/>
- 如果设置为0秒，运行时会立即终止，不会尝试写入崩溃转储文件。<br/>
- 如果设置为一个正数 S，节点会等待 S 秒来完成崩溃转储文件，然后用SIGALRM信号终止运行时系统。<br/>
- 如果设置为一个负值导致运行时系统的终止等待无限期地直到崩溃转储文件已经完全写入。"""
node_crash_dump_seconds.label:
"""保存崩溃文件最长时间"""
log_file_handlers.desc:
"""输出到文件的日志处理进程列表"""
log_file_handlers.label:
"""File Handler"""
node_global_gc_interval.desc:
"""系统调优参数，设置节点运行多久强制进行一次全局垃圾回收。禁用设置为 <code>disabled</code>。"""
node_global_gc_interval.label:
"""全局垃圾回收"""
common_handler_time_offset.desc:
"""日志中的时间戳使用的时间偏移量。
可选值为：
- <code>system</code>: 本地系统使用的时区偏移量
- <code>utc</code>: 0 时区的偏移量
- <code>+-[hh]:[mm]</code>: 自定义偏移量，比如 "-02:00" 或者 "+00:00"
默认值为本地系统的时区偏移量：<code>system</code>。"""
common_handler_time_offset.label:
"""时间偏移量"""
rpc_mode.desc:
"""在 <code>sync</code> 模式下，发送端等待接收端的 ack信号。"""
rpc_mode.label:
"""RPC 模式"""
node_crash_dump_file.desc:
"""设置 Erlang crash_dump 文件的存储路径和文件名。"""
node_crash_dump_file.label:
"""节点崩溃时的Dump文件"""
cluster_mcast_loop.desc:
"""设置多播的报文是否投递到本地回环地址。
当 cluster.discovery_strategy 为 mcast 时，此配置项才有效。"""
cluster_mcast_loop.label:
"""多播回环开关"""
rpc_socket_keepalive_interval.desc:
"""keepalive 消息的间隔。"""
rpc_socket_keepalive_interval.label:
"""RPC Socket Keepalive 间隔"""
common_handler_level.desc:
"""当前日志处理进程的日志级别。
默认为 warning 级别。"""
common_handler_level.label:
"""日志级别"""
desc_rpc.desc:
"""EMQX 使用 <code>gen_rpc</code> 库来实现跨节点通信。<br/>
大多数情况下，默认的配置应该可以工作，但如果你需要做一些性能优化或者实验，可以尝试调整这些参数。"""
desc_rpc.label:
"""RPC"""
rpc_ssl_server_port.desc:
"""RPC 本地服务使用的监听SSL端口。<br/>
只有当 rpc.port_discovery 设置为 manual 且 <code> dirver </code> 设置为 <code>ssl</code>，
此配置才会生效。"""
rpc_ssl_server_port.label:
"""RPC SSL 服务监听端口"""
desc_cluster.desc:
"""EMQX 节点可以组成一个集群，以提高总容量。<br/> 这里指定了节点之间如何连接。"""
desc_cluster.label:
"""集群"""
common_handler_sync_mode_qlen.desc:
"""只要缓冲的日志事件的数量低于这个值，所有的日志事件都会被异步处理。
这意味着，日志落地速度不会影响正常的业务进程，因为它们不需要等待日志处理进程的响应。
如果消息队列的增长超过了这个值，处理程序开始同步处理日志事件。也就是说，发送事件的客户进程必须等待响应。
当处理程序将消息队列减少到低于sync_mode_qlen阈值的水平时，异步操作就会恢复。
默认为100条信息，当等待的日志事件大于100条时，就开始同步处理日志。"""
common_handler_sync_mode_qlen.label:
"""进入异步模式的队列长度"""
common_handler_formatter.desc:
"""选择日志格式类型。 <code>text</code> 用于纯文本，<code>json</code> 用于结构化日志记录。"""
common_handler_formatter.label:
"""日志格式类型"""
rpc_async_batch_size.desc:
"""异步模式下，发送的批量消息的最大数量。"""
rpc_async_batch_size.label:
"""异步模式下的批量消息数量"""
cluster_call_max_history.desc:
"""集群间调用最多保留的历史记录数。只用于排错时查看。"""
cluster_call_max_history.label:
"""最大历史记录"""
cluster_discovery_strategy.desc:
"""集群节点发现方式。可选值为:
- manual: 使用 <code>emqx ctl cluster</code> 命令管理集群。<br/>
- static: 配置静态节点。配置几个固定的节点，新节点通过连接固定节点中的某一个来加入集群。<br/>
- dns: 使用 DNS A 记录的方式发现节点。<br/>
- etcd: 使用 etcd 发现节点。<br/>
- k8s: 使用 Kubernetes API 发现节点。"""
cluster_discovery_strategy.label:
"""集群服务发现策略"""
rpc_send_timeout.desc:
"""发送 RPC 请求的超时时间。"""
rpc_send_timeout.label:
"""RPC 发送超时时间"""
common_handler_single_line.desc:
"""如果设置为 true，则单行打印日志。 否则，日志消息可能跨越多行。"""
common_handler_single_line.label:
"""单行模式"""
rpc_socket_buffer.desc:
"""TCP 调节参数。用户模式套接字缓冲区大小。"""
rpc_socket_buffer.label:
"""RPC 套接字缓冲区大小"""
db_shard_transports.desc:
"""允许为每个 shard 下的事务日志复制操作的传输方法进行调优。<br/>
<code>gen_rpc</code> 使用 <code>gen_rpc</code> 库，
<code>distr</code> 使用 Erlang 自带的 rpc 库。<br/>如果未指定，
默认是使用 <code>db.default_shard_transport</code> 中设置的值。"""
db_shard_transports.label:
"""事务日志传输协议"""
}

46
rel/i18n/zh/emqx_connector_api.hocon
View File

@ -1,46 +0,0 @@
emqx_connector_api {
conn_get.desc:
"""列出所有连接器"""
conn_get.label:
"""列出所有连接器"""
conn_id_delete.desc:
"""通过 ID 删除一个连接器"""
conn_id_delete.label:
"""删除连接器"""
conn_id_get.desc:
"""通过 ID 获取连接器"""
conn_id_get.label:
"""获取连接器"""
conn_id_put.desc:
"""通过 ID 更新一个连接器"""
conn_id_put.label:
"""更新连接器"""
conn_post.desc:
"""创建一个新的连接器"""
conn_post.label:
"""创建连接器"""
conn_test_post.desc:
"""通过给定的 ID 测试创建一个新的连接器 <br/>
ID 的格式必须为“{type}:{name}”"""
conn_test_post.label:
"""创建测试连接器"""
id.desc:
"""连接器 ID， 格式必须为 {type}:{name}"""
id.label:
"""连接器 ID"""
}

69
rel/i18n/zh/emqx_connector_http.hocon
View File

@ -1,69 +0,0 @@
emqx_connector_http {
body.desc:
"""HTTP请求报文主体。"""
body.label:
"""HTTP请求报文主体"""
connect_timeout.desc:
"""连接HTTP服务器的超时时间。"""
connect_timeout.label:
"""连接超时"""
enable_pipelining.desc:
"""正整数，设置最大可发送的异步 HTTP 请求数量。当设置为 1 时，表示每次发送完成 HTTP 请求后都需要等待服务器返回，再继续发送下一个请求。"""
enable_pipelining.label:
"""HTTP 管道"""
headers.desc:
"""HTTP 头字段列表。"""
headers.label:
"""HTTP 头字段列表"""
max_retries.desc:
"""请求出错时的最大重试次数。"""
max_retries.label:
"""最大重试次数"""
method.desc:
"""HTTP 请求方法。"""
method.label:
"""HTTP 请求方法"""
path.desc:
"""HTTP请求路径。"""
path.label:
"""HTTP请求路径"""
pool_size.desc:
"""连接池大小。"""
pool_size.label:
"""连接池大小"""
pool_type.desc:
"""连接池的类型，可用类型有`random`, `hash`。"""
pool_type.label:
"""连接池类型"""
request.desc:
"""设置 HTTP 请求的参数。"""
request.label:
"""HTTP 请求"""
request_timeout.desc:
"""HTTP 请求超时。"""
request_timeout.label:
"""HTTP 请求超时"""
}

21
rel/i18n/zh/emqx_connector_ldap.hocon
View File

@ -1,21 +0,0 @@
emqx_connector_ldap {
bind_dn.desc:
"""LDAP 绑定的 DN 的值"""
bind_dn.label:
"""Bind DN"""
port.desc:
"""LDAP 端口"""
port.label:
"""端口"""
timeout.desc:
"""LDAP 查询超时时间"""
timeout.label:
"""超时时间"""
}

152
rel/i18n/zh/emqx_connector_mongo.hocon
View File

@ -1,152 +0,0 @@
emqx_connector_mongo {
auth_source.desc:
"""与用户证书关联的数据库名称。"""
auth_source.label:
"""认证源"""
connect_timeout.desc:
"""超时重连的等待时间。"""
connect_timeout.label:
"""连接超时"""
desc_rs.desc:
"""配置 Replica Set"""
desc_rs.label:
"""配置 Replica Set"""
desc_sharded.desc:
"""配置 Sharded Cluster"""
desc_sharded.label:
"""配置 Sharded Cluster"""
desc_single.desc:
"""配置 Single 模式"""
desc_single.label:
"""配置 Single 模式"""
desc_topology.desc:
"""配置 Topology"""
desc_topology.label:
"""配置 Topology"""
heartbeat_period.desc:
"""控制驱动程序何时检查MongoDB部署的状态。指定检查的间隔时间，从上一次检查结束到下一次检查开始计算。如果连接数增加（例如，如果你增加池子的大小，就会发生这种情况），你可能也需要增加这个周期，以避免在MongoDB日志文件中创建太多的日志条目。"""
heartbeat_period.label:
"""心跳期"""
local_threshold.desc:
"""在多个合适的MongoDB实例中进行选择的延迟窗口的大小。"""
local_threshold.label:
"""本地阈值"""
max_overflow.desc:
"""最大溢出。"""
max_overflow.label:
"""最大溢出"""
min_heartbeat_period.desc:
"""心跳间的最小间隙"""
min_heartbeat_period.label:
"""最小心跳周期"""
overflow_check_period.desc:
"""检查是否有超过配置的工人的周期（"溢出"）。"""
overflow_check_period.label:
"""溢出检查周期"""
overflow_ttl.desc:
"""当池内工人太多时，等待多久清除多余工人。"""
overflow_ttl.label:
"""溢出TTL"""
r_mode.desc:
"""读模式。"""
r_mode.label:
"""读模式"""
replica_set_name.desc:
"""副本集的名称。"""
replica_set_name.label:
"""副本集名称"""
rs_mongo_type.desc:
"""Replica set模式。当 MongoDB 服务运行在 replica-set 模式下，该配置必须设置为 'rs'。"""
rs_mongo_type.label:
"""Replica set 模式"""
server.desc:
"""将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>
主机名具有以下形式：`Host[:Port]`。<br/>
如果未指定 `[:Port]`，则使用 MongoDB 默认端口 27017。"""
server.label:
"""服务器地址"""
server_selection_timeout.desc:
"""指定在抛出异常之前为服务器选择阻断多长时间。"""
server_selection_timeout.label:
"""服务器选择超时"""
servers.desc:
"""集群将要连接的节点列表。 节点之间用逗号分隔，如：`Node[,Node].`
每个节点的配置为：将要连接的 IPv4 或 IPv6 地址或主机名。
主机名具有以下形式：`Host[:Port]`。
如果未指定 `[:Port]`，则使用 MongoDB 默认端口 27017。"""
servers.label:
"""服务器列表"""
sharded_mongo_type.desc:
"""Sharded cluster模式。当 MongoDB 服务运行在 sharded 模式下，该配置必须设置为 'sharded'。"""
sharded_mongo_type.label:
"""Sharded cluster 模式"""
single_mongo_type.desc:
"""Standalone 模式。当 MongoDB 服务运行在 standalone 模式下，该配置必须设置为 'single'。"""
single_mongo_type.label:
"""Standalone 模式"""
socket_timeout.desc:
"""在尝试超时之前，在套接字上尝试发送或接收的持续时间。"""
socket_timeout.label:
"""套接字操作超时"""
srv_record.desc:
"""使用 DNS SRV 记录。"""
srv_record.label:
"""SRV 记录"""
w_mode.desc:
"""写模式。"""
w_mode.label:
"""写模式"""
wait_queue_timeout.desc:
"""工作者等待连接可用的最长时间。"""
wait_queue_timeout.label:
"""等待队列超时"""
}

21
rel/i18n/zh/emqx_connector_mqtt.hocon
View File

@ -1,21 +0,0 @@
emqx_connector_mqtt {
name.desc:
"""连接器名称，人类可读的连接器描述。"""
name.label:
"""连接器名称"""
num_of_bridges.desc:
"""当前使用此连接器的网桥数量。"""
num_of_bridges.label:
"""网桥数量"""
type.desc:
"""连接器类型。"""
type.label:
"""连接器类型"""
}

170
rel/i18n/zh/emqx_connector_mqtt_schema.hocon
View File

@ -1,170 +0,0 @@
emqx_connector_mqtt_schema {
bridge_mode.desc:
"""是否启用 Bridge Mode。
注意：此设置只针对 MQTT 协议版本 < 5.0 有效，并且需要远程 MQTT Broker 支持 Bridge Mode。
如果设置为 true ，桥接会告诉远端服务器当前连接是一个桥接而不是一个普通的客户端。
这意味着消息回环检测会更加高效，并且远端服务器收到的保留消息的标志位会透传给本地。"""
bridge_mode.label:
"""Bridge 模式"""
clean_start.desc:
"""与 ingress MQTT 桥的远程服务器重连时是否清除老的 MQTT 会话。"""
clean_start.label:
"""清除会话"""
clientid_prefix.desc:
"""可选的前缀，用于在出口网桥使用的clientid前加上前缀。"""
clientid_prefix.label:
"""客户ID前缀"""
egress_desc.desc:
"""出口配置定义了该桥接如何将消息从本地 Broker 转发到远程 Broker。
以下字段中允许使用带有变量的模板：'remote.topic', 'local.qos', 'local.retain', 'local.payload'。<br/>
注意：如果此桥接被用作规则的动作，并且配置了 'local.topic'，则从规则输出的数据以及匹配到 'local.topic' 的 MQTT 消息都会被转发。"""
egress_desc.label:
"""出方向配置"""
egress_local.desc:
"""如何从本地 Broker 接收消息相关的配置。"""
egress_local.label:
"""本地配置"""
egress_local_topic.desc:
"""要转发到远程broker的本地主题"""
egress_local_topic.label:
"""本地主题"""
egress_remote.desc:
"""发送消息到远程 Broker 相关的配置。"""
egress_remote.label:
"""远程配置"""
egress_remote_qos.desc:
"""待发送 MQTT 消息的 QoS。<br/>
允许使用带有变量的模板。"""
egress_remote_qos.label:
"""远程 QoS"""
egress_remote_topic.desc:
"""转发到远程broker的哪个topic。<br/>
允许使用带有变量的模板。"""
egress_remote_topic.label:
"""远程主题"""
ingress_desc.desc:
"""入口配置定义了该桥接如何从远程 MQTT Broker 接收消息，然后将消息发送到本地 Broker。<br/>
以下字段中允许使用带有变量的模板：'remote.qos', 'local.topic', 'local.qos', 'local.retain', 'local.payload'。<br/>
注意：如果此桥接被用作规则的输入，并且配置了 'local.topic'，则从远程代理获取的消息将同时被发送到 'local.topic' 和规则。"""
ingress_desc.label:
"""入方向配置"""
ingress_local.desc:
"""发送消息到本地 Broker 相关的配置。"""
ingress_local.label:
"""本地配置"""
ingress_local_qos.desc:
"""待发送 MQTT 消息的 QoS。<br/>
允许使用带有变量的模板。"""
ingress_local_qos.label:
"""本地 QoS"""
ingress_local_topic.desc:
"""向本地broker的哪个topic发送消息。<br/>
允许使用带有变量的模板。"""
ingress_local_topic.label:
"""本地主题"""
ingress_remote.desc:
"""订阅远程 Broker 相关的配置。"""
ingress_remote.label:
"""远程配置"""
ingress_remote_qos.desc:
"""订阅远程borker时要使用的 QoS 级别"""
ingress_remote_qos.label:
"""远程 QoS"""
ingress_remote_topic.desc:
"""从远程broker的哪个topic接收消息"""
ingress_remote_topic.label:
"""远程主题"""
max_inflight.desc:
"""MQTT 协议的最大飞行（已发送但未确认）消息"""
max_inflight.label:
"""最大飞行消息"""
mode.desc:
"""MQTT 桥的模式。 <br/>
- cluster_shareload：在 emqx 集群的每个节点上创建一个 MQTT 连接。<br/>
在“cluster_shareload”模式下，来自远程代理的传入负载通过共享订阅的方式接收。<br/>
请注意，<code>clientid</code> 以节点名称为后缀，这是为了避免不同节点之间的 <code> clientid</code> 冲突。
而且对于入口连接的 <code>remote.topic</code>，我们只能使用共享订阅主题过滤器。"""
mode.label:
"""MQTT 桥接模式"""
password.desc:
"""MQTT 协议的密码"""
password.label:
"""密码"""
payload.desc:
"""要发送的 MQTT 消息的负载。<br/>
允许使用带有变量的模板。"""
payload.label:
"""消息负载"""
proto_ver.desc:
"""MQTT 协议版本"""
proto_ver.label:
"""协议版本"""
retain.desc:
"""要发送的 MQTT 消息的“保留”标志。<br/>
允许使用带有变量的模板。"""
retain.label:
"""保留消息标志"""
server.desc:
"""远程 MQTT Broker的主机和端口。"""
server.label:
"""Broker主机和端口"""
server_configs.desc:
"""服务器相关的配置。"""
server_configs.label:
"""服务配置。"""
username.desc:
"""MQTT 协议的用户名"""
username.label:
"""用户名"""
}

11
rel/i18n/zh/emqx_connector_mysql.hocon
View File

@ -1,11 +0,0 @@
emqx_connector_mysql {
server.desc:
"""将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>
主机名具有以下形式：`Host[:Port]`。<br/>
如果未指定 `[:Port]`，则使用 MySQL 默认端口 3306。"""
server.label:
"""服务器地址"""
}

11
rel/i18n/zh/emqx_connector_pgsql.hocon
View File

@ -1,11 +0,0 @@
emqx_connector_pgsql {
server.desc:
"""将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>
主机名具有以下形式：`Host[:Port]`。<br/>
如果未指定 `[:Port]`，则使用 PostgreSQL 默认端口 5432。"""
server.label:
"""服务器地址"""
}

50
rel/i18n/zh/emqx_connector_redis.hocon
View File

@ -1,50 +0,0 @@
emqx_connector_redis {
cluster.desc:
"""集群模式。当 Redis 服务运行在集群模式下，该配置必须设置为 'cluster'。"""
cluster.label:
"""集群模式"""
database.desc:
"""Redis 数据库 ID。"""
database.label:
"""数据库 ID"""
sentinel.desc:
"""哨兵模式。当 Redis 服务运行在哨兵模式下，该配置必须设置为 'sentinel'。"""
sentinel.label:
"""哨兵模式"""
sentinel_desc.desc:
"""Redis 哨兵模式下的集群名称。"""
sentinel_desc.label:
"""集群名称"""
server.desc:
"""将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>
主机名具有以下形式：`Host[:Port]`。<br/>
如果未指定 `[:Port]`，则使用 Redis 默认端口 6379。"""
server.label:
"""服务器地址"""
servers.desc:
"""集群将要连接的节点列表。 节点之间用逗号分隔，如：`Node[,Node].`
每个节点的配置为：将要连接的 IPv4 或 IPv6 地址或主机名。
主机名具有以下形式：`Host[:Port]`。
如果未指定 `[:Port]`，则使用 Redis 默认端口 6379。"""
servers.label:
"""服务器列表"""
single.desc:
"""单机模式。当 Redis 服务运行在单机模式下，该配置必须设置为 'single'。"""
single.label:
"""单机模式"""
}

45
rel/i18n/zh/emqx_connector_schema_lib.hocon
View File

@ -1,45 +0,0 @@
emqx_connector_schema_lib {
auto_reconnect.desc:
"""已弃用。自动重连数据库。"""
auto_reconnect.label:
"""已弃用。自动重连数据库"""
database_desc.desc:
"""数据库名字。"""
database_desc.label:
"""数据库名字"""
password.desc:
"""内部数据库密码。"""
password.label:
"""密码"""
pool_size.desc:
"""桥接远端服务时使用的连接池大小。"""
pool_size.label:
"""连接池大小"""
prepare_statement.desc:
"""SQL 预处理语句列表。"""
prepare_statement.label:
"""SQL 预处理语句列表"""
ssl.desc:
"""启用 SSL 连接。"""
ssl.label:
"""启用SSL"""
username.desc:
"""内部数据库的用户名。"""
username.label:
"""用户名"""
}

66
rel/i18n/zh/emqx_dashboard_api.hocon
View File

@ -1,66 +0,0 @@
emqx_dashboard_api {
change_pwd_api.desc:
"""更改 Dashboard 用户密码"""
create_user_api.desc:
"""创建 Dashboard 用户"""
create_user_api_success.desc:
"""创建 Dashboard 用户成功"""
delete_user_api.desc:
"""删除 Dashboard 用户"""
license.desc:
"""EMQX 许可类型。可为 opensource 或 enterprise"""
list_users_api.desc:
"""Dashboard 用户列表"""
login_api.desc:
"""获取 Dashboard 认证 Token。"""
login_failed401.desc:
"""登录失败。用户名或密码错误"""
login_failed_response400.desc:
"""登录失败。用户名或密码错误"""
login_success.desc:
"""Dashboard 认证成功"""
logout_api.desc:
"""Dashboard 用户登出"""
new_pwd.desc:
"""新密码"""
old_pwd.desc:
"""旧密码"""
password.desc:
"""Dashboard 密码"""
token.desc:
"""Dashboard 认证 Token"""
update_user_api.desc:
"""更新 Dashboard 用户描述"""
update_user_api200.desc:
"""更新 Dashboard 用户成功"""
user_description.desc:
"""Dashboard 用户描述"""
username.desc:
"""Dashboard 用户名"""
users_api404.desc:
"""Dashboard 用户不存在"""
version.desc:
"""EMQX 版本"""
}

130
rel/i18n/zh/emqx_dashboard_schema.hocon
View File

@ -1,130 +0,0 @@
emqx_dashboard_schema {
backlog.desc:
"""排队等待连接的队列的最大长度。"""
backlog.label:
"""排队长度"""
bind.desc:
"""监听地址和端口，热更新此配置时，会重启 Dashboard 服务。"""
bind.label:
"""绑定端口"""
bootstrap_users_file.desc:
"""已废弃，请使用 api_key.bootstrap_file。"""
bootstrap_users_file.label:
"""已废弃"""
cors.desc:
"""支持跨域资源共享(CORS)，
允许服务器指示任何来源(域名、协议或端口)，除了本服务器之外的任何浏览器应允许加载资源。"""
cors.label:
"""跨域资源共享"""
default_password.desc:
"""Dashboard 的默认密码，为了安全，应该尽快修改密码。
当通过网页首次登录 Dashboard 并按提示修改成复杂密码后，此值就会失效。"""
default_password.label:
"""默认密码"""
default_username.desc:
"""Dashboard 的默认用户名。"""
default_username.label:
"""默认用户名"""
desc_dashboard.desc:
"""EMQX Dashboard 配置。"""
desc_dashboard.label:
"""Dashboard"""
desc_http.desc:
"""Dashboard 监听器(HTTP)配置。"""
desc_http.label:
"""HTTP"""
desc_https.desc:
"""Dashboard 监听器(HTTPS)配置。"""
desc_https.label:
"""HTTPS"""
desc_listeners.desc:
"""Dashboard 监听器配置。"""
desc_listeners.label:
"""监听器"""
i18n_lang.desc:
"""设置 Swagger 多语言的版本，可为 en 或 zh。"""
i18n_lang.label:
"""多语言支持"""
inet6.desc:
"""启用IPv6， 如果机器不支持IPv6，请关闭此选项，否则会导致 Dashboard 无法使用。"""
inet6.label:
"""IPv6"""
ipv6_v6only.desc:
"""当开启 inet6 功能的同时禁用 IPv4-to-IPv6 映射。该配置仅在 inet6 功能开启时有效。"""
ipv6_v6only.label:
"""IPv6 only"""
listener_enable.desc:
"""忽略或启用该监听器。"""
listener_enable.label:
"""启用"""
listeners.desc:
"""Dashboard 监听器设置。监听器必须有唯一的端口号和IP地址的组合。
例如，可以通过指定IP地址 0.0.0.0 来监听机器上给定端口上的所有配置的IP地址。
或者，可以为每个监听器指定唯一的IP地址，但使用相同的端口。"""
listeners.label:
"""监听器"""
max_connections.desc:
"""同时处理的最大连接数。"""
max_connections.label:
"""最大连接数"""
num_acceptors.desc:
"""TCP协议的Socket acceptor池大小, 默认设置在线的调度器数量（通常为 CPU 核数）"""
num_acceptors.label:
"""Acceptor 数量"""
proxy_header.desc:
"""开启对 `HAProxy` 的支持，注意：一旦开启了这个功能，就无法再处理普通的 HTTP 请求了。"""
proxy_header.label:
"""开启对 `HAProxy` 的支持"""
sample_interval.desc:
"""Dashboard 中图表指标的时间间隔。必须小于60，且被60的整除，默认设置 10s。"""
send_timeout.desc:
"""Socket发送超时时间。"""
send_timeout.label:
"""发送超时时间"""
token_expired_time.desc:
"""JWT token 过期时间。默认设置为 60 分钟。"""
token_expired_time.label:
"""JWT 过期时间"""
}

72
rel/i18n/zh/emqx_delayed_api.hocon
View File

@ -1,72 +0,0 @@
emqx_delayed_api {
bad_msgid_format.desc:
"""消息 ID 格式错误"""
count.desc:
"""延迟消息总数"""
delayed_interval.desc:
"""延迟时间(秒)"""
delayed_remaining.desc:
"""剩余时间(秒)"""
delete_api.desc:
"""删除延迟消息"""
expected_at.desc:
"""期望的发送时间, RFC 3339 格式"""
from_clientid.desc:
"""消息的 ClientID"""
from_username.desc:
"""消息的 Username"""
get_message_api.desc:
"""查看延迟消息"""
illegality_limit.desc:
"""数量上限不合法"""
list_api.desc:
"""查看延迟消息列表"""
msgid.desc:
"""延迟消息 ID"""
msgid_not_found.desc:
"""未找到对应消息"""
node.desc:
"""消息的来源节点"""
payload.desc:
"""消息内容, base64 格式。如果消息的大小超过 2048 字节，则消息内容会被设置为 'PAYLOAD_TO_LARGE'"""
publish_at.desc:
"""客户端发送时间, RFC 3339 格式"""
qos.desc:
"""QoS"""
topic.desc:
"""主题"""
update_api.desc:
"""开启或者关闭功能，或者设置延迟消息数量上限"""
update_success.desc:
"""开启或者关闭功能操作成功"""
view_limit.desc:
"""每页数量"""
view_page.desc:
"""查看的页数"""
view_status_api.desc:
"""查看慢订阅状态"""
}

40
rel/i18n/zh/emqx_ee_bridge_cassa.hocon
View File

@ -1,40 +0,0 @@
emqx_ee_bridge_cassa {
config_enable.desc:
"""启用/禁用桥接"""
config_enable.label:
"""启用/禁用桥接"""
cql_template.desc:
"""CQL 模板"""
cql_template.label:
"""CQL 模板"""
desc_config.desc:
"""Cassandra 桥接配置"""
desc_config.label:
"""Cassandra 桥接配置"""
desc_name.desc:
"""桥接名字"""
desc_name.label:
"""桥接名字"""
desc_type.desc:
"""Bridge 类型"""
desc_type.label:
"""桥接类型"""
local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 Cassandra。 </br>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发。"""
local_topic.label:
"""本地 Topic"""
}

52
rel/i18n/zh/emqx_ee_bridge_hstreamdb.hocon
View File

@ -1,52 +0,0 @@
emqx_ee_bridge_hstreamdb {
config_direction.desc:
"""桥接的方向， 必须是 egress"""
config_direction.label:
"""桥接方向"""
config_enable.desc:
"""启用/禁用桥接"""
config_enable.label:
"""启用/禁用桥接"""
desc_config.desc:
"""HStreamDB 桥接配置"""
desc_config.label:
"""HStreamDB 桥接配置"""
desc_connector.desc:
"""连接器的通用配置。"""
desc_connector.label:
"""连接器通用配置。"""
desc_name.desc:
"""桥接名字，可读描述"""
desc_name.label:
"""桥接名字"""
desc_type.desc:
"""Bridge 类型"""
desc_type.label:
"""桥接类型"""
local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 HStreamDB。 </br>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发到 HStreamDB。"""
local_topic.label:
"""本地 Topic"""
payload.desc:
"""要转发到 HStreamDB 的数据内容，支持占位符"""
payload.label:
"""消息内容"""
}

57
rel/i18n/zh/emqx_ee_bridge_mongodb.hocon
View File

@ -1,57 +0,0 @@
emqx_ee_bridge_mongodb {
collection.desc:
"""数据将被存储到的集合"""
collection.label:
"""将要使用的集合（Collection）"""
desc_config.desc:
"""为MongoDB桥配置"""
desc_config.label:
"""MongoDB桥配置"""
desc_name.desc:
"""桥接名称。"""
desc_name.label:
"""桥接名称"""
desc_type.desc:
"""桥接类型。"""
desc_type.label:
"""桥接类型"""
enable.desc:
"""启用或停用该MongoDB桥"""
enable.label:
"""启用或禁用"""
mongodb_rs_conf.desc:
"""MongoDB（Replica Set）配置"""
mongodb_rs_conf.label:
"""MongoDB（Replica Set）配置"""
mongodb_sharded_conf.desc:
"""MongoDB (Sharded)配置"""
mongodb_sharded_conf.label:
"""MongoDB (Sharded)配置"""
mongodb_single_conf.desc:
"""MongoDB（独立）配置"""
mongodb_single_conf.label:
"""MongoDB（独立）配置"""
payload_template.desc:
"""用于格式化写入 MongoDB 的消息模板。 如果未定义，规则引擎会使用 JSON 格式序列化所有的可见输入，例如 clientid, topic, payload 等。"""
payload_template.label:
"""有效载荷模板"""
}

40
rel/i18n/zh/emqx_ee_bridge_mysql.hocon
View File

@ -1,40 +0,0 @@
emqx_ee_bridge_mysql {
config_enable.desc:
"""启用/禁用桥接"""
config_enable.label:
"""启用/禁用桥接"""
desc_config.desc:
"""HStreamDB 桥接配置"""
desc_config.label:
"""HStreamDB 桥接配置"""
desc_name.desc:
"""桥接名字，可读描述"""
desc_name.label:
"""桥接名字"""
desc_type.desc:
"""Bridge 类型"""
desc_type.label:
"""桥接类型"""
local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 MySQL。 </br>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发。"""
local_topic.label:
"""本地 Topic"""
sql_template.desc:
"""SQL 模板"""
sql_template.label:
"""SQL 模板"""
}

41
rel/i18n/zh/emqx_ee_bridge_redis.hocon
View File

@ -1,41 +0,0 @@
emqx_ee_bridge_redis {
command_template.desc:
"""用于推送数据的 Redis 命令模板。 每个列表元素代表一个命令名称或其参数。
例如，要通过键值 `msgs` 将消息体推送到 Redis 列表中，数组元素应该是： `rpush`, `msgs`, `${payload}`。"""
command_template.label:
"""Redis Command 模板"""
config_enable.desc:
"""启用/禁用桥接"""
config_enable.label:
"""启用/禁用桥接"""
desc_config.desc:
"""Resis 桥接配置"""
desc_config.label:
"""Redis 桥接配置"""
desc_name.desc:
"""桥接名字，可读描述"""
desc_name.label:
"""桥接名字"""
desc_type.desc:
"""Bridge 类型"""
desc_type.label:
"""桥接类型"""
local_topic.desc:
"""发送到 'local_topic' 的消息都会转发到 Redis。 </br>
注意：如果这个 Bridge 被用作规则（EMQX 规则引擎）的输出，同时也配置了 'local_topic' ，那么这两部分的消息都会被转发到 Redis。"""
local_topic.label:
"""本地 Topic"""
}

17
rel/i18n/zh/emqx_ee_connector_cassa.hocon
View File

@ -1,17 +0,0 @@
emqx_ee_connector_cassa {
keyspace.desc:
"""要连接到的 Keyspace 名称。"""
keyspace.label:
"""Keyspace"""
servers.desc:
"""将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>
主机名具有以下形式：`Host[:Port][,Host2:Port]`。<br/>
如果未指定 `[:Port]`，则使用 Cassandra 默认端口 9042。"""
servers.label:
"""Servers"""
}

45
rel/i18n/zh/emqx_ee_connector_hstreamdb.hocon
View File

@ -1,45 +0,0 @@
emqx_ee_connector_hstreamdb {
config.desc:
"""HStreamDB 连接配置。"""
config.label:
"""连接配置"""
name.desc:
"""连接器名称，人类可读的连接器描述。"""
name.label:
"""连接器名称"""
ordering_key.desc:
"""HStreamDB 分区键"""
ordering_key.label:
"""HStreamDB 分区键"""
pool_size.desc:
"""HStreamDB 连接池大小"""
pool_size.label:
"""HStreamDB 连接池大小"""
stream_name.desc:
"""HStreamDB 流名称"""
stream_name.label:
"""HStreamDB 流名称"""
type.desc:
"""连接器类型。"""
type.label:
"""连接器类型"""
url.desc:
"""HStreamDB 服务器 URL"""
url.label:
"""HStreamDB 服务器 URL"""
}

39
rel/i18n/zh/emqx_ee_schema_registry_http_api.hocon
View File

@ -1,39 +0,0 @@
emqx_ee_schema_registry_http_api {
desc_param_path_schema_name.desc:
"""模式名称"""
desc_param_path_schema_name.label:
"""模式名称"""
desc_schema_registry_api_delete.desc:
"""删除一个模式"""
desc_schema_registry_api_delete.label:
"""删除模式"""
desc_schema_registry_api_get.desc:
"""通过名称获取模式"""
desc_schema_registry_api_get.label:
"""获取模式"""
desc_schema_registry_api_list.desc:
"""列出所有注册的模式"""
desc_schema_registry_api_list.label:
"""列表模式"""
desc_schema_registry_api_post.desc:
"""注册一个新的模式"""
desc_schema_registry_api_post.label:
"""注册模式"""
desc_schema_registry_api_put.desc:
"""更新一个现有的模式"""
desc_schema_registry_api_put.label:
"""更新模式"""
}

51
rel/i18n/zh/emqx_ee_schema_registry_schema.hocon
View File

@ -1,51 +0,0 @@
emqx_ee_schema_registry_schema {
avro_type.desc:
"""[阿帕奇-阿夫罗](https://avro.apache.org/) 序列化格式。"""
avro_type.label:
"""阿帕奇-阿夫罗"""
protobuf_type.desc:
"""[协议缓冲器](https://protobuf.dev/) 序列化格式。"""
protobuf_type.label:
"""协议缓冲器"""
schema_description.desc:
"""对该模式的描述。"""
schema_description.label:
"""模式描述"""
schema_name.desc:
"""模式的一个名称，将作为其标识符。"""
schema_name.label:
"""模式名称"""
schema_registry_root.desc:
"""模式注册表的配置。"""
schema_registry_root.label:
"""模式注册表"""
schema_registry_schemas.desc:
"""注册的模式。"""
schema_registry_schemas.label:
"""注册的模式"""
schema_source.desc:
"""模式的源文本。"""
schema_source.label:
"""模式来源"""
schema_type.desc:
"""模式类型。"""
schema_type.label:
"""模式类型"""
}

9
rel/i18n/zh/emqx_eviction_agent_api.hocon
View File

@ -1,9 +0,0 @@
emqx_eviction_agent_api {
node_eviction_status_get.desc:
"""获取节点驱逐状态"""
node_eviction_status_get.label:
"""节点驱逐状态"""
}

81
rel/i18n/zh/emqx_exhook_api.hocon
View File

@ -1,81 +0,0 @@
emqx_exhook_api {
add_server.desc:
"""添加 ExHook 服务器"""
delete_server.desc:
"""删除 Exhook 服务器"""
get_detail.desc:
"""查看 Exhook 服务器详细信息"""
get_hooks.desc:
"""获取 Exhook 服务器的钩子信息"""
hook_metrics.desc:
"""当前节点中该钩子的指标信息"""
hook_name.desc:
"""钩子的名称"""
hook_params.desc:
"""钩子注册时使用的参数"""
list_all_servers.desc:
"""查看ExHook 服务器列表"""
metric_failed.desc:
"""钩子执行失败的次数"""
metric_max_rate.desc:
"""钩子的最大调用速率"""
metric_rate.desc:
"""钩子的调用速率"""
metric_succeed.desc:
"""钩子执行成功的次数"""
metrics.desc:
"""指标信息"""
move_api.desc:
"""移动 Exhook 服务器顺序。
注意: 移动的参数只能是：front | rear | before:{name} | after:{name}"""
move_api.label:
"""改变已注册的Exhook服务器的执行顺序"""
move_position.desc:
"""移动的方向"""
node.desc:
"""节点名称"""
node_hook_metrics.desc:
"""所有节点中该钩子的指标信息"""
node_metrics.desc:
"""所有节点中该服务器的指标信息"""
node_status.desc:
"""所有节点中该服务器的状态信息"""
server_metrics.desc:
"""当前节点中该服务器的指标信息"""
server_name.desc:
"""Exhook 服务器的名称"""
status.desc:
"""Exhook 服务器的状态。<br/>
connected: 连接成功<br/>
connecting: 连接失败，重连中<br/>
disconnected: 连接失败，且未设置自动重连<br/>
disabled: 该服务器未开启<br/>
error: 查看该服务器状态时发生错误"""
update_server.desc:
"""更新 Exhook 服务器"""
}

43
rel/i18n/zh/emqx_exhook_schema.hocon
View File

@ -1,43 +0,0 @@
emqx_exhook_schema {
auto_reconnect.desc:
"""自动重连到 gRPC 服务器的设置。
当 gRPC 服务器不可用时，Exhook 将会按照这里设置的间隔时间进行重连，并重新初始化注册的钩子"""
enable.desc:
"""开启这个 Exhook 服务器"""
failed_action.desc:
"""当 gRPC 请求失败后的操作"""
keepalive.desc:
"""当没有其他数据交换时，是否向连接的对端套接字定期的发送探测包。如果另一端没有响应，则认为连接断开，并向控制进程发送错误消息"""
name.desc:
"""ExHook 服务器名称"""
nodelay.desc:
"""如果为 true，则为套接字设置 TCP_NODELAY 选项，这意味着会立即发送数据包"""
pool_size.desc:
"""gRPC 客户端进程池大小"""
recbuf.desc:
"""套接字的最小接收缓冲区大小"""
request_timeout.desc:
"""gRPC 服务器请求超时时间"""
servers.desc:
"""ExHook 服务器列表"""
sndbuf.desc:
"""套接字的最小发送缓冲区大小"""
socket_options.desc:
"""连接套接字设置"""
url.desc:
"""gRPC 服务器地址"""
}

26
rel/i18n/zh/emqx_exproto_schema.hocon
View File

@ -1,26 +0,0 @@
emqx_exproto_schema {
exproto.desc:
"""ExProto 网关"""
exproto_grpc_handler_address.desc:
"""对端 gRPC 服务器地址。"""
exproto_grpc_handler_ssl.desc:
"""gRPC 客户端的 SSL 配置。"""
exproto_grpc_server_bind.desc:
"""服务监听地址和端口。"""
exproto_grpc_server_ssl.desc:
"""服务 SSL 配置。"""
exproto_handler.desc:
"""配置 ExProto 网关需要请求的 <code>ConnectionHandler</code> 服务地址。
该服务用于给 ExProto 提供客户端的 Socket 事件处理、字节解码、订阅消息接收等功能。"""
exproto_server.desc:
"""配置 ExProto 网关需要启动的 <code>ConnectionAdapter</code> 服务。
该服务用于提供客户端的认证、发布、订阅和数据下行等功能。"""
}

73
rel/i18n/zh/emqx_gateway_api.hocon
View File

@ -1,73 +0,0 @@
emqx_gateway_api {
delete_gateway.desc:
"""停用指定网关"""
enable_gateway.desc:
"""使用配置启动某一网关。"""
gateway_created_at.desc:
"""网关创建时间"""
gateway_current_connections.desc:
"""当前连接数"""
gateway_enable_in_path.desc:
"""是否开启此网关"""
gateway_listener_id.desc:
"""监听器 ID"""
gateway_listener_name.desc:
"""监听器名称"""
gateway_listener_running.desc:
"""监听器运行状态"""
gateway_listener_type.desc:
"""监听器类型"""
gateway_listeners.desc:
"""网关监听器列表"""
gateway_max_connections.desc:
"""最大连接数"""
gateway_name.desc:
"""网关名称"""
gateway_name_in_qs.desc:
"""网关名称.<br/>
可取值为 `stomp`、`mqttsn`、`coap`、`lwm2m`、`exproto`"""
gateway_node_status.desc:
"""网关在集群中每个节点上的状态"""
gateway_started_at.desc:
"""网关启用时间"""
gateway_status.desc:
"""网关启用状态"""
gateway_status_in_qs.desc:
"""通过网关状态筛选<br/>
可选值为 `running`、`stopped`、`unloaded`"""
gateway_stopped_at.desc:
"""网关停用时间"""
get_gateway.desc:
"""获取网关配置详情"""
list_gateway.desc:
"""该接口会返回指定或所有网关的概览状态，
包括当前状态、连接数、监听器状态等。"""
node.desc:
"""节点名称"""
update_gateway.desc:
"""更新指定网关的基础配置、和启用的状态。<br/>
注：认证、和监听器的配置更新需参考对应的 API 接口。"""
}

45
rel/i18n/zh/emqx_gateway_api_authn.hocon
View File

@ -1,45 +0,0 @@
emqx_gateway_api_authn {
add_authn.desc:
"""为指定网关开启认证器实现客户端认证的功能。<br/>
当未配置认证器或关闭认证器时，则认为允许所有客户端的连接。<br/>
注：在网关中仅支持添加一个认证器，而不是像 MQTT 一样允许配置多个认证器构成认证链。"""
add_user.desc:
"""添加用户（仅支持 built_in_database 类型的认证器）"""
delete_authn.desc:
"""删除指定网关的认证器。"""
delete_user.desc:
"""删除用户（仅支持 built_in_database 类型的认证器）"""
get_authn.desc:
"""获取指定网关认证器的配置
当网关或认证未启用时，返回 404。"""
get_user.desc:
"""获取用户信息（仅支持 built_in_database 类型的认证器）"""
import_users.desc:
"""导入用户（仅支持 built_in_database 类型的认证器）"""
is_superuser.desc:
"""是否是超级用户"""
like_user_id.desc:
"""使用用户 ID （username 或 clientid）模糊搜索，仅支持按子串的方式进行搜索。"""
list_users.desc:
"""获取用户列表（仅支持 built_in_database 类型的认证器）"""
update_authn.desc:
"""更新指定网关认证器的配置，或停用认证器。"""
update_user.desc:
"""更新用户信息（仅支持 built_in_database 类型的认证器）"""
user_id.desc:
"""用户 ID"""
}

207
rel/i18n/zh/emqx_gateway_api_clients.hocon
View File

@ -1,207 +0,0 @@
emqx_gateway_api_clients {
disconnected_at.desc:
"""客户端连接断开时间"""
heap_size.desc:
"""进程堆内存大小，单位：字节"""
send_oct.desc:
"""已发送字节数"""
get_client.desc:
"""获取客户端信息"""
param_gte_created_at.desc:
"""匹配会话创建时间大于等于指定值的客户端"""
param_conn_state.desc:
"""匹配客户端连接状态"""
send_pkt.desc:
"""已发送应用层协议控制报文数"""
clean_start.desc:
"""标识客户端是否以 clean_start 的标志连接到网关"""
inflight_cnt.desc:
"""客户端当前飞行窗口大小"""
delete_subscription.desc:
"""为某客户端删除某订阅关系"""
param_lte_connected_at.desc:
"""匹配连接创建时间小于等于指定值的客户端"""
node.desc:
"""客户端连接到的节点名称"""
awaiting_rel_cnt.desc:
"""客户端当前等待 PUBREL 确认的 PUBREC 消息的条数"""
rap.desc:
"""Retain as Published 选项，枚举：0，1"""
inflight_max.desc:
"""客户端允许的飞行窗口最大值"""
param_username.desc:
"""匹配客户端 Username"""
param_like_endpoint_name.desc:
"""子串匹配 LwM2M 客户端 Endpoint Name"""
created_at.desc:
"""会话创建时间"""
sub_props.desc:
"""订阅属性"""
list_clients.desc:
"""获取指定网关的客户端列表"""
subscriptions_cnt.desc:
"""客户端已订阅主题数"""
mailbox_len.desc:
"""进程邮箱大小"""
send_cnt.desc:
"""已发送 Socket 报文次数"""
rh.desc:
"""Retain Handling 选项，枚举：0，1，2"""
connected.desc:
"""标识客户端是否已连接到网关"""
qos.desc:
"""QoS 等级，枚举：0，1，2"""
ip_address.desc:
"""客户端 IP 地址"""
param_gte_connected_at.desc:
"""匹配连接创建时间大于等于指定值的客户端"""
awaiting_rel_max.desc:
"""客户端允许的最大 PUBREC 等待队列长度"""
param_like_username.desc:
"""子串匹配 客户端 Username"""
nl.desc:
"""No Local 选项，枚举：0，1"""
param_like_clientid.desc:
"""子串匹配客户端 ID"""
param_lte_created_at.desc:
"""匹配会话创建时间小于等于指定值的客户端"""
topic.desc:
"""主题过滤器或主题名称"""
proto_ver.desc:
"""客户端使用的协议版本"""
mountpoint.desc:
"""主题固定前缀"""
proto_name.desc:
"""客户端使用的协议名称"""
param_lte_lifetime.desc:
"""匹配心跳时间小于等于指定值的 LwM2M 客户端"""
port.desc:
"""客户端端口"""
connected_at.desc:
"""客户端连接时间"""
expiry_interval.desc:
"""会话超期时间，单位：秒"""
username.desc:
"""客户端连接的用户名"""
param_clean_start.desc:
"""匹配客户端 `clean_start` 标记"""
recv_msg.desc:
"""已接收上行的消息条数"""
list_subscriptions.desc:
"""获取某客户端的主题订阅列表"""
recv_oct.desc:
"""已接收的字节数"""
keepalive.desc:
"""Keepalive 时间，单位：秒"""
param_clientid.desc:
"""匹配客户端 ID"""
subscriptions_max.desc:
"""客户端允许订阅的最大主题数"""
param_ip_address.desc:
"""匹配客户端 IP 地址"""
mqueue_max.desc:
"""客户端允许的最大消息队列长度"""
mqueue_dropped.desc:
"""由于消息队列过程，客户端消息队列丢弃消息条数"""
subid.desc:
"""订阅ID，仅用于 Stomp 网关。用于创建订阅关系时指定订阅 ID。取值范围 1-65535。"""
clientid.desc:
"""客户端 ID"""
kick_client.desc:
"""踢出指定客户端"""
is_bridge.desc:
"""标识客户端是否通过 is_bridge 标志连接"""
lifetime.desc:
"""LwM2M 客户端心跳周期"""
send_msg.desc:
"""已发送下行消息数条数"""
add_subscription.desc:
"""为某客户端新增订阅关系"""
param_endpoint_name.desc:
"""匹配 LwM2M 客户端 Endpoint Name"""
param_node.desc:
"""匹配客户端的节点名称"""
recv_cnt.desc:
"""已接收 Socket 报文次数"""
recv_pkt.desc:
"""已接收应用层协议控制报文数"""
endpoint_name.desc:
"""LwM2M 客户端 Endpoint Name"""
param_proto_ver.desc:
"""匹配客户端协议版本"""
reductions.desc:
"""进程已消耗 Reduction 数"""
param_gte_lifetime.desc:
"""匹配心跳时间大于等于指定值的 LwM2M 客户端"""
mqueue_len.desc:
"""客户端当前消息队列长度"""
}

65
rel/i18n/zh/emqx_gateway_api_listeners.hocon
View File

@ -1,65 +0,0 @@
emqx_gateway_api_listeners {
add_listener.desc:
"""为指定网关添加监听器。<br/>
注：对于某网关不支持的监听器类型，该接口会返回 `400: BAD_REQUEST`。"""
add_listener_authn.desc:
"""为指定监听器开启认证器以实现客户端认证的能力。<br/>
当某一监听器开启认证后，所有连接到该监听器的客户端会使用该认证器进行认证。"""
add_user.desc:
"""添加用户（仅支持 built_in_database 类型的认证器）"""
current_connections.desc:
"""当前连接数"""
delete_listener.desc:
"""删除指定监听器。被删除的监听器下所有已连接的客户端都会离线。"""
delete_listener_authn.desc:
"""移除指定监听器的认证器。"""
delete_user.desc:
"""删除用户（仅支持 built_in_database 类型的认证器）"""
get_listener.desc:
"""获取指定网关监听器的配置。"""
get_listener_authn.desc:
"""获取监听器的认证器配置。"""
get_user.desc:
"""获取用户信息（仅支持 built_in_database 类型的认证器）"""
import_users.desc:
"""导入用户（仅支持 built_in_database 类型的认证器）"""
list_listeners.desc:
"""获取网关监听器列表。该接口会返回监听器所有的配置（包括该监听器上的认证器），同时也会返回该监听器在集群中运行的状态。"""
list_users.desc:
"""获取用户列表（仅支持 built_in_database 类型的认证器）"""
listener_id.desc:
"""监听器 ID"""
listener_node_status.desc:
"""监听器在集群中每个节点上的状态"""
listener_status.desc:
"""监听器状态"""
node.desc:
"""节点名称"""
update_listener.desc:
"""更新某网关监听器的配置。被更新的监听器会执行重启，所有已连接到该监听器上的客户端都会被断开。"""
update_listener_authn.desc:
"""更新指定监听器的认证器配置，或停用/启用该认证器。"""
update_user.desc:
"""更新用户信息（仅支持 built_in_database 类型的认证器）"""
}

112
rel/i18n/zh/emqx_gateway_schema.hocon
View File

@ -1,112 +0,0 @@
emqx_gateway_schema {
dtls_listener_acceptors.desc:
"""Acceptor 进程池大小。"""
dtls_listener_dtls_opts.desc:
"""DTLS Socket 配置"""
gateway_common_authentication.desc:
"""网关的认证器配置，对该网关下所以的监听器生效。如果每个监听器需要配置不同的认证器，需要配置监听器下的 <code>authentication</code> 字段。"""
gateway_common_clientinfo_override.desc:
"""ClientInfo 重写。"""
gateway_common_clientinfo_override_clientid.desc:
"""clientid 重写模板"""
gateway_common_clientinfo_override_password.desc:
"""password 重写模板"""
gateway_common_clientinfo_override_username.desc:
"""username 重写模板"""
gateway_common_enable.desc:
"""是否启用该网关"""
gateway_common_enable_stats.desc:
"""是否开启客户端统计"""
gateway_common_idle_timeout.desc:
"""客户端连接过程的空闲时间。该配置用于：
1. 一个新创建的客户端进程如果在该时间间隔内没有收到任何客户端请求，将被直接关闭。
2. 一个正在运行的客户进程如果在这段时间后没有收到任何客户请求，将进入休眠状态以节省资源。"""
gateway_common_listener_access_rules.desc:
"""配置监听器的访问控制规则。
见：https://github.com/emqtt/esockd#allowdeny"""
gateway_common_listener_bind.desc:
"""监听器绑定的 IP 地址或端口。"""
gateway_common_listener_enable.desc:
"""是否启用该监听器。"""
gateway_common_listener_enable_authn.desc:
"""配置 <code>true</code> （默认值）启用客户端进行身份认证。
配置 <code>false</code> 时，将不对客户端做任何认证。"""
gateway_common_listener_max_conn_rate.desc:
"""监听器支持的最大连接速率。"""
gateway_common_listener_max_connections.desc:
"""监听器支持的最大连接数。"""
gateway_mountpoint.desc:
"""发布或订阅时，在所有主题前增加前缀字符串。
当消息投递给订阅者时，前缀字符串将从主题名称中删除。挂载点是用户可以用来实现不同监听器之间的消息路由隔离的一种方式。
例如，如果客户端 A 在 `listeners.tcp.\<name>.mountpoint` 设置为 `some_tenant` 的情况下订阅 `t`，
则客户端实际上订阅了 `some_tenant/t` 主题。
类似地，如果另一个客户端 B（连接到与客户端 A 相同的侦听器）向主题 `t` 发送消息，
则该消息被路由到所有订阅了 `some_tenant/t` 的客户端，因此客户端 A 将收到该消息，带有 主题名称`t`。 设置为 `""` 以禁用该功能。
挂载点字符串中可用的变量：<br/>
- <code>${clientid}</code>：clientid<br/>
- <code>${username}</code>：用户名"""
listener_name_to_settings_map.desc:
"""从监听器名称到配置参数的映射。"""
ssl_listener_options.desc:
"""SSL Socket 配置。"""
tcp_listener_acceptors.desc:
"""Acceptor 进程池大小。"""
tcp_listener_proxy_protocol.desc:
"""是否开启 Proxy Protocol V1/2。当 EMQX 集群部署在 HAProxy 或 Nginx 后需要获取客户端真实 IP 时常用到该选项。参考：https://www.haproxy.com/blog/haproxy/proxy-protocol/"""
tcp_listener_proxy_protocol_timeout.desc:
"""接收 Proxy Protocol 报文头的超时时间。如果在超时内没有收到 Proxy Protocol 包，EMQX 将关闭 TCP 连接。"""
tcp_listener_tcp_opts.desc:
"""TCP Socket 配置。"""
tcp_listeners.desc:
"""配置 TCP 类型的监听器。"""
tcp_udp_listeners.desc:
"""监听器配置。"""
udp_listener_active_n.desc:
"""为 Socket 指定 {active, N} 选项。
参见：https://erlang.org/doc/man/inet.html#setopts-2"""
udp_listener_buffer.desc:
"""Socket 在用户空间的缓冲区大小。"""
udp_listener_recbuf.desc:
"""Socket 在内核空间接收缓冲区的大小。"""
udp_listener_reuseaddr.desc:
"""允许重用本地处于 TIME_WAIT 的端口号。"""
udp_listener_sndbuf.desc:
"""Socket 在内核空间发送缓冲区的大小。"""
udp_listener_udp_opts.desc:
"""UDP Socket 配置。"""
udp_listeners.desc:
"""配置 UDP 类型的监听器。"""
}

15
rel/i18n/zh/emqx_license_http_api.hocon
View File

@ -1,15 +0,0 @@
emqx_license_http_api {
desc_license_info_api.desc:
"""获取许可证信息"""
desc_license_info_api.label:
"""许可证信息"""
desc_license_key_api.desc:
"""更新一个许可证密钥"""
desc_license_key_api.label:
"""更新许可证"""
}

29
rel/i18n/zh/emqx_license_schema.hocon
View File

@ -1,29 +0,0 @@
emqx_license_schema {
connection_high_watermark_field.desc:
"""高水位线，连接数超过这个水位线时，系统会触发许可证连接配额使用告警"""
connection_high_watermark_field.label:
"""连接高水位"""
connection_low_watermark_field.desc:
"""低水位限制，低于此水位线时系统会清除连接配额使用告警"""
connection_low_watermark_field.label:
"""连接低水位线"""
key_field.desc:
"""许可证字符串"""
key_field.label:
"""许可证字符串"""
license_root.desc:
"""EMQX企业许可证。
EMQX 自带一个默认的试用许可证，默认试用许可允许最多接入 100 个连接，签发时间是 2023年1月9日，有效期是 5 年（1825 天）。若需要在生产环境部署，
请访问 https://www.emqx.com/apply-licenses/emqx 来申请。"""
license_root.label:
"""许可证"""
}

89
rel/i18n/zh/emqx_limiter_schema.hocon
View File

@ -1,89 +0,0 @@
emqx_limiter_schema {
bucket_cfg.desc:
"""桶的配置"""
bucket_cfg.label:
"""桶的配置"""
burst.desc:
"""突发速率。
突发速率允许短时间内速率超过设置的速率值，突发速率 + 速率 = 当前桶能达到的最大速率值"""
burst.label:
"""突发速率"""
bytes.desc:
"""流入字节率控制器。
这个是用来控制当前节点上的数据流入的字节率，每条消息将会消耗和其二进制大小等量的令牌，当达到最大速率后，会话将会被限速甚至被强制挂起一小段时间"""
bytes.label:
"""流入字节率"""
client.desc:
"""对桶的每个使用者的速率控制设置"""
client.label:
"""每个使用者的限制"""
connection.desc:
"""连接速率控制器。
这个用来控制当前节点上的连接速率，当达到最大速率后，新的连接将会被拒绝"""
connection.label:
"""连接速率"""
divisible.desc:
"""申请的令牌数是否可以被分割"""
divisible.label:
"""是否可分割"""
failure_strategy.desc:
"""当所有的重试都失败后的处理策略"""
failure_strategy.label:
"""失败策略"""
initial.desc:
"""桶中的初始令牌数"""
initial.label:
"""初始令牌数"""
internal.desc:
"""EMQX 内部功能所用限制器。"""
low_watermark.desc:
"""当桶中剩余的令牌数低于这个值，即使令牌申请成功了，也会被强制暂停一会儿"""
low_watermark.label:
"""低水位线"""
max_retry_time.desc:
"""申请失败后，尝试重新申请的时长最大值"""
max_retry_time.label:
"""最大重试时间"""
message_routing.desc:
"""消息派发速率控制器。
这个用来控制当前节点内的消息派发速率，当达到最大速率后，新的推送将会被拒绝"""
message_routing.label:
"""消息派发"""
messages.desc:
"""流入速率控制器。
这个用来控制当前节点上的消息流入速率，当达到最大速率后，会话将会被限速甚至被强制挂起一小段时间"""
messages.label:
"""消息流入速率"""
rate.desc:
"""桶的令牌生成速率"""
rate.label:
"""速率"""
}

Some files were not shown because too many files have changed in this diff Show More