diff options
Diffstat (limited to 'deps/rabbitmq_cli/lib')
222 files changed, 18165 insertions, 0 deletions
diff --git a/deps/rabbitmq_cli/lib/rabbit_common/records.ex b/deps/rabbitmq_cli/lib/rabbit_common/records.ex new file mode 100644 index 0000000000..dc1503caf7 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbit_common/records.ex @@ -0,0 +1,19 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitCommon.Records do + require Record + import Record, only: [defrecord: 2, extract: 2] + + # Important: amqqueue records must not be used directly since they are versioned + # for mixed version cluster compatibility. Convert records + # to maps on the server end to access the fields of those records. MK. + defrecord :listener, extract(:listener, from_lib: "rabbit_common/include/rabbit.hrl") + defrecord :plugin, extract(:plugin, from_lib: "rabbit_common/include/rabbit.hrl") + defrecord :resource, extract(:resource, from_lib: "rabbit_common/include/rabbit.hrl") + + defrecord :hostent, extract(:hostent, from_lib: "kernel/include/inet.hrl") +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/auto_complete.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/auto_complete.ex new file mode 100644 index 0000000000..1f907b528d --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/auto_complete.ex @@ -0,0 +1,118 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.AutoComplete do + alias RabbitMQ.CLI.Core.{CommandModules, Parser} + + # Use the same jaro distance limit as in Elixir's "did you mean?" + @jaro_distance_limit 0.77 + + @spec complete(String.t(), [String.t()]) :: [String.t()] + def complete(_, []) do + [] + end + + def complete(script_name, args) do + case Parser.parse_global(args) do + {_, %{script_name: _args_script_name}, _} -> + complete(args) + + _ -> + complete(["--script-name", script_name | args]) + end + end + + def suggest_command(_cmd_name, empty) when empty == %{} do + nil + end + def suggest_command(typed, module_map) do + suggestion = + module_map + |> Map.keys() + |> Enum.map(fn existing -> + {existing, String.jaro_distance(existing, typed)} + end) + |> Enum.max_by(fn {_, distance} -> distance end) + + case suggestion do + {cmd, distance} when distance >= @jaro_distance_limit -> + {:suggest, cmd} + _ -> + nil + end + end + + defp complete(tokens) do + {command, command_name, _, _, _} = Parser.parse(tokens) + last_token = List.last(tokens) + + case {command, command_name} do + ## No command provided + {_, ""} -> + complete_default_opts(last_token) + + ## Command is not found/incomplete + {:no_command, command_name} -> + complete_command_name(command_name) + + {{:suggest, _}, command_name} -> + complete_command_name(command_name) + + ## Command is found + {command, _} -> + complete_command_opts(command, last_token) + end + |> Enum.sort() + end + + defp complete_default_opts(opt) do + Parser.default_switches() + |> Keyword.keys() + |> Enum.map(fn sw -> "--" <> to_string(sw) end) + |> select_starts_with(opt) + |> format_options + end + + defp complete_command_name(command_name) do + module_map = CommandModules.module_map() + + case module_map[command_name] do + nil -> + module_map + |> Map.keys() + |> select_starts_with(command_name) + + _ -> + command_name + end + end + + defp complete_command_opts(command, <<"-", _::binary>> = opt) do + switches = + command.switches + |> Keyword.keys() + |> Enum.map(fn sw -> "--" <> to_string(sw) end) + + # aliases = command.aliases + # |> Keyword.keys + # |> Enum.map(fn(al) -> "-" <> to_string(al) end) + select_starts_with(switches, opt) + |> format_options + end + + defp complete_command_opts(_, _) do + [] + end + + defp select_starts_with(list, prefix) do + Enum.filter(list, fn el -> String.starts_with?(el, prefix) end) + end + + defp format_options(options) do + options + |> Enum.map(fn opt -> String.replace(opt, "_", "-") end) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/command_behaviour.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/command_behaviour.ex new file mode 100644 index 0000000000..800d4d3227 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/command_behaviour.ex @@ -0,0 +1,170 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.CommandBehaviour do + alias RabbitMQ.CLI.Core.Helpers + + @type pair_of_strings :: nonempty_list(String.t()) + + @callback usage() :: String.t() | [String.t()] + # validates CLI arguments + @callback validate(list(), map()) :: :ok | {:validation_failure, atom() | {atom(), String.t()}} + @callback merge_defaults(list(), map()) :: {list(), map()} + @callback banner(list(), map()) :: [String.t()] | String.t() | nil + @callback run(list(), map()) :: any + # Coerces run/2 return value into the standard command output form + # that is then formatted, printed and returned as an exit code. + # There is a default implementation for this callback in DefaultOutput module + @callback output(any, map()) :: + :ok + | {:ok, any} + | {:stream, Enum.t()} + | {:error, RabbitMQ.CLI.Core.ExitCodes.exit_code(), [String.t()]} + + @optional_callbacks formatter: 0, + printer: 0, + scopes: 0, + usage_additional: 0, + usage_doc_guides: 0, + description: 0, + help_section: 0, + switches: 0, + aliases: 0, + # validates execution environment, e.g. file presence, + # whether RabbitMQ is in an expected state on a node, etc + validate_execution_environment: 2, + distribution: 1 + + @callback validate_execution_environment(list(), map()) :: + :ok | {:validation_failure, atom() | {atom(), any}} + @callback switches() :: Keyword.t() + @callback aliases() :: Keyword.t() + + @callback formatter() :: atom() + @callback printer() :: atom() + @callback scopes() :: [atom()] | nil + @callback description() :: String.t() + @callback help_section() :: String.t() + @callback usage_additional() :: String.t() | [String.t()] | nonempty_list(pair_of_strings()) | [{String.t(), String.t()}] + @callback usage_doc_guides() :: String.t() | [String.t()] + ## Erlang distribution control + ## :cli - default rabbitmqctl generated node name + ## :none - disable erlang distribution + ## {:fun, fun} - use a custom function to start distribution + @callback distribution(map()) :: :cli | :none | {:fun, (map() -> :ok | {:error, any()})} + + defmacro defcmd(map) do + usage_q = case map[:usage] do + nil -> :ok + usage -> + quote do def usage(), do: unquote(usage) end + end + scopes_q = case map[:scopes] do + nil -> :ok + scopes -> + quote do def scopes(), do: unquote(scopes) end + end + description_q = case map[:description] do + nil -> :ok + description -> + quote do def description(), do: unquote(description) end + end + help_section_q = case map[:help_section] do + nil -> :ok + help_section -> + quote do def help_section(), do: unquote(help_section) end + end + usage_additional_q = case map[:usage_additional] do + nil -> :ok + usage_additional -> + quote do def usage_additional(), do: unquote(usage_additional) end + end + formatter_q = case map[:formatter] do + nil -> :ok + formatter -> + quote do def formatter(), do: unquote(formatter) end + end + switches_q = case map[:switches] do + nil -> :ok + switches -> + quote do def switches(), do: unquote(switches) end + end + aliases_q = case map[:aliases] do + nil -> :ok + aliases -> + quote do def aliases(), do: unquote(aliases) end + end + + quote do + unquote(usage_q) + unquote(scopes_q) + unquote(description_q) + unquote(help_section_q) + unquote(usage_additional_q) + unquote(formatter_q) + unquote(switches_q) + unquote(aliases_q) + end + end + + def usage(cmd) do + cmd.usage() + end + + def scopes(cmd) do + Helpers.apply_if_exported(cmd, :scopes, [], nil) + end + + def description(cmd) do + Helpers.apply_if_exported(cmd, :description, [], "") + end + + def help_section(cmd) do + case Helpers.apply_if_exported(cmd, :help_section, [], :other) do + :other -> + case Application.get_application(cmd) do + :rabbitmqctl -> :other + plugin -> {:plugin, plugin} + end + section -> + section + end + end + + def usage_additional(cmd) do + Helpers.apply_if_exported(cmd, :usage_additional, [], []) + end + + def usage_doc_guides(cmd) do + Helpers.apply_if_exported(cmd, :usage_doc_guides, [], []) + end + + def formatter(cmd, default) do + Helpers.apply_if_exported(cmd, :formatter, [], default) + end + + def printer(cmd, default) do + Helpers.apply_if_exported(cmd, :printer, [], default) + end + + def switches(cmd) do + Helpers.apply_if_exported(cmd, :switches, [], []) + end + + def aliases(cmd) do + Helpers.apply_if_exported(cmd, :aliases, [], []) + end + + def validate_execution_environment(cmd, args, options) do + Helpers.apply_if_exported(cmd, + :validate_execution_environment, [args, options], + :ok) + end + + def distribution(cmd, options) do + Helpers.apply_if_exported(cmd, :distribution, [options], :cli) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_default_switches_and_timeout.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_default_switches_and_timeout.ex new file mode 100644 index 0000000000..3a78974b0c --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_default_switches_and_timeout.ex @@ -0,0 +1,16 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Should be used by commands that require rabbit app to be stopped +# but need no other execution environment validators. +defmodule RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout do + defmacro __using__(_) do + quote do + def switches(), do: [timeout: :integer] + def aliases(), do: [t: :timeout] + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_no_positional_arguments.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_no_positional_arguments.ex new file mode 100644 index 0000000000..166c4f22f7 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_no_positional_arguments.ex @@ -0,0 +1,21 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Should be used by commands that require rabbit app to be stopped +# but need no other execution environment validators. +defmodule RabbitMQ.CLI.Core.AcceptsNoPositionalArguments do + defmacro __using__(_) do + quote do + def validate(args, _) when length(args) > 0 do + {:validation_failure, :too_many_args} + end + + # Note: this will accept everything, so it must be the + # last validation clause defined! + def validate(_, _), do: :ok + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_one_positional_argument.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_one_positional_argument.ex new file mode 100644 index 0000000000..3731775ed3 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_one_positional_argument.ex @@ -0,0 +1,25 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Should be used by commands that require rabbit app to be stopped +# but need no other execution environment validators. +defmodule RabbitMQ.CLI.Core.AcceptsOnePositionalArgument do + defmacro __using__(_) do + quote do + def validate(args, _) when length(args) == 0 do + {:validation_failure, :not_enough_args} + end + + def validate(args, _) when length(args) > 1 do + {:validation_failure, :too_many_args} + end + + # Note: this will accept everything, so it must be the + # last validation clause defined! + def validate(_, _), do: :ok + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_one_positive_integer_argument.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_one_positive_integer_argument.ex new file mode 100644 index 0000000000..6b6fd28dfe --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_one_positive_integer_argument.ex @@ -0,0 +1,34 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Should be used by commands that require rabbit app to be stopped +# but need no other execution environment validators. +defmodule RabbitMQ.CLI.Core.AcceptsOnePositiveIntegerArgument do + defmacro __using__(_) do + quote do + def validate(args, _) when length(args) == 0 do + {:validation_failure, :not_enough_args} + end + + def validate(args, _) when length(args) > 1 do + {:validation_failure, :too_many_args} + end + + def validate([value], _) when is_integer(value) do + :ok + end + + def validate([value], _) do + case Integer.parse(value) do + {n, _} when n >= 1 -> :ok + :error -> {:validation_failure, {:bad_argument, "Argument must be a positive integer"}} + end + end + + def validate(_, _), do: :ok + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_two_positional_arguments.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_two_positional_arguments.ex new file mode 100644 index 0000000000..18b2740b42 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/accepts_two_positional_arguments.ex @@ -0,0 +1,25 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Should be used by commands that require rabbit app to be stopped +# but need no other execution environment validators. +defmodule RabbitMQ.CLI.Core.AcceptsTwoPositionalArguments do + defmacro __using__(_) do + quote do + def validate(args, _) when length(args) < 2 do + {:validation_failure, :not_enough_args} + end + + def validate(args, _) when length(args) > 2 do + {:validation_failure, :too_many_args} + end + + # Note: this will accept everything, so it must be the + # last validation clause defined! + def validate([_, _], _), do: :ok + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/alarms.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/alarms.ex new file mode 100644 index 0000000000..15143f7f69 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/alarms.ex @@ -0,0 +1,88 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Alarms do + def alarm_lines(alarms, node_name) do + Enum.reduce(alarms, [], fn + :file_descriptor_limit, acc -> + ["File descriptor limit alarm on node #{node_name}" | acc] + + {{:resource_limit, :memory, alarmed_node_name}, _}, acc -> + ["Memory alarm on node #{alarmed_node_name}" | acc] + + {:resource_limit, :memory, alarmed_node_name}, acc -> + ["Memory alarm on node #{alarmed_node_name}" | acc] + + {{:resource_limit, :disk, alarmed_node_name}, _}, acc -> + ["Free disk space alarm on node #{alarmed_node_name}" | acc] + + {:resource_limit, :disk, alarmed_node_name}, acc -> + ["Free disk space alarm on node #{alarmed_node_name}" | acc] + end) + |> Enum.reverse() + end + + def local_alarms(alarms, node_name) do + Enum.filter( + alarms, + fn + # local by definition + :file_descriptor_limit -> + true + + {{:resource_limit, _, a_node}, _} -> + node_name == a_node + end + ) + end + + def clusterwide_alarms(alarms, node_name) do + alarms + |> Enum.reject(fn x -> x == :file_descriptor_limit end) + |> Enum.filter(fn {{:resource_limit, _, a_node}, _} -> + a_node != node_name + end) + end + + def alarm_types(xs) do + Enum.map(xs, &alarm_type/1) + end + + def alarm_type(val) when is_atom(val) do + val + end + def alarm_type({:resource_limit, val, _node}) do + val + end + def alarm_type({{:resource_limit, val, _node}, []}) do + val + end + + def alarm_maps(xs) do + Enum.map(xs, &alarm_map/1) + end + def alarm_map(:file_descriptor_limit) do + %{ + type: :resource_limit, + resource: :file_descriptors, + node: node() + } + end + def alarm_map({{:resource_limit, resource, node}, _}) do + %{ + type: :resource_limit, + resource: resource, + node: node + } + end + def alarm_map({:resource_limit, resource, node}) do + %{ + type: :resource_limit, + resource: resource, + node: node + } + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/ansi.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/ansi.ex new file mode 100644 index 0000000000..e541a632ff --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/ansi.ex @@ -0,0 +1,35 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.ANSI do + def bright(string) do + "#{IO.ANSI.bright()}#{string}#{IO.ANSI.reset()}" + end + + def red(string) do + "#{IO.ANSI.red()}#{string}#{IO.ANSI.reset()}" + end + + def yellow(string) do + "#{IO.ANSI.yellow()}#{string}#{IO.ANSI.reset()}" + end + + def magenta(string) do + "#{IO.ANSI.magenta()}#{string}#{IO.ANSI.reset()}" + end + + def bright_red(string) do + "#{IO.ANSI.bright()}#{IO.ANSI.red()}#{string}#{IO.ANSI.reset()}" + end + + def bright_yellow(string) do + "#{IO.ANSI.bright()}#{IO.ANSI.yellow()}#{string}#{IO.ANSI.reset()}" + end + + def bright_magenta(string) do + "#{IO.ANSI.bright()}#{IO.ANSI.magenta()}#{string}#{IO.ANSI.reset()}" + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/code_path.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/code_path.ex new file mode 100644 index 0000000000..32636fac6f --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/code_path.ex @@ -0,0 +1,108 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.CodePath do + alias RabbitMQ.CLI.Core.{Config, Paths, Platform} + + def add_plugins_to_load_path(opts) do + with {:ok, plugins_dir} <- Paths.plugins_dir(opts) do + String.split(to_string(plugins_dir), Platform.path_separator()) + |> Enum.map(&add_directory_plugins_to_load_path/1) + + :ok + end + end + + def add_directory_plugins_to_load_path(directory_with_plugins_inside_it) do + with {:ok, files} <- File.ls(directory_with_plugins_inside_it) do + Enum.map( + files, + fn filename -> + cond do + String.ends_with?(filename, [".ez"]) -> + Path.join([directory_with_plugins_inside_it, filename]) + |> String.to_charlist() + |> add_archive_code_path() + + File.dir?(filename) -> + Path.join([directory_with_plugins_inside_it, filename]) + |> add_dir_code_path() + + true -> + {:error, {:not_a_plugin, filename}} + end + end + ) + end + end + + defp add_archive_code_path(ez_dir) do + case :erl_prim_loader.list_dir(ez_dir) do + {:ok, [app_dir]} -> + app_in_ez = :filename.join(ez_dir, app_dir) + add_dir_code_path(app_in_ez) + + _ -> + {:error, :no_app_dir} + end + end + + defp add_dir_code_path(app_dir_0) do + app_dir = to_charlist(app_dir_0) + + case :erl_prim_loader.list_dir(app_dir) do + {:ok, list} -> + case Enum.member?(list, 'ebin') do + true -> + ebin_dir = :filename.join(app_dir, 'ebin') + Code.append_path(ebin_dir) + + false -> + {:error, :no_ebin} + end + + _ -> + {:error, :app_dir_empty} + end + end + + def require_rabbit_and_plugins(_, opts) do + require_rabbit_and_plugins(opts) + end + + def require_rabbit_and_plugins(opts) do + with :ok <- require_rabbit(opts), + :ok <- add_plugins_to_load_path(opts), + do: :ok + end + + def require_rabbit(_, opts) do + require_rabbit(opts) + end + + def require_rabbit(opts) do + home = Config.get_option(:rabbitmq_home, opts) + + case home do + nil -> + {:error, {:unable_to_load_rabbit, :rabbitmq_home_is_undefined}} + + _ -> + case Application.load(:rabbit) do + :ok -> + Code.ensure_loaded(:rabbit_plugins) + :ok + + {:error, {:already_loaded, :rabbit}} -> + Code.ensure_loaded(:rabbit_plugins) + :ok + + {:error, err} -> + {:error, {:unable_to_load_rabbit, err}} + end + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/command_modules.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/command_modules.ex new file mode 100644 index 0000000000..a1b7fc9237 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/command_modules.ex @@ -0,0 +1,196 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.CommandModules do + alias RabbitMQ.CLI.Core.Config + alias RabbitMQ.CLI.Plugins.Helpers, as: PluginsHelpers + alias RabbitMQ.CLI.CommandBehaviour + + import RabbitMQ.CLI.Core.CodePath + + @commands_ns ~r/RabbitMQ.CLI.(.*).Commands/ + + def module_map(opts \\ %{}) do + Application.get_env(:rabbitmqctl, :commands) || load(opts) + end + + def module_map_core(opts \\ %{}) do + Application.get_env(:rabbitmqctl, :commands_core) || load_core(opts) + end + + def load_core(opts) do + scope = script_scope(opts) + commands = load_commands_core(scope) + Application.put_env(:rabbitmqctl, :commands_core, commands) + commands + end + + def load(opts) do + scope = script_scope(opts) + commands = load_commands(scope, opts) + Application.put_env(:rabbitmqctl, :commands, commands) + commands + end + + def script_scope(opts) do + scopes = Application.get_env(:rabbitmqctl, :scopes, []) + scopes[Config.get_option(:script_name, opts)] || :none + end + + def load_commands_core(scope) do + make_module_map(ctl_modules(), scope) + end + + def load_commands(scope, opts) do + make_module_map(plugin_modules(opts) ++ ctl_modules(), scope) + end + + def ctl_modules() do + Application.spec(:rabbitmqctl, :modules) + end + + def plugin_modules(opts) do + require_rabbit(opts) + + enabled_plugins = + try do + PluginsHelpers.read_enabled(opts) + catch + err -> + {:ok, enabled_plugins_file} = PluginsHelpers.enabled_plugins_file(opts) + require Logger + + Logger.warn( + "Unable to read the enabled plugins file.\n" <> + " Reason: #{inspect(err)}\n" <> + " Commands provided by plugins will not be available.\n" <> + " Please make sure your user has sufficient permissions to read to\n" <> + " #{enabled_plugins_file}" + ) + + [] + end + + partitioned = + Enum.group_by(enabled_plugins, fn app -> + case Application.load(app) do + :ok -> :loaded + {:error, {:already_loaded, ^app}} -> :loaded + _ -> :not_found + end + end) + + loaded = partitioned[:loaded] || [] + missing = partitioned[:not_found] || [] + ## If plugins are not in ERL_LIBS, they should be loaded from plugins_dir + case missing do + [] -> + :ok + + _ -> + add_plugins_to_load_path(opts) + Enum.each(missing, fn app -> Application.load(app) end) + end + + Enum.flat_map(loaded ++ missing, fn app -> + Application.spec(app, :modules) || [] + end) + end + + defp make_module_map(modules, scope) do + commands_ns = Regex.recompile!(@commands_ns) + + modules + |> Enum.filter(fn mod -> + to_string(mod) =~ commands_ns and + module_exists?(mod) and + implements_command_behaviour?(mod) and + command_in_scope(mod, scope) + end) + |> Enum.map(&command_tuple/1) + |> Map.new() + end + + defp module_exists?(nil) do + false + end + + defp module_exists?(mod) do + Code.ensure_loaded?(mod) + end + + defp implements_command_behaviour?(nil) do + false + end + + defp implements_command_behaviour?(module) do + Enum.member?( + module.module_info(:attributes)[:behaviour] || [], + RabbitMQ.CLI.CommandBehaviour + ) + end + + def module_to_command(mod) do + mod + |> to_string + |> strip_namespace + |> to_snake_case + |> String.replace_suffix("_command", "") + end + + defp command_tuple(cmd) do + {module_to_command(cmd), cmd} + end + + def strip_namespace(str) do + str + |> String.split(".") + |> List.last() + end + + def to_snake_case(<<c, str::binary>>) do + tail = for <<c <- str>>, into: "", do: snake(c) + <<to_lower_char(c), tail::binary>> + end + + defp snake(c) do + if c >= ?A and c <= ?Z do + <<"_", c + 32>> + else + <<c>> + end + end + + defp to_lower_char(c) do + if c >= ?A and c <= ?Z do + c + 32 + else + c + end + end + + defp command_in_scope(_cmd, :all) do + true + end + + defp command_in_scope(cmd, scope) do + Enum.member?(command_scopes(cmd), scope) + end + + defp command_scopes(cmd) do + case CommandBehaviour.scopes(cmd) do + nil -> + Regex.recompile!(@commands_ns) + |> Regex.run(to_string(cmd), capture: :all_but_first) + |> List.first() + |> to_snake_case + |> String.to_atom() + |> List.wrap() + scopes -> + scopes + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/config.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/config.ex new file mode 100644 index 0000000000..251f9e582f --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/config.ex @@ -0,0 +1,200 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Config do + alias RabbitMQ.CLI.{ + CommandBehaviour, + FormatterBehaviour, + PrinterBehaviour + } + + alias RabbitMQ.CLI.Core.Helpers + + # + # Environment + # + + def get_option(name, opts \\ %{}) do + raw_option = + opts[name] || + get_system_option(name, opts) || + default(name) + + normalise(name, raw_option) + end + + def output_less?(opts) do + Map.get(opts, :silent, false) || Map.get(opts, :quiet, false) + end + + def normalise(:node, nil), do: nil + + def normalise(:node, node) when not is_atom(node) do + RabbitMQ.CLI.Core.DataCoercion.to_atom(node) + end + + def normalise(:erlang_cookie, nil), do: nil + + def normalise(:erlang_cookie, c) when not is_atom(c) do + RabbitMQ.CLI.Core.DataCoercion.to_atom(c) + end + + def normalise(:longnames, true), do: :longnames + def normalise(:longnames, "true"), do: :longnames + def normalise(:longnames, 'true'), do: :longnames + def normalise(:longnames, "\"true\""), do: :longnames + def normalise(:longnames, _val), do: :shortnames + def normalise(_, value), do: value + + def get_system_option(:script_name, _) do + Path.basename(:escript.script_name()) + |> Path.rootname() + |> String.to_atom() + end + + def get_system_option(:aliases_file, _) do + System.get_env("RABBITMQ_CLI_ALIASES_FILE") + end + + def get_system_option(:erlang_cookie, _) do + System.get_env("RABBITMQ_ERLANG_COOKIE") + end + + def get_system_option(:node, %{offline: true} = opts) do + remote_node = + case opts[:node] do + nil -> nil + val -> Helpers.normalise_node_option(val, opts[:longnames], opts) + end + + context = get_env_context(remote_node, true) + get_val_from_env_context(context, :node) + end + + def get_system_option(:node, opts) do + remote_node = + case opts[:node] do + nil -> nil + val -> Helpers.normalise_node_option(val, opts[:longnames], opts) + end + + context = get_env_context(remote_node, false) + get_val_from_env_context(context, :node) + end + + def get_system_option(name, opts) do + work_offline = opts[:offline] == true + + remote_node = + case name do + :longnames -> nil + :rabbitmq_home -> nil + _ -> node_flag_or_default(opts) + end + + context = get_env_context(remote_node, work_offline) + val0 = get_val_from_env_context(context, name) + + val = + cond do + remote_node != nil and + val0 == :undefined and + (name == :mnesia_dir or name == :feature_flags_file or name == :plugins_dir or + name == :enabled_plugins_file) -> + context1 = get_env_context(nil, true) + get_val_from_env_context(context1, name) + + true -> + val0 + end + + case val do + :undefined -> nil + _ -> val + end + end + + def get_env_context(nil, _) do + :rabbit_env.get_context() + end + + def get_env_context(remote_node, work_offline) do + case work_offline do + true -> :rabbit_env.get_context(:offline) + false -> :rabbit_env.get_context(remote_node) + end + end + + def get_val_from_env_context(context, name) do + case name do + :node -> context[:nodename] + :longnames -> context[:nodename_type] == :longnames + :rabbitmq_home -> context[:rabbitmq_home] + :mnesia_dir -> context[:mnesia_dir] + :plugins_dir -> context[:plugins_path] + :plugins_expand_dir -> context[:plugins_expand_dir] + :feature_flags_file -> context[:feature_flags_file] + :enabled_plugins_file -> context[:enabled_plugins_file] + end + end + + def node_flag_or_default(opts) do + case opts[:node] do + nil -> + # Just in case `opts` was not normalized yet (to get the + # default node), we do it here as well. + case Helpers.normalise_node_option(opts) do + {:error, _} -> nil + {:ok, normalized_opts} -> normalized_opts[:node] + end + + node -> + node + end + end + + def default(:script_name), do: :rabbitmqctl + def default(:node), do: :rabbit + def default(_), do: nil + + # + # Formatters and Printers + # + + def get_formatter(command, %{formatter: formatter}) do + module_name = FormatterBehaviour.module_name(formatter) + + case Code.ensure_loaded(module_name) do + {:module, _} -> module_name + {:error, :nofile} -> CommandBehaviour.formatter(command, default_formatter()) + end + end + + def get_formatter(command, _) do + CommandBehaviour.formatter(command, default_formatter()) + end + + def get_printer(command, %{printer: printer}) do + module_name = PrinterBehaviour.module_name(printer) + + case Code.ensure_loaded(module_name) do + {:module, _} -> module_name + {:error, :nofile} -> CommandBehaviour.printer(command, default_printer()) + end + end + + def get_printer(command, _) do + CommandBehaviour.printer(command, default_printer()) + end + + def default_formatter() do + RabbitMQ.CLI.Formatters.String + end + + def default_printer() do + RabbitMQ.CLI.Printers.StdIO + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/data_coercion.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/data_coercion.ex new file mode 100644 index 0000000000..9c3d3e7344 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/data_coercion.ex @@ -0,0 +1,21 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defprotocol RabbitMQ.CLI.Core.DataCoercion do + def to_atom(data) +end + +defimpl RabbitMQ.CLI.Core.DataCoercion, for: Atom do + def to_atom(atom), do: atom +end + +defimpl RabbitMQ.CLI.Core.DataCoercion, for: BitString do + def to_atom(string), do: String.to_atom(string) +end + +defimpl RabbitMQ.CLI.Core.DataCoercion, for: List do + def to_atom(list), do: List.to_atom(list) +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/distribution.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/distribution.ex new file mode 100644 index 0000000000..403c9dd970 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/distribution.ex @@ -0,0 +1,138 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Distribution do + alias RabbitMQ.CLI.Core.{ANSI, Config, Helpers} + + # + # API + # + + def start() do + start(%{}) + end + + def start(options) do + node_name_type = Config.get_option(:longnames, options) + result = start(node_name_type, 10, :undefined) + ensure_cookie(options) + result + end + + def stop, do: Node.stop() + + def start_as(node_name, options) do + node_name_type = Config.get_option(:longnames, options) + result = start_with_epmd(node_name, node_name_type) + ensure_cookie(options) + result + end + + ## Optimization. We try to start EPMD only if distribution fails + def start_with_epmd(node_name, node_name_type) do + case Node.start(node_name, node_name_type) do + {:ok, _} = ok -> + ok + + {:error, {:already_started, _}} = started -> + started + + {:error, {{:already_started, _}, _}} = started -> + started + + ## EPMD can be stopped. Retry with EPMD + {:error, _} -> + :rabbit_nodes_common.ensure_epmd() + Node.start(node_name, node_name_type) + end + end + + def per_node_timeout(:infinity, _) do + :infinity + end + + def per_node_timeout(timeout, node_count) do + Kernel.trunc(timeout / node_count) + end + + # + # Implementation + # + + def ensure_cookie(options) do + case Config.get_option(:erlang_cookie, options) do + nil -> + :ok + + cookie -> + Node.set_cookie(cookie) + maybe_warn_about_deprecated_rabbitmq_erlang_cookie_env_variable(options) + :ok + end + end + + defp start(_opt, 0, last_err) do + {:error, last_err} + end + + defp start(node_name_type, attempts, _last_err) do + candidate = generate_cli_node_name(node_name_type) + + case start_with_epmd(candidate, node_name_type) do + {:ok, _} -> + :ok + + {:error, {:already_started, pid}} -> + {:ok, pid} + + {:error, {{:already_started, pid}, _}} -> + {:ok, pid} + + {:error, reason} -> + start(node_name_type, attempts - 1, reason) + end + end + + defp generate_cli_node_name(node_name_type) do + case Helpers.get_rabbit_hostname(node_name_type) do + {:error, _} = err -> + throw(err) + + rmq_hostname -> + # This limits the number of possible unique node names used by CLI tools to avoid + # the atom table from growing above the node limit. We must use reasonably unique IDs + # to allow for concurrent CLI tool execution. + # + # Enum.random/1 is constant time and space with range arguments https://hexdocs.pm/elixir/Enum.html#random/1. + id = Enum.random(1..1024) + String.to_atom("rabbitmqcli-#{id}-#{rmq_hostname}") + end + end + + defp maybe_warn_about_deprecated_rabbitmq_erlang_cookie_env_variable(options) do + case System.get_env("RABBITMQ_ERLANG_COOKIE") do + nil -> + :ok + + _ -> + case Config.output_less?(options) do + true -> + :ok + + false -> + warning = + ANSI.bright_red( + "RABBITMQ_ERLANG_COOKIE env variable support is deprecated and will be REMOVED in a future version. " + ) <> + ANSI.yellow( + "Use the $HOME/.erlang.cookie file or the --erlang-cookie switch instead." + ) + + IO.puts(warning) + end + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/doc_guide.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/doc_guide.ex new file mode 100644 index 0000000000..c75dcb0d7c --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/doc_guide.ex @@ -0,0 +1,67 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.DocGuide.Macros do + @moduledoc """ + Helper module that works around a compiler limitation: macros cannot + be used in a module that defines them. + """ + @default_domain "rabbitmq.com" + + defmacro defguide(name, opts \\ []) do + domain = Keyword.get(opts, :domain, @default_domain) + fn_name = String.to_atom(name) + path_segment = Keyword.get(opts, :path_segment, String.replace(name, "_", "-")) + + quote do + def unquote(fn_name)() do + unquote("https://#{domain}/#{path_segment}.html") + end + end + end +end + +defmodule RabbitMQ.CLI.Core.DocGuide do + require RabbitMQ.CLI.Core.DocGuide.Macros + alias RabbitMQ.CLI.Core.DocGuide.Macros + + # + # API + # + + Macros.defguide("access_control") + Macros.defguide("alarms") + Macros.defguide("disk_alarms") + Macros.defguide("alternate_exchange", path_segment: "ae") + Macros.defguide("channels") + Macros.defguide("cli") + Macros.defguide("clustering") + Macros.defguide("cluster_formation") + Macros.defguide("connections") + Macros.defguide("configuration", path_segment: "configure") + Macros.defguide("consumers") + Macros.defguide("definitions") + Macros.defguide("erlang_versions", path_segment: "which-erlang") + Macros.defguide("feature_flags") + Macros.defguide("firehose") + Macros.defguide("mirroring", path_segment: "ha") + Macros.defguide("logging") + Macros.defguide("management") + Macros.defguide("memory_use") + Macros.defguide("monitoring") + Macros.defguide("networking") + Macros.defguide("parameters") + Macros.defguide("publishers") + Macros.defguide("plugins") + Macros.defguide("queues") + Macros.defguide("quorum_queues", domain: "next.rabbitmq.com") + Macros.defguide("stream_queues", domain: "next.rabbitmq.com") + Macros.defguide("runtime_tuning", path_segment: "runtime") + Macros.defguide("tls", path_segment: "ssl") + Macros.defguide("troubleshooting") + Macros.defguide("virtual_hosts", path_segments: "vhosts") + Macros.defguide("upgrade") +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/erl_eval.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/erl_eval.ex new file mode 100644 index 0000000000..8d2e3aff9e --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/erl_eval.ex @@ -0,0 +1,26 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.ErlEval do + def parse_expr(expr) do + expr_str = to_charlist(expr) + + case :erl_scan.string(expr_str) do + {:ok, scanned, _} -> + case :erl_parse.parse_exprs(scanned) do + {:ok, parsed} -> {:ok, parsed} + {:error, err} -> {:error, format_parse_error(err)} + end + + {:error, err, _} -> + {:error, format_parse_error(err)} + end + end + + defp format_parse_error({_line, mod, err}) do + to_string(:lists.flatten(mod.format_error(err))) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/exit_codes.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/exit_codes.ex new file mode 100644 index 0000000000..9e416d7153 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/exit_codes.ex @@ -0,0 +1,56 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Lists predefined error exit codes used by RabbitMQ CLI tools. +# The codes are adopted from [1], which (according to our team's research) +# is possibly the most standardized set of command line tool exit codes there is. +# +# 1. https://www.freebsd.org/cgi/man.cgi?query=sysexits&apropos=0&sektion=0&manpath=FreeBSD+12.0-RELEASE&arch=default&format=html +defmodule RabbitMQ.CLI.Core.ExitCodes do + @exit_ok 0 + @exit_usage 64 + @exit_dataerr 65 + @exit_nouser 67 + @exit_unavailable 69 + @exit_software 70 + @exit_tempfail 75 + @exit_config 78 + + @type exit_code :: integer + + def exit_ok, do: @exit_ok + def exit_usage, do: @exit_usage + def exit_dataerr, do: @exit_dataerr + def exit_nouser, do: @exit_nouser + def exit_unavailable, do: @exit_unavailable + def exit_software, do: @exit_software + def exit_tempfail, do: @exit_tempfail + def exit_config, do: @exit_config + + def exit_code_for({:validation_failure, :not_enough_args}), do: exit_usage() + def exit_code_for({:validation_failure, :too_many_args}), do: exit_usage() + def exit_code_for({:validation_failure, {:not_enough_args, _}}), do: exit_usage() + def exit_code_for({:validation_failure, {:too_many_args, _}}), do: exit_usage() + def exit_code_for({:validation_failure, {:bad_argument, _}}), do: exit_dataerr() + def exit_code_for({:validation_failure, :bad_argument}), do: exit_dataerr() + def exit_code_for({:validation_failure, :eperm}), do: exit_dataerr() + def exit_code_for({:validation_failure, {:bad_option, _}}), do: exit_usage() + def exit_code_for({:validation_failure, _}), do: exit_usage() + # a special case of bad_argument + def exit_code_for({:no_such_vhost, _}), do: exit_dataerr() + def exit_code_for({:no_such_user, _}), do: exit_nouser() + def exit_code_for({:badrpc_multi, :timeout, _}), do: exit_tempfail() + def exit_code_for({:badrpc, :timeout}), do: exit_tempfail() + def exit_code_for({:badrpc, {:timeout, _}}), do: exit_tempfail() + def exit_code_for({:badrpc, {:timeout, _, _}}), do: exit_tempfail() + def exit_code_for(:timeout), do: exit_tempfail() + def exit_code_for({:timeout, _}), do: exit_tempfail() + def exit_code_for({:badrpc_multi, :nodedown, _}), do: exit_unavailable() + def exit_code_for({:badrpc, :nodedown}), do: exit_unavailable() + def exit_code_for({:node_name, _}), do: exit_dataerr() + def exit_code_for({:incompatible_version, _, _}), do: exit_unavailable() + def exit_code_for({:error, _}), do: exit_unavailable() +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/feature_flags.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/feature_flags.ex new file mode 100644 index 0000000000..4b4b8c8d5d --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/feature_flags.ex @@ -0,0 +1,19 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.FeatureFlags do + + # + # API + # + + def feature_flag_lines(feature_flags) do + feature_flags + |> Enum.map(fn %{name: name, state: state} -> + "Flag: #{name}, state: #{state}" + end) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/helpers.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/helpers.ex new file mode 100644 index 0000000000..97bd7c7bd9 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/helpers.ex @@ -0,0 +1,148 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Helpers do + alias RabbitMQ.CLI.Core.{Config, NodeName} + require Record + + def get_rabbit_hostname(node_name_type \\ :shortnames) do + normalise_node(Config.get_option(:node), node_name_type) + end + + def normalise_node(nil, node_name_type) do + normalise_node(Config.get_option(:node), node_name_type) + end + + def normalise_node(name, node_name_type) do + case NodeName.create(name, node_name_type) do + {:ok, node_name} -> node_name + other -> other + end + end + + # rabbitmq/rabbitmq-cli#278 + def normalise_node_option(options) do + node_opt = Config.get_option(:node, options) + longnames_opt = Config.get_option(:longnames, options) + case NodeName.create(node_opt, longnames_opt) do + {:error, _} = err -> + err + {:ok, val} -> + {:ok, Map.put(options, :node, val)} + end + end + + def normalise_node_option(nil, _, _) do + nil + end + def normalise_node_option(node_opt, longnames_opt, options) do + case NodeName.create(node_opt, longnames_opt) do + {:error, _} = err -> + err + {:ok, val} -> + {:ok, Map.put(options, :node, val)} + end + end + + def case_insensitive_format(%{format: format} = opts) do + %{opts | format: String.downcase(format)} + end + def case_insensitive_format(opts), do: opts + + def nodes_in_cluster(node, timeout \\ :infinity) do + with_nodes_in_cluster(node, fn nodes -> nodes end, timeout) + end + + def with_nodes_in_cluster(node, fun, timeout \\ :infinity) do + case :rpc.call(node, :rabbit_mnesia, :cluster_nodes, [:running], timeout) do + {:badrpc, _} = err -> err + value -> fun.(value) + end + end + + def node_running?(node) do + :net_adm.ping(node) == :pong + end + + # Convert function to stream + def defer(fun) do + Stream.iterate(:ok, fn _ -> fun.() end) + |> Stream.drop(1) + |> Stream.take(1) + end + + # Streamify a function sequence passing result + # Execution can be terminated by an error {:error, _}. + # The error will be the last element in the stream. + # Functions can return {:ok, val}, so val will be passed + # to then next function, or {:ok, val, output} where + # val will be passed and output will be put into the stream + def stream_until_error_parameterised(funs, init) do + Stream.transform(funs, {:just, init}, fn + f, {:just, val} -> + case f.(val) do + {:error, _} = err -> {[err], :nothing} + :ok -> {[], {:just, val}} + {:ok, new_val} -> {[], {:just, new_val}} + {:ok, new_val, out} -> {[out], {:just, new_val}} + end + + _, :nothing -> + {:halt, :nothing} + end) + end + + # Streamify function sequence. + # Execution can be terminated by an error {:error, _}. + # The error will be the last element in the stream. + def stream_until_error(funs) do + stream_until_error_parameterised( + Enum.map( + funs, + fn fun -> + fn :no_param -> + case fun.() do + {:error, _} = err -> err + other -> {:ok, :no_param, other} + end + end + end + ), + :no_param + ) + end + + def apply_if_exported(mod, fun, args, default) do + Code.ensure_loaded(mod) + case function_exported?(mod, fun, length(args)) do + true -> apply(mod, fun, args) + false -> default + end + end + + def cli_acting_user, do: "rmq-cli" + + def string_or_inspect(val) do + case String.Chars.impl_for(val) do + nil -> + inspect(val) + + _ -> + try do + to_string(val) + catch + _, _ -> inspect(val) + end + end + end + + def evaluate_input_as_term(input) do + {:ok, tokens, _end_line} = :erl_scan.string(to_charlist(input <> ".")) + {:ok, abs_form} = :erl_parse.parse_exprs(tokens) + {:value, term_value, _bs} = :erl_eval.exprs(abs_form, :erl_eval.new_bindings()) + term_value + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/input.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/input.ex new file mode 100644 index 0000000000..5e1328be29 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/input.ex @@ -0,0 +1,39 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Input do + alias RabbitMQ.CLI.Core.Config + + def consume_single_line_string_with_prompt(prompt, opts) do + val = case Config.output_less?(opts) do + true -> + IO.read(:stdio, :line) + false -> + IO.puts(prompt) + IO.read(:stdio, :line) + end + + case val do + :eof -> :eof + "" -> :eof + s -> String.trim(s) + end + end + + def consume_multiline_string() do + val = IO.read(:stdio, :all) + + case val do + :eof -> :eof + "" -> :eof + s -> String.trim(s) + end + end + + def infer_password(prompt, opts) do + consume_single_line_string_with_prompt(prompt, opts) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/listeners.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/listeners.ex new file mode 100644 index 0000000000..0bc162186c --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/listeners.ex @@ -0,0 +1,312 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Listeners do + import Record, only: [defrecord: 3, extract: 2] + import RabbitCommon.Records + import RabbitMQ.CLI.Core.DataCoercion + + # + # API + # + + defrecord :certificate, :Certificate, extract(:Certificate, from_lib: "public_key/include/public_key.hrl") + defrecord :tbscertificate, :TBSCertificate, extract(:TBSCertificate, from_lib: "public_key/include/public_key.hrl") + defrecord :validity, :Validity, extract(:Validity, from_lib: "public_key/include/public_key.hrl") + + def listeners_on(listeners, target_node) do + Enum.filter(listeners, fn listener(node: node) -> + node == target_node + end) + end + + def listeners_with_certificates(listeners) do + Enum.filter(listeners, fn listener(opts: opts) -> + Keyword.has_key?(opts, :cacertfile) or Keyword.has_key?(opts, :certfile) + end) + end + + def listener_lines(listeners) do + listeners + |> listener_maps + |> Enum.map(fn %{interface: interface, port: port, protocol: protocol} -> + "Interface: #{interface}, port: #{port}, protocol: #{protocol}, purpose: #{ + protocol_label(to_atom(protocol)) + }" + end) + end + def listener_lines(listeners, node) do + listeners + |> listener_maps + |> Enum.map(fn %{interface: interface, port: port, protocol: protocol} -> + "Node: #{node}, interface: #{interface}, port: #{port}, protocol: #{protocol}, purpose: #{ + protocol_label(to_atom(protocol)) + }" + end) + end + + def listener_map(listener) when is_map(listener) do + listener + end + def listener_map(listener) do + # Listener options are left out intentionally: they can contain deeply nested values + # that are impossible to serialise to JSON. + # + # Management plugin/HTTP API had its fair share of bugs because of that + # and now filters out a lot of options. Raw listener data can be seen in + # rabbitmq-diagnostics status. + listener(node: node, protocol: protocol, ip_address: interface, port: port) = listener + + %{ + node: node, + protocol: protocol, + interface: :inet.ntoa(interface) |> to_string |> maybe_enquote_interface, + port: port, + purpose: protocol_label(to_atom(protocol)) + } + end + + def listener_maps(listeners) do + Enum.map(listeners, &listener_map/1) + end + + def listener_certs(listener) do + listener(node: node, protocol: protocol, ip_address: interface, port: port, opts: opts) = listener + + %{ + node: node, + protocol: protocol, + interface: :inet.ntoa(interface) |> to_string |> maybe_enquote_interface, + port: port, + purpose: protocol_label(to_atom(protocol)), + certfile: read_cert(Keyword.get(opts, :certfile)), + cacertfile: read_cert(Keyword.get(opts, :cacertfile)) + } + end + + def read_cert(nil) do + nil + end + def read_cert({:pem, pem}) do + pem + end + def read_cert(path) do + case File.read(path) do + {:ok, bin} -> + bin + {:error, _} = err -> + err + end + end + + def listener_expiring_within(listener, seconds) do + listener(node: node, protocol: protocol, ip_address: interface, port: port, opts: opts) = listener + certfile = Keyword.get(opts, :certfile) + cacertfile = Keyword.get(opts, :cacertfile) + now = :calendar.datetime_to_gregorian_seconds(:calendar.universal_time()) + expiry_date = now + seconds + certfile_expires_on = expired(cert_validity(read_cert(certfile)), expiry_date) + cacertfile_expires_on = expired(cert_validity(read_cert(cacertfile)), expiry_date) + case {certfile_expires_on, cacertfile_expires_on} do + {[], []} -> + false + _ -> + %{ + node: node, + protocol: protocol, + interface: interface, + port: port, + certfile: certfile, + cacertfile: cacertfile, + certfile_expires_on: certfile_expires_on, + cacertfile_expires_on: cacertfile_expires_on + } + end + end + + def expired_listener_map(%{node: node, protocol: protocol, interface: interface, port: port, certfile_expires_on: certfile_expires_on, cacertfile_expires_on: cacertfile_expires_on, certfile: certfile, cacertfile: cacertfile}) do + %{ + node: node, + protocol: protocol, + interface: :inet.ntoa(interface) |> to_string |> maybe_enquote_interface, + port: port, + purpose: protocol_label(to_atom(protocol)), + certfile: certfile |> to_string, + cacertfile: cacertfile |> to_string, + certfile_expires_on: expires_on_list(certfile_expires_on), + cacertfile_expires_on: expires_on_list(cacertfile_expires_on) + } + end + + def expires_on_list({:error, _} = error) do + [error] + end + def expires_on_list(expires) do + Enum.map(expires, &expires_on/1) + end + + def expires_on({:error, _} = error) do + error + end + def expires_on(seconds) do + {:ok, naive} = NaiveDateTime.from_erl(:calendar.gregorian_seconds_to_datetime(seconds)) + NaiveDateTime.to_string(naive) + end + + def expired(nil, _) do + [] + end + def expired({:error, _} = error, _) do + error + end + def expired(expires, expiry_date) do + Enum.filter(expires, fn ({:error, _}) -> true + (seconds) -> seconds < expiry_date end) + end + + def cert_validity(nil) do + nil + end + def cert_validity(cert) do + dsa_entries = :public_key.pem_decode(cert) + case dsa_entries do + [] -> + {:error, "The certificate file provided does not contain any PEM entry."} + _ -> + now = :calendar.datetime_to_gregorian_seconds(:calendar.universal_time()) + Enum.map(dsa_entries, fn ({:Certificate, _, _} = dsa_entry) -> + certificate(tbsCertificate: tbs_certificate) = :public_key.pem_entry_decode(dsa_entry) + tbscertificate(validity: validity) = tbs_certificate + validity(notAfter: not_after, notBefore: not_before) = validity + start = :pubkey_cert.time_str_2_gregorian_sec(not_before) + case start > now do + true -> + {:ok, naive} = NaiveDateTime.from_erl(:calendar.gregorian_seconds_to_datetime(start)) + startdate = NaiveDateTime.to_string(naive) + {:error, "Certificate is not yet valid. It starts on #{startdate}"} + false -> + :pubkey_cert.time_str_2_gregorian_sec(not_after) + end + ({type, _, _}) -> + {:error, "The certificate file provided contains a #{type} entry."} + end) + end + end + + def listener_rows(listeners) do + for listener(node: node, protocol: protocol, ip_address: interface, port: port) <- listeners do + # Listener options are left out intentionally, see above + [ + node: node, + protocol: protocol, + interface: :inet.ntoa(interface) |> to_string |> maybe_enquote_interface, + port: port, + purpose: protocol_label(to_atom(protocol)) + ] + end + end + + def protocol_label(:amqp), do: "AMQP 0-9-1 and AMQP 1.0" + def protocol_label(:'amqp/ssl'), do: "AMQP 0-9-1 and AMQP 1.0 over TLS" + def protocol_label(:mqtt), do: "MQTT" + def protocol_label(:'mqtt/ssl'), do: "MQTT over TLS" + def protocol_label(:stomp), do: "STOMP" + def protocol_label(:'stomp/ssl'), do: "STOMP over TLS" + def protocol_label(:http), do: "HTTP API" + def protocol_label(:https), do: "HTTP API over TLS (HTTPS)" + def protocol_label(:"http/web-mqtt"), do: "MQTT over WebSockets" + def protocol_label(:"https/web-mqtt"), do: "MQTT over WebSockets and TLS (HTTPS)" + def protocol_label(:"http/web-stomp"), do: "STOMP over WebSockets" + def protocol_label(:"https/web-stomp"), do: "STOMP over WebSockets and TLS (HTTPS)" + def protocol_label(:"http/prometheus"), do: "Prometheus exporter API over HTTP" + def protocol_label(:"https/prometheus"), do: "Prometheus exporter API over TLS (HTTPS)" + def protocol_label(:clustering), do: "inter-node and CLI tool communication" + def protocol_label(other), do: to_string(other) + + def normalize_protocol(proto) do + val = proto |> to_string |> String.downcase() + + case val do + "amqp091" -> "amqp" + "amqp0.9.1" -> "amqp" + "amqp0-9-1" -> "amqp" + "amqp0_9_1" -> "amqp" + "amqp10" -> "amqp" + "amqp1.0" -> "amqp" + "amqp1-0" -> "amqp" + "amqp1_0" -> "amqp" + "amqps" -> "amqp/ssl" + "mqtt3.1" -> "mqtt" + "mqtt3.1.1" -> "mqtt" + "mqtt31" -> "mqtt" + "mqtt311" -> "mqtt" + "mqtt3_1" -> "mqtt" + "mqtt3_1_1" -> "mqtt" + "mqtts" -> "mqtt/ssl" + "mqtt+tls" -> "mqtt/ssl" + "mqtt+ssl" -> "mqtt/ssl" + "stomp1.0" -> "stomp" + "stomp1.1" -> "stomp" + "stomp1.2" -> "stomp" + "stomp10" -> "stomp" + "stomp11" -> "stomp" + "stomp12" -> "stomp" + "stomp1_0" -> "stomp" + "stomp1_1" -> "stomp" + "stomp1_2" -> "stomp" + "stomps" -> "stomp/ssl" + "stomp+tls" -> "stomp/ssl" + "stomp+ssl" -> "stomp/ssl" + "https" -> "https" + "http1" -> "http" + "http1.1" -> "http" + "http_api" -> "http" + "management" -> "http" + "management_ui" -> "http" + "ui" -> "http" + "cli" -> "clustering" + "distribution" -> "clustering" + "webmqtt" -> "http/web-mqtt" + "web-mqtt" -> "http/web-mqtt" + "web_mqtt" -> "http/web-mqtt" + "webmqtt/tls" -> "https/web-mqtt" + "web-mqtt/tls" -> "https/web-mqtt" + "webmqtt/ssl" -> "https/web-mqtt" + "web-mqtt/ssl" -> "https/web-mqtt" + "webmqtt+tls" -> "https/web-mqtt" + "web-mqtt+tls" -> "https/web-mqtt" + "webmqtt+ssl" -> "https/web-mqtt" + "web-mqtt+ssl" -> "https/web-mqtt" + "webstomp" -> "http/web-stomp" + "web-stomp" -> "http/web-stomp" + "web_stomp" -> "http/web-stomp" + "webstomp/tls" -> "https/web-stomp" + "web-stomp/tls" -> "https/web-stomp" + "webstomp/ssl" -> "https/web-stomp" + "web-stomp/ssl" -> "https/web-stomp" + "webstomp+tls" -> "https/web-stomp" + "web-stomp+tls" -> "https/web-stomp" + "webstomp+ssl" -> "https/web-stomp" + "web-stomp+ssl" -> "https/web-stomp" + _ -> val + end + end + + # + # Implementation + # + + defp maybe_enquote_interface(value) do + # This simplistic way of distinguishing IPv6 addresses, + # networks address ranges, etc actually works better + # for the kind of values we can get here than :inet functions. MK. + regex = Regex.recompile!(~r/:/) + case value =~ regex do + true -> "[#{value}]" + false -> value + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/log_files.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/log_files.ex new file mode 100644 index 0000000000..b6d104bff0 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/log_files.ex @@ -0,0 +1,52 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2019-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.LogFiles do + @spec get_log_locations(atom, integer | :infinity) :: [String.t] | {:badrpc, term} + def get_log_locations(node_name, timeout) do + case :rabbit_misc.rpc_call(node_name, + :rabbit_lager, :log_locations, [], + timeout) do + {:badrpc, _} = error -> error; + list -> Enum.map(list, &to_string/1) + end + end + + @spec get_default_log_location(atom, integer | :infinity) :: + {:ok, String.t} | {:badrpc, term} | {:error, term} + def get_default_log_location(node_name, timeout) do + case get_log_locations(node_name, timeout) do + {:badrpc, _} = error -> error; + [] -> {:error, "No log files configured on the node"}; + [first_log | _] = log_locations -> + case get_log_config_file_location(node_name, timeout) do + {:badrpc, _} = error -> error; + nil -> {:ok, first_log}; + location -> + case Enum.member?(log_locations, location) do + true -> {:ok, to_string(location)}; + ## Configured location was not propagated to lager? + false -> {:ok, first_log} + end + end + end + end + + defp get_log_config_file_location(node_name, timeout) do + case :rabbit_misc.rpc_call(node_name, + :application, :get_env, [:rabbit, :log, :none], + timeout) do + {:badrpc, _} = error -> error; + :none -> nil; + log_config -> + case log_config[:file] do + nil -> nil; + file_config -> + file_config[:file] + end + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/memory.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/memory.ex new file mode 100644 index 0000000000..92db5b5502 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/memory.ex @@ -0,0 +1,105 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Memory do + alias RabbitMQ.CLI.InformationUnit, as: IU + + def memory_units do + ["k", "kiB", "M", "MiB", "G", "GiB", "kB", "MB", "GB", ""] + end + + def memory_unit_absolute(num, unit) when is_number(num) and num < 0, + do: {:bad_argument, [num, unit]} + + def memory_unit_absolute(num, "k") when is_number(num), do: power_as_int(num, 2, 10) + def memory_unit_absolute(num, "kiB") when is_number(num), do: power_as_int(num, 2, 10) + def memory_unit_absolute(num, "M") when is_number(num), do: power_as_int(num, 2, 20) + def memory_unit_absolute(num, "MiB") when is_number(num), do: power_as_int(num, 2, 20) + def memory_unit_absolute(num, "G") when is_number(num), do: power_as_int(num, 2, 30) + def memory_unit_absolute(num, "GiB") when is_number(num), do: power_as_int(num, 2, 30) + def memory_unit_absolute(num, "kB") when is_number(num), do: power_as_int(num, 10, 3) + def memory_unit_absolute(num, "MB") when is_number(num), do: power_as_int(num, 10, 6) + def memory_unit_absolute(num, "GB") when is_number(num), do: power_as_int(num, 10, 9) + def memory_unit_absolute(num, "") when is_number(num), do: num + def memory_unit_absolute(num, unit) when is_number(num), do: {:bad_argument, [unit]} + def memory_unit_absolute(num, unit), do: {:bad_argument, [num, unit]} + + def power_as_int(num, x, y), do: round(num * :math.pow(x, y)) + + def compute_relative_values(all_pairs) when is_map(all_pairs) do + compute_relative_values(Enum.into(all_pairs, [])) + end + def compute_relative_values(all_pairs) do + num_pairs = Keyword.delete(all_pairs, :strategy) + # Includes RSS, allocated and runtime-used ("erlang") values. + # See https://github.com/rabbitmq/rabbitmq-server/pull/1404. + totals = Keyword.get(num_pairs, :total) + pairs = Keyword.delete(num_pairs, :total) + # Should not be necessary but be more defensive. + total = + max_of(totals) || + Keyword.get(totals, :rss) || + Keyword.get(totals, :allocated) || + Keyword.get(totals, :erlang) + + pairs + |> Enum.map(fn {k, v} -> + pg = (v / total) |> fraction_to_percent() + {k, %{bytes: v, percentage: pg}} + end) + |> Enum.sort_by(fn {_key, %{bytes: bytes}} -> bytes end, &>=/2) + end + + def formatted_watermark(val) when is_float(val) do + %{relative: val} + end + def formatted_watermark({:absolute, val}) do + %{absolute: parse_watermark(val)} + end + def formatted_watermark(val) when is_integer(val) do + %{absolute: parse_watermark(val)} + end + def formatted_watermark(val) when is_bitstring(val) do + %{absolute: parse_watermark(val)} + end + def formatted_watermark(val) when is_list(val) do + %{absolute: parse_watermark(val)} + end + + def parse_watermark({:absolute, n}) do + case IU.parse(n) do + {:ok, parsed} -> parsed + err -> err + end + end + def parse_watermark(n) when is_bitstring(n) do + case IU.parse(n) do + {:ok, parsed} -> parsed + err -> err + end + end + def parse_watermark(n) when is_list(n) do + case IU.parse(n) do + {:ok, parsed} -> parsed + err -> err + end + end + def parse_watermark(n) when is_float(n) or is_integer(n) do + n + end + + # + # Implementation + # + + defp fraction_to_percent(x) do + Float.round(x * 100, 2) + end + + defp max_of(m) do + Keyword.values(m) |> Enum.max() + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/merges_default_virtual_host.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/merges_default_virtual_host.ex new file mode 100644 index 0000000000..94b1b768b6 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/merges_default_virtual_host.ex @@ -0,0 +1,15 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Should be used by commands that require rabbit app to be stopped +# but need no other execution environment validators. +defmodule RabbitMQ.CLI.Core.MergesDefaultVirtualHost do + defmacro __using__(_) do + quote do + def merge_defaults(args, opts), do: {args, Map.merge(%{vhost: "/"}, opts)} + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/merges_no_defaults.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/merges_no_defaults.ex new file mode 100644 index 0000000000..0ee6f3f05a --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/merges_no_defaults.ex @@ -0,0 +1,15 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Should be used by commands that require rabbit app to be stopped +# but need no other execution environment validators. +defmodule RabbitMQ.CLI.Core.MergesNoDefaults do + defmacro __using__(_) do + quote do + def merge_defaults(args, opts), do: {args, opts} + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/networking.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/networking.ex new file mode 100644 index 0000000000..12d99df7c1 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/networking.ex @@ -0,0 +1,73 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Networking do + @type address_family() :: :inet | :inet6 + + @spec address_family(String.t() | atom() | charlist() | binary()) :: address_family() + def address_family(value) do + val = RabbitMQ.CLI.Core.DataCoercion.to_atom(value) + case val do + :inet -> :inet + :inet4 -> :inet + :inet6 -> :inet6 + :ipv4 -> :inet + :ipv6 -> :inet6 + :IPv4 -> :inet + :IPv6 -> :inet6 + end + end + + @spec address_family(String.t() | atom()) :: boolean() + def valid_address_family?(value) when is_atom(value) do + valid_address_family?(to_string(value)) + end + def valid_address_family?("inet"), do: true + def valid_address_family?("inet4"), do: true + def valid_address_family?("inet6"), do: true + def valid_address_family?("ipv4"), do: true + def valid_address_family?("ipv6"), do: true + def valid_address_family?("IPv4"), do: true + def valid_address_family?("IPv6"), do: true + def valid_address_family?(_other), do: false + + @spec format_address(:inet.ip_address()) :: String.t() + def format_address(addr) do + to_string(:inet.ntoa(addr)) + end + + @spec format_addresses([:inet.ip_address()]) :: [String.t()] + def format_addresses(addrs) do + Enum.map(addrs, &format_address/1) + end + + @spec inetrc_map(nonempty_list()) :: map() + def inetrc_map(list) do + Enum.reduce(list, %{}, + fn hosts, acc when is_list(hosts) -> + Map.put(acc, "hosts", host_resolution_map(hosts)) + {k, v}, acc when k == :domain or k == :resolv_conf or k == :hosts_file -> + Map.put(acc, to_string(k), to_string(v)) + {k, v}, acc when is_list(v) when k == :search or k == :lookup -> + Map.put(acc, to_string(k), Enum.join(Enum.map(v, &to_string/1), ", ")) + {k, v}, acc when is_integer(v) -> + Map.put(acc, to_string(k), v) + {k, v, v2}, acc when is_tuple(v) when k == :nameserver or k == :nameservers or k == :alt_nameserver -> + Map.put(acc, to_string(k), "#{:inet.ntoa(v)}:#{v2}") + {k, v}, acc when is_tuple(v) when k == :nameserver or k == :nameservers or k == :alt_nameserver -> + Map.put(acc, to_string(k), to_string(:inet.ntoa(v))) + {k, v}, acc -> + Map.put(acc, to_string(k), to_string(v)) + end) + end + + def host_resolution_map(hosts) do + Enum.reduce(hosts, %{}, + fn {:host, address, hosts}, acc -> + Map.put(acc, to_string(:inet.ntoa(address)), Enum.map(hosts, &to_string/1)) + end) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/node_name.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/node_name.ex new file mode 100644 index 0000000000..c39b215ca7 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/node_name.ex @@ -0,0 +1,198 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.NodeName do + alias RabbitMQ.CLI.Core.Config + + @moduledoc """ + Provides functions for correctly constructing node names given a node type and optional base name. + """ + + @doc """ + Constructs complete node name based on :longnames or :shortnames and + a base name, in the same manner as Erlang/OTP lib/kernel/src/net_kernel.erl + """ + def create(base, type) do + create_name(base, type, 1) + end + + @doc """ + Get local hostname + """ + def hostname, do: :inet_db.gethostname() |> List.to_string() + + @doc """ + Get hostname part of current node name + """ + def hostname_from_node do + [_, hostname] = split_node(Node.self()) + hostname + end + + @doc """ + Get hostname part of given node name + """ + def hostname_from_node(name) do + [_, hostname] = split_node(name) + hostname + end + + def split_node(name) when is_atom(name) do + split_node(to_string(name)) + end + + def split_node(name) do + case String.split(name, "@", parts: 2) do + ["", host] -> + default_name = to_string(Config.default(:node)) + [default_name, host] + + [_head, _host] = rslt -> + rslt + + [head] -> + [head, ""] + end + end + + @doc """ + Get local domain. If unavailable, makes a good guess. We're using + :inet_db here because that's what Erlang/OTP uses when it creates a node + name: + https://github.com/erlang/otp/blob/8ca061c3006ad69c2a8d1c835d0d678438966dfc/lib/kernel/src/net_kernel.erl#L1363-L1445 + """ + def domain do + domain(1) + end + + # + # Implementation + # + + defp domain(attempt) do + case {attempt, :inet_db.res_option(:domain), :os.type()} do + {1, [], _} -> + do_load_resolv() + domain(0) + + {0, [], {:unix, :darwin}} -> + "local" + + {0, [], _} -> + "localdomain" + + {_, domain, _} -> + List.to_string(domain) + end + end + + defp create_name(name, long_or_short_names, attempt) do + {head, host1} = create_hostpart(name, long_or_short_names) + + case host1 do + {:ok, host_part} -> + case valid_name_head(head) do + true -> + {:ok, String.to_atom(head <> "@" <> host_part)} + + false -> + {:error, {:node_name, :invalid_node_name_head}} + end + + {:error, :long} when attempt == 1 -> + do_load_resolv() + create_name(name, long_or_short_names, 0) + + {:error, :long} when attempt == 0 -> + case valid_name_head(head) do + true -> + {:ok, String.to_atom(head <> "@" <> hostname() <> "." <> domain())} + + false -> + {:error, {:node_name, :invalid_node_name_head}} + end + + {:error, :hostname_not_allowed} -> + {:error, {:node_name, :hostname_not_allowed}} + + {:error, err_type} -> + {:error, {:node_name, err_type}} + end + end + + defp create_hostpart(name, long_or_short_names) do + [head, host] = split_node(name) + + host1 = + case {host, long_or_short_names} do + {"", :shortnames} -> + case :inet_db.gethostname() do + inet_db_host when inet_db_host != [] -> + {:ok, to_string(inet_db_host)} + + _ -> + {:error, :short} + end + + {"", :longnames} -> + case {:inet_db.gethostname(), :inet_db.res_option(:domain)} do + {inet_db_host, inet_db_domain} + when inet_db_host != [] and inet_db_domain != [] -> + {:ok, to_string(inet_db_host) <> "." <> to_string(inet_db_domain)} + + _ -> + {:error, :long} + end + + {_, type} -> + validate_hostname(host, type) + end + + {head, host1} + end + + defp validate_hostname(host, :longnames) do + case String.contains?(host, ".") do + true -> + validate_hostname_rx(host) + + _ -> + validate_hostname(host <> "." <> domain(), :longnames) + end + end + + defp validate_hostname(host, :shortnames) do + case String.contains?(host, ".") do + true -> + {:error, :short} + + _ -> + validate_hostname_rx(host) + end + end + + defp validate_hostname_rx(host) do + rx = Regex.compile!("^[!-ÿ]*$", [:unicode]) + + case Regex.match?(rx, host) do + true -> + {:ok, host} + + false -> + {:error, :hostname_not_allowed} + end + end + + defp valid_name_head(head) do + rx = Regex.compile!("^[0-9A-Za-z_\\-]+$", [:unicode]) + Regex.match?(rx, head) + end + + defp do_load_resolv do + # It could be we haven't read domain name from resolv file yet + :ok = :inet_config.do_load_resolv(:os.type(), :longnames) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/os_pid.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/os_pid.ex new file mode 100644 index 0000000000..0b53d59748 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/os_pid.ex @@ -0,0 +1,56 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.OsPid do + @external_process_check_interval 1000 + + @pid_regex ~r/^\s*(?<pid>\d+)/ + + # + # API + # + + def wait_for_os_process_death(pid) do + case :rabbit_misc.is_os_process_alive(pid) do + true -> + :timer.sleep(@external_process_check_interval) + wait_for_os_process_death(pid) + + false -> + :ok + end + end + + def read_pid_from_file(pidfile_path, should_wait) do + case {:file.read_file(pidfile_path), should_wait} do + {{:ok, contents}, _} -> + pid_regex = Regex.recompile!(@pid_regex) + + case Regex.named_captures(pid_regex, contents)["pid"] do + # e.g. the file is empty + nil -> + {:error, :could_not_read_pid_from_file, {:contents, contents}} + + pid_string -> + try do + {pid, _remainder} = Integer.parse(pid_string) + pid + rescue + _e in ArgumentError -> + {:error, {:could_not_read_pid_from_file, {:contents, contents}}} + end + end + + # file does not exist, wait and re-check + {{:error, :enoent}, true} -> + :timer.sleep(@external_process_check_interval) + read_pid_from_file(pidfile_path, should_wait) + + {{:error, details}, _} -> + {:error, :could_not_read_pid_from_file, details} + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/output.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/output.ex new file mode 100644 index 0000000000..1b2436cba4 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/output.ex @@ -0,0 +1,72 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Output do + def format_output(:ok, _, _) do + :ok + end + + # the command intends to produce no output + def format_output({:ok, nil}, _, _) do + :ok + end + + def format_output({:ok, :check_passed}, _, _) do + :ok + end + + def format_output({:ok, output}, formatter, options) do + {:ok, formatter.format_output(output, options)} + end + + def format_output({:stream, stream}, formatter, options) do + {:stream, formatter.format_stream(stream, options)} + end + + def print_output(output, printer, options) do + {:ok, printer_state} = printer.init(options) + exit_code = print_output_0(output, printer, printer_state) + printer.finish(printer_state) + exit_code + end + + def print_output_0(:ok, printer, printer_state) do + printer.print_ok(printer_state) + :ok + end + + # the command intends to produce no output + def print_output_0({:ok, nil}, _printer, _printer_state) do + :ok + end + + def print_output_0({:ok, :check_passed}, _printer, _printer_state) do + :ok + end + + def print_output_0({:ok, single_value}, printer, printer_state) do + printer.print_output(single_value, printer_state) + :ok + end + + def print_output_0({:stream, stream}, printer, printer_state) do + case print_output_stream(stream, printer, printer_state) do + :ok -> :ok + {:error, _} = err -> err + end + end + + def print_output_stream(stream, printer, printer_state) do + Enum.reduce_while(stream, :ok, fn + {:error, err}, _ -> + {:halt, {:error, err}} + + val, _ -> + printer.print_output(val, printer_state) + {:cont, :ok} + end) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/parser.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/parser.ex new file mode 100644 index 0000000000..28c4df2aa4 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/parser.ex @@ -0,0 +1,311 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Parser do + alias RabbitMQ.CLI.{CommandBehaviour, FormatterBehaviour} + alias RabbitMQ.CLI.Core.{CommandModules, Config} + + def default_switches() do + [ + node: :atom, + quiet: :boolean, + silent: :boolean, + dry_run: :boolean, + vhost: :string, + # for backwards compatibility, + # not all commands support timeouts + timeout: :integer, + longnames: :boolean, + formatter: :string, + printer: :string, + file: :string, + script_name: :atom, + rabbitmq_home: :string, + mnesia_dir: :string, + plugins_dir: :string, + enabled_plugins_file: :string, + aliases_file: :string, + erlang_cookie: :atom, + help: :boolean, + print_stacktrace: :boolean + ] + end + + def default_aliases() do + [ + p: :vhost, + n: :node, + q: :quiet, + s: :silent, + l: :longnames, + # for backwards compatibility, + # not all commands support timeouts + t: :timeout, + "?": :help + ] + end + + @spec parse([String.t()]) :: + {command :: :no_command | atom() | {:suggest, String.t()}, command_name :: String.t(), + arguments :: [String.t()], options :: map(), + invalid :: [{String.t(), String.t() | nil}]} + + def parse(input) do + {parsed_args, options, invalid} = parse_global(input) + {command_name, command_module, arguments} = look_up_command(parsed_args, options) + + case command_module do + nil -> + {:no_command, command_name, arguments, options, invalid} + + {:suggest, _} = suggest -> + {suggest, command_name, arguments, options, invalid} + + {:alias, alias_module, alias_content} -> + {[_alias_command_name | cmd_arguments], cmd_options, cmd_invalid} = + parse_alias(input, command_name, alias_module, alias_content, options) + + {alias_module, command_name, cmd_arguments, cmd_options, cmd_invalid} + + command_module when is_atom(command_module) -> + {[^command_name | cmd_arguments], cmd_options, cmd_invalid} = + parse_command_specific(input, command_module, options) + + {command_module, command_name, cmd_arguments, cmd_options, cmd_invalid} + end + end + + def command_suggestion(_cmd_name, empty) when empty == %{} do + nil + end + def command_suggestion(typed, module_map) do + RabbitMQ.CLI.AutoComplete.suggest_command(typed, module_map) + end + + defp look_up_command(parsed_args, options) do + case parsed_args do + [cmd_name | arguments] -> + ## This is an optimisation for pluggable command discovery. + ## Most of the time a command will be from rabbitmqctl application + ## so there is not point in scanning plugins for potential commands + CommandModules.load_core(options) + core_commands = CommandModules.module_map_core() + + command = + case core_commands[cmd_name] do + nil -> + CommandModules.load(options) + module_map = CommandModules.module_map() + + module_map[cmd_name] || + command_alias(cmd_name, module_map, options) || + command_suggestion(cmd_name, module_map) + + c -> + c + end + + {cmd_name, command, arguments} + + [] -> + {"", nil, []} + end + end + + defp command_alias(cmd_name, module_map, options) do + aliases = load_aliases(options) + + case aliases[cmd_name] do + nil -> + nil + + [alias_cmd_name | _] = alias_content -> + case module_map[alias_cmd_name] do + nil -> nil + module -> {:alias, module, alias_content} + end + end + end + + defp load_aliases(options) do + aliases_file = Config.get_option(:aliases_file, options) + + case aliases_file && File.read(aliases_file) do + ## No aliases file + nil -> + %{} + + {:ok, content} -> + String.split(content, "\n") + |> Enum.reduce( + %{}, + fn str, acc -> + case String.split(str, "=", parts: 2) do + [alias_name, alias_string] -> + Map.put(acc, String.trim(alias_name), OptionParser.split(alias_string)) + + _ -> + acc + end + end + ) + + {:error, err} -> + IO.puts(:stderr, "Error reading aliases file #{aliases_file}: #{err}") + %{} + end + end + + defp parse_alias(input, command_name, module, alias_content, options) do + {pre_command_options, tail, invalid} = parse_global_head(input) + [^command_name | other] = tail + aliased_input = alias_content ++ other + {args, options, command_invalid} = parse_command_specific(aliased_input, module, options) + merged_options = Map.merge(options, pre_command_options) + {args, merged_options, command_invalid ++ invalid} + end + + def parse_command_specific(input, command, options \\ %{}) do + formatter = Config.get_formatter(command, options) + + switches = build_switches(default_switches(), command, formatter) + aliases = build_aliases(default_aliases(), command, formatter) + parse_generic(input, switches, aliases) + end + + def parse_global_head(input) do + switches = default_switches() + aliases = default_aliases() + + {options, tail, invalid} = + OptionParser.parse_head( + input, + strict: switches, + aliases: aliases, + allow_nonexistent_atoms: true + ) + + norm_options = normalize_options(options, switches) |> Map.new() + {norm_options, tail, invalid} + end + + def parse_global(input) do + switches = default_switches() + aliases = default_aliases() + parse_generic(input, switches, aliases) + end + + defp parse_generic(input, switches, aliases) do + {options, args, invalid} = + OptionParser.parse( + input, + strict: switches, + aliases: aliases, + allow_nonexistent_atoms: true + ) + + norm_options = normalize_options(options, switches) |> Map.new() + {args, norm_options, invalid} + end + + defp build_switches(default, command, formatter) do + command_switches = CommandBehaviour.switches(command) + formatter_switches = FormatterBehaviour.switches(formatter) + + assert_no_conflict( + command, + command_switches, + formatter_switches, + :redefining_formatter_switches + ) + + merge_if_different( + default, + formatter_switches, + {:formatter_invalid, + {formatter, {:redefining_global_switches, default, formatter_switches}}} + ) + |> merge_if_different( + command_switches, + {:command_invalid, {command, {:redefining_global_switches, default, command_switches}}} + ) + end + + defp assert_no_conflict(command, command_fields, formatter_fields, err) do + merge_if_different( + formatter_fields, + command_fields, + {:command_invalid, {command, {err, formatter_fields, command_fields}}} + ) + + :ok + end + + defp build_aliases(default, command, formatter) do + command_aliases = CommandBehaviour.aliases(command) + formatter_aliases = FormatterBehaviour.aliases(formatter) + + assert_no_conflict(command, command_aliases, formatter_aliases, :redefining_formatter_aliases) + + merge_if_different( + default, + formatter_aliases, + {:formatter_invalid, {command, {:redefining_global_aliases, default, formatter_aliases}}} + ) + |> merge_if_different( + command_aliases, + {:command_invalid, {command, {:redefining_global_aliases, default, command_aliases}}} + ) + end + + defp merge_if_different(default, specific, error) do + case keyword_intersect(default, specific) do + [] -> + Keyword.merge(default, specific) + + conflicts -> + # if all conflicting keys are of the same type, + # that's acceptable + case Enum.all?( + conflicts, + fn c -> + Keyword.get(default, c) == Keyword.get(specific, c) + end + ) do + true -> Keyword.merge(default, specific) + false -> exit(error) + end + end + end + + defp keyword_intersect(one, two) do + one_keys = MapSet.new(Keyword.keys(one)) + two_keys = MapSet.new(Keyword.keys(two)) + intersection = MapSet.intersection(one_keys, two_keys) + + case Enum.empty?(intersection) do + true -> [] + false -> MapSet.to_list(intersection) + end + end + + defp normalize_options(options, switches) do + Enum.map( + options, + fn {key, option} -> + {key, normalize_type(option, switches[key])} + end + ) + end + + defp normalize_type(value, :atom) when is_binary(value) do + String.to_atom(value) + end + + defp normalize_type(value, _type) do + value + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/paths.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/paths.ex new file mode 100644 index 0000000000..0e90834771 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/paths.ex @@ -0,0 +1,55 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Paths do + alias RabbitMQ.CLI.Core.Config + import RabbitMQ.CLI.Core.Platform + + def plugins_dir(_, opts) do + plugins_dir(opts) + end + + def plugins_dir(opts) do + case Config.get_option(:plugins_dir, opts) do + nil -> + {:error, :no_plugins_dir} + + dir -> + paths = String.split(to_string(dir), path_separator()) + + case Enum.any?(paths, &File.dir?/1) do + true -> {:ok, dir} + false -> {:error, :plugins_dir_does_not_exist} + end + end + end + + def require_mnesia_dir(opts) do + case Application.get_env(:mnesia, :dir) do + nil -> + case Config.get_option(:mnesia_dir, opts) do + nil -> {:error, :mnesia_dir_not_found} + val -> Application.put_env(:mnesia, :dir, to_charlist(val)) + end + + _ -> + :ok + end + end + + def require_feature_flags_file(opts) do + case Application.get_env(:rabbit, :feature_flags_file) do + nil -> + case Config.get_option(:feature_flags_file, opts) do + nil -> {:error, :feature_flags_file_not_found} + val -> Application.put_env(:rabbit, :feature_flags_file, to_charlist(val)) + end + + _ -> + :ok + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/platform.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/platform.ex new file mode 100644 index 0000000000..561b2adb58 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/platform.ex @@ -0,0 +1,37 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Platform do + def path_separator() do + case :os.type() do + {:unix, _} -> ":" + {:win32, _} -> ";" + end + end + + def line_separator() do + case :os.type() do + {:unix, _} -> "\n" + {:win32, _} -> "\r\n" + end + end + + def os_name({:unix, :linux}) do + "Linux" + end + def os_name({:unix, :darwin}) do + "macOS" + end + def os_name({:unix, :freebsd}) do + "FreeBSD" + end + def os_name({:unix, name}) do + name |> to_string |> String.capitalize + end + def os_name({:win32, _}) do + "Windows" + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/requires_rabbit_app_running.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/requires_rabbit_app_running.ex new file mode 100644 index 0000000000..7f5337a6e7 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/requires_rabbit_app_running.ex @@ -0,0 +1,17 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Should be used by commands that require rabbit app to be running +# but need no other execution environment validators. +defmodule RabbitMQ.CLI.Core.RequiresRabbitAppRunning do + defmacro __using__(_) do + quote do + def validate_execution_environment(args, opts) do + RabbitMQ.CLI.Core.Validators.rabbit_is_running(args, opts) + end + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/requires_rabbit_app_stopped.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/requires_rabbit_app_stopped.ex new file mode 100644 index 0000000000..48b2b6dcd0 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/requires_rabbit_app_stopped.ex @@ -0,0 +1,17 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Should be used by commands that require rabbit app to be stopped +# but need no other execution environment validators. +defmodule RabbitMQ.CLI.Core.RequiresRabbitAppStopped do + defmacro __using__(_) do + quote do + def validate_execution_environment(args, opts) do + RabbitMQ.CLI.Core.Validators.rabbit_is_not_running(args, opts) + end + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/validators.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/validators.ex new file mode 100644 index 0000000000..666d7af065 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/validators.ex @@ -0,0 +1,115 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Provides common validation functions. +defmodule RabbitMQ.CLI.Core.Validators do + alias RabbitMQ.CLI.Core.Helpers + import RabbitMQ.CLI.Core.{CodePath, Paths} + + + def chain([validator | rest], args) do + case apply(validator, args) do + :ok -> chain(rest, args) + {:ok, _} -> chain(rest, args) + {:validation_failure, err} -> {:validation_failure, err} + {:error, err} -> {:validation_failure, err} + end + end + + def chain([], _) do + :ok + end + + def validate_step(:ok, step) do + case step.() do + {:error, err} -> {:validation_failure, err} + _ -> :ok + end + end + + def validate_step({:validation_failure, err}, _) do + {:validation_failure, err} + end + + def node_is_not_running(_, %{node: node_name}) do + case Helpers.node_running?(node_name) do + true -> {:validation_failure, :node_running} + false -> :ok + end + end + + def node_is_running(_, %{node: node_name}) do + case Helpers.node_running?(node_name) do + false -> {:validation_failure, :node_not_running} + true -> :ok + end + end + + def mnesia_dir_is_set(_, opts) do + case require_mnesia_dir(opts) do + :ok -> :ok + {:error, err} -> {:validation_failure, err} + end + end + + def feature_flags_file_is_set(_, opts) do + case require_feature_flags_file(opts) do + :ok -> :ok + {:error, err} -> {:validation_failure, err} + end + end + + def rabbit_is_loaded(_, opts) do + case require_rabbit(opts) do + :ok -> :ok + {:error, err} -> {:validation_failure, err} + end + end + + def rabbit_app_running?(%{node: node, timeout: timeout}) do + case :rabbit_misc.rpc_call(node, :rabbit, :is_running, [], timeout) do + true -> true + false -> false + other -> {:error, other} + end + end + + def rabbit_app_running?(_, opts) do + rabbit_app_running?(opts) + end + + def rabbit_is_running(args, opts) do + case rabbit_app_state(args, opts) do + :running -> :ok + :stopped -> {:validation_failure, :rabbit_app_is_stopped} + other -> other + end + end + + def rabbit_is_running_or_offline_flag_used(_args, %{offline: true}) do + :ok + end + + def rabbit_is_running_or_offline_flag_used(args, opts) do + rabbit_is_running(args, opts) + end + + def rabbit_is_not_running(args, opts) do + case rabbit_app_state(args, opts) do + :running -> {:validation_failure, :rabbit_app_is_running} + :stopped -> :ok + other -> other + end + end + + def rabbit_app_state(_, opts) do + case rabbit_app_running?(opts) do + true -> :running + false -> :stopped + {:error, err} -> {:error, err} + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/core/version.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/version.ex new file mode 100644 index 0000000000..bd5a24f9a0 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/core/version.ex @@ -0,0 +1,24 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Core.Version do + @default_timeout 30_000 + + def local_version do + to_string(:rabbit_misc.version()) + end + + + def remote_version(node_name) do + remote_version(node_name, @default_timeout) + end + def remote_version(node_name, timeout) do + case :rabbit_misc.rpc_call(node_name, :rabbit_misc, :version, [], timeout) do + {:badrpc, _} = err -> err + val -> val + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/add_user_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/add_user_command.ex new file mode 100644 index 0000000000..514922cac9 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/add_user_command.ex @@ -0,0 +1,98 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.AddUserCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ExitCodes, Helpers, Input} + import RabbitMQ.CLI.Core.Config, only: [output_less?: 1] + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate(args, _) when length(args) < 1, do: {:validation_failure, :not_enough_args} + def validate(args, _) when length(args) > 2, do: {:validation_failure, :too_many_args} + def validate([_], _), do: :ok + def validate(["", _], _) do + {:validation_failure, {:bad_argument, "user cannot be an empty string"}} + end + def validate([_, _], _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([username], %{node: node_name} = opts) do + # note: blank passwords are currently allowed, they make sense + # e.g. when a user only authenticates using X.509 certificates. + # Credential validators can be used to require passwords of a certain length + # or following a certain pattern. This is a core server responsibility. MK. + case Input.infer_password("Password: ", opts) do + :eof -> {:error, :not_enough_args} + password -> :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :add_user, + [username, password, Helpers.cli_acting_user()] + ) + end + end + def run([username, password], %{node: node_name}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :add_user, + [username, password, Helpers.cli_acting_user()] + ) + end + + def output({:error, :not_enough_args}, _) do + {:error, ExitCodes.exit_dataerr(), "Password is not provided via argument or stdin"} + end + def output({:error, {:user_already_exists, username}}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => "User #{username} already exists"}} + end + def output({:error, {:user_already_exists, username}}, _) do + {:error, ExitCodes.exit_software(), "User \"#{username}\" already exists"} + end + def output(:ok, %{formatter: "json", node: node_name}) do + m = %{ + "status" => "ok", + "node" => node_name, + "message" => "Done. Don't forget to grant the user permissions to some virtual hosts! See 'rabbitmqctl help set_permissions' to learn more." + } + {:ok, m} + end + def output(:ok, opts) do + case output_less?(opts) do + true -> + :ok + false -> + {:ok, "Done. Don't forget to grant the user permissions to some virtual hosts! See 'rabbitmqctl help set_permissions' to learn more."} + end + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "add_user <username> <password>" + + def usage_additional() do + [ + ["<username>", "Self-explanatory"], + ["<password>", "Password this user will authenticate with. Use a blank string to disable password-based authentication."] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :user_management + + def description() do + "Creates a new user in the internal database. This user will have no permissions for any virtual hosts by default." + end + + def banner([username | _], _), do: "Adding user \"#{username}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/add_vhost_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/add_vhost_command.ex new file mode 100644 index 0000000000..04c1e61106 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/add_vhost_command.ex @@ -0,0 +1,62 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.AddVhostCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches(), do: [description: :string, + tags: :string] + def aliases(), do: [d: :description] + + def merge_defaults(args, opts) do + {args, Map.merge(%{description: "", tags: ""}, opts)} + end + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([vhost], %{node: node_name, description: desc, tags: tags}) do + :rabbit_misc.rpc_call(node_name, :rabbit_vhost, :add, [vhost, desc, parse_tags(tags), Helpers.cli_acting_user()]) + end + def run([vhost], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit_vhost, :add, [vhost, Helpers.cli_acting_user()]) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "add_vhost <vhost> [--description <description> --tags \"<tag1>,<tag2>,<...>\"]" + + def usage_additional() do + [ + ["<vhost>", "Virtual host name"], + ["--description <description>", "Virtual host description"], + ["--tags <tags>", "Command separated list of tags"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.virtual_hosts() + ] + end + + def help_section(), do: :virtual_hosts + + def description(), do: "Creates a virtual host" + + def banner([vhost], _), do: "Adding vhost \"#{vhost}\" ..." + + # + # Implementation + # + + def parse_tags(tags) do + String.split(tags, ",", trim: true) + |> Enum.map(&String.trim/1) + |> Enum.map(&String.to_atom/1) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/authenticate_user_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/authenticate_user_command.ex new file mode 100644 index 0000000000..9913633b84 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/authenticate_user_command.ex @@ -0,0 +1,79 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.AuthenticateUserCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ExitCodes, Input} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate(args, _) when length(args) < 1, do: {:validation_failure, :not_enough_args} + def validate(args, _) when length(args) > 2, do: {:validation_failure, :too_many_args} + def validate([_], _), do: :ok + def validate([_, _], _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([user], %{node: node_name} = opts) do + # note: blank passwords are currently allowed, they make sense + # e.g. when a user only authenticates using X.509 certificates. + # Credential validators can be used to require passwords of a certain length + # or following a certain pattern. This is a core server responsibility. MK. + case Input.infer_password("Password: ", opts) do + :eof -> {:error, :not_enough_args} + password -> :rabbit_misc.rpc_call( + node_name, + :rabbit_access_control, + :check_user_pass_login, + [user, password] + ) + end + end + def run([user, password], %{node: node_name}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_access_control, + :check_user_pass_login, + [user, password] + ) + end + + def usage, do: "authenticate_user <username> <password>" + + def usage_additional() do + [ + ["<username>", "Username to use"], + ["<password>", "Password to use. Can be entered via stdin in interactive mode."] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :user_management + + def description(), do: "Attempts to authenticate a user. Exits with a non-zero code if authentication fails." + + def banner([username | _], _), do: "Authenticating user \"#{username}\" ..." + + def output({:error, :not_enough_args}, _) do + {:error, ExitCodes.exit_software(), "Password is not provided via argument or stdin"} + end + def output({:refused, user, msg, args}, _) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_dataerr(), + "Error: failed to authenticate user \"#{user}\"\n" <> + to_string(:io_lib.format(msg, args))} + end + def output({:ok, _user}, _) do + {:ok, "Success"} + end + + use RabbitMQ.CLI.DefaultOutput +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/autocomplete_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/autocomplete_command.ex new file mode 100644 index 0000000000..19deb74f79 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/autocomplete_command.ex @@ -0,0 +1,53 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.AutocompleteCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + + alias RabbitMQ.CLI.Core.{Config, DocGuide} + + def scopes(), do: [:ctl, :diagnostics, :plugins, :queues] + + def distribution(_), do: :none + + def merge_defaults(args, opts) do + # enforce --silent as shell completion does not + # expect to receive any additional output, so the command + # is not really interactive + {args, Map.merge(opts, %{silent: true})} + end + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + + def run(args, %{script_name: script_name}) do + {:stream, RabbitMQ.CLI.AutoComplete.complete(script_name, args)} + end + def run(args, opts) do + script_name = Config.get_system_option(:script_name, opts) + + {:stream, RabbitMQ.CLI.AutoComplete.complete(script_name, args)} + end + use RabbitMQ.CLI.DefaultOutput + + def usage() do + "autocomplete [prefix]" + end + + def banner(_args, _opts) do + nil + end + + def usage_doc_guides() do + [ + DocGuide.cli() + ] + end + + def help_section(), do: :help + + def description(), do: "Provides command name autocomplete variants" +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/await_online_nodes_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/await_online_nodes_command.ex new file mode 100644 index 0000000000..f0d1df6a02 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/await_online_nodes_command.ex @@ -0,0 +1,62 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.AwaitOnlineNodesCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + + @default_timeout 300_000 + + def merge_defaults(args, opts) do + timeout = + case opts[:timeout] do + nil -> @default_timeout + :infinity -> @default_timeout + other -> other + end + + {args, Map.merge(opts, %{timeout: timeout})} + end + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.AcceptsOnePositiveIntegerArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([count], %{node: node_name, timeout: timeout}) do + {n, _} = Integer.parse(count) + :rabbit_misc.rpc_call(node_name, :rabbit_nodes, :await_running_count, [n, timeout]) + end + + def output({:error, :timeout}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), + "Error: timed out while waiting. Not enough nodes joined #{node_name}'s cluster."} + end + + use RabbitMQ.CLI.DefaultOutput + + def banner([count], %{node: node_name, timeout: timeout}) when is_number(timeout) do + "Will wait for at least #{count} nodes to join the cluster of #{node_name}. Timeout: #{ + trunc(timeout / 1000) + } seconds." + end + + def banner([count], %{node: node_name, timeout: _timeout}) do + "Will wait for at least #{count} nodes to join the cluster of #{node_name}." + end + + def usage() do + "await_online_nodes <count>" + end + + def usage_additional() do + [ + ["<count>", "how many cluster members must be up in order for this command to exit. When <count> is 1, always exits immediately."] + ] + end + + def help_section(), do: :cluster_management + + def description(), do: "Waits for <count> nodes to join the cluster" +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/await_startup_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/await_startup_command.ex new file mode 100644 index 0000000000..9a898224ce --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/await_startup_command.ex @@ -0,0 +1,45 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.AwaitStartupCommand do + @moduledoc """ + Waits until target node is fully booted. If the node is already running, + returns immediately. + + This command is meant to be used when automating deployments. + See also `AwaitOnlineNodesCommand`. + """ + + import RabbitMQ.CLI.Core.Config, only: [output_less?: 1] + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @default_timeout 300_000 + + def merge_defaults(args, opts) do + {args, Map.merge(%{timeout: @default_timeout}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout} = opts) do + :rabbit_misc.rpc_call(node_name, :rabbit, :await_startup, [ + node_name, + not output_less?(opts), + timeout + ]) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "await_startup" + + def help_section(), do: :node_management + + def description(), do: "Waits for the RabbitMQ application to start on the target node" + + def banner(_, _), do: nil +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/cancel_sync_queue_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/cancel_sync_queue_command.ex new file mode 100644 index 0000000000..2858040039 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/cancel_sync_queue_command.ex @@ -0,0 +1,52 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.CancelSyncQueueCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([queue], %{vhost: vhost, node: node_name}) do + :rpc.call( + node_name, + :rabbit_mirror_queue_misc, + :cancel_sync_queue, + [:rabbit_misc.r(vhost, :queue, queue)], + :infinity + ) + end + + def usage, do: "cancel_sync_queue [--vhost <vhost>] <queue>" + + def usage_additional() do + [ + ["<queue>", "Queue name"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.mirroring() + ] + end + + def help_section(), do: :replication + + def description(), do: "Instructs a synchronising mirrored queue to stop synchronising itself" + + def banner([queue], %{vhost: vhost, node: _node}) do + "Stopping synchronising queue '#{queue}' in vhost '#{vhost}' ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/change_cluster_node_type_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/change_cluster_node_type_command.ex new file mode 100644 index 0000000000..93fc9c7da0 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/change_cluster_node_type_command.ex @@ -0,0 +1,87 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ChangeClusterNodeTypeCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, opts} + end + + def validate([], _), do: {:validation_failure, :not_enough_args} + + # node type + def validate(["disc"], _), do: :ok + def validate(["disk"], _), do: :ok + def validate(["ram"], _), do: :ok + + def validate([_], _), + do: {:validation_failure, {:bad_argument, "The node type must be either disc or ram."}} + + def validate(_, _), do: {:validation_failure, :too_many_args} + + use RabbitMQ.CLI.Core.RequiresRabbitAppStopped + + def run([node_type_arg], %{node: node_name}) do + normalized_type = normalize_type(String.to_atom(node_type_arg)) + current_type = :rabbit_misc.rpc_call(node_name, :rabbit_mnesia, :node_type, []) + + case current_type do + ^normalized_type -> + {:ok, "Node type is already #{normalized_type}"} + + _ -> + :rabbit_misc.rpc_call(node_name, :rabbit_mnesia, :change_cluster_node_type, [ + normalized_type + ]) + end + end + + def usage() do + "change_cluster_node_type <disc | ram>" + end + + def usage_additional() do + [ + ["<disc | ram>", "New node type"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.clustering() + ] + end + + def help_section(), do: :cluster_management + + def description(), do: "Changes the type of the cluster node" + + def banner([node_type], %{node: node_name}) do + "Turning #{node_name} into a #{node_type} node" + end + + def output({:error, :mnesia_unexpectedly_running}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), + RabbitMQ.CLI.DefaultOutput.mnesia_running_error(node_name)} + end + + use RabbitMQ.CLI.DefaultOutput + + defp normalize_type(:ram) do + :ram + end + + defp normalize_type(:disc) do + :disc + end + + defp normalize_type(:disk) do + :disc + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/change_password_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/change_password_command.ex new file mode 100644 index 0000000000..b0dec0a824 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/change_password_command.ex @@ -0,0 +1,76 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ChangePasswordCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ExitCodes, Helpers, Input} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate(args, _) when length(args) < 1, do: {:validation_failure, :not_enough_args} + def validate(args, _) when length(args) > 2, do: {:validation_failure, :too_many_args} + def validate([_], _), do: :ok + def validate([_, _], _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([username], %{node: node_name} = opts) do + # note: blank passwords are currently allowed, they make sense + # e.g. when a user only authenticates using X.509 certificates. + # Credential validators can be used to require passwords of a certain length + # or following a certain pattern. This is a core server responsibility. MK. + case Input.infer_password("Password: ", opts) do + :eof -> {:error, :not_enough_args} + password -> :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :change_password, + [username, password, Helpers.cli_acting_user()] + ) + end + end + def run([username, password], %{node: node_name}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :change_password, + [username, password, Helpers.cli_acting_user()] + ) + end + + def output({:error, :not_enough_args}, _) do + {:error, ExitCodes.exit_software(), "Password is not provided via argument or stdin"} + end + def output({:error, {:no_such_user, username}}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => "User #{username} does not exists"}} + end + def output({:error, {:no_such_user, username}}, _) do + {:error, ExitCodes.exit_nouser(), "User \"#{username}\" does not exist"} + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "change_password <username> <password>" + + def usage_additional() do + [ + ["<username>", "Name of the user whose password should be changed"], + ["<password>", "New password to set"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :user_management + + def description(), do: "Changes the user password" + + def banner([user | _], _), do: "Changing password for user \"#{user}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_global_parameter_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_global_parameter_command.ex new file mode 100644 index 0000000000..c5cedeb96a --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_global_parameter_command.ex @@ -0,0 +1,48 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ClearGlobalParameterCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([key], %{node: node_name}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_runtime_parameters, + :clear_global, + [key, Helpers.cli_acting_user()] + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "clear_global_parameter <name>" + + def usage_additional() do + [ + ["<name>", "parameter name (identifier)"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.parameters() + ] + end + + def help_section(), do: :parameters + + def description(), do: "Clears a global runtime parameter" + + def banner([key], _) do + "Clearing global runtime parameter \"#{key}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_operator_policy_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_operator_policy_command.ex new file mode 100644 index 0000000000..4b77d4cb38 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_operator_policy_command.ex @@ -0,0 +1,49 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ClearOperatorPolicyCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([key], %{node: node_name, vhost: vhost}) do + :rabbit_misc.rpc_call(node_name, :rabbit_policy, :delete_op, [ + vhost, + key, + Helpers.cli_acting_user() + ]) + end + + def usage, do: "clear_operator_policy [--vhost <vhost>] <name>" + + def usage_additional() do + [ + ["<name>", "policy name (identifier)"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.parameters() + ] + end + + def help_section(), do: :policies + + def description(), do: "Clears an operator policy" + + def banner([key], %{vhost: vhost}) do + "Clearing operator policy \"#{key}\" on vhost \"#{vhost}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_parameter_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_parameter_command.ex new file mode 100644 index 0000000000..3997b1b61f --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_parameter_command.ex @@ -0,0 +1,60 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ClearParameterCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + def validate(args, _) when is_list(args) and length(args) < 2 do + {:validation_failure, :not_enough_args} + end + + def validate([_ | _] = args, _) when length(args) > 2 do + {:validation_failure, :too_many_args} + end + + def validate([_, _], _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([component_name, key], %{node: node_name, vhost: vhost}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_runtime_parameters, + :clear, + [vhost, component_name, key, Helpers.cli_acting_user()] + ) + end + + def usage, do: "clear_parameter [--vhost <vhost>] <component_name> <name>" + + def usage_additional() do + [ + ["<component_name>", "component name"], + ["<name>", "parameter name (identifier)"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.parameters() + ] + end + + def help_section(), do: :parameters + + def description(), do: "Clears a runtime parameter." + + def banner([component_name, key], %{vhost: vhost}) do + "Clearing runtime parameter \"#{key}\" for component \"#{component_name}\" on vhost \"#{vhost}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_password_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_password_command.ex new file mode 100644 index 0000000000..398af4813b --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_password_command.ex @@ -0,0 +1,46 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ClearPasswordCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([_user] = args, %{node: node_name}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :clear_password, + args ++ [Helpers.cli_acting_user()] + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "clear_password <username>" + + def usage_additional() do + [ + ["<username>", "Name of the user whose password should be cleared"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :user_management + + def description(), do: "Clears (resets) password and disables password login for a user" + + def banner([user], _), do: "Clearing password for user \"#{user}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_permissions_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_permissions_command.ex new file mode 100644 index 0000000000..2fd129fffa --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_permissions_command.ex @@ -0,0 +1,61 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ClearPermissionsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ExitCodes, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([username], %{node: node_name, vhost: vhost}) do + :rabbit_misc.rpc_call(node_name, :rabbit_auth_backend_internal, :clear_permissions, [ + username, + vhost, + Helpers.cli_acting_user() + ]) + end + + def output({:error, {:no_such_user, username}}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => "User #{username} does not exist"}} + end + def output({:error, {:no_such_vhost, vhost}}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => "Virtual host #{vhost} does not exist"}} + end + def output({:error, {:no_such_user, username}}, _) do + {:error, ExitCodes.exit_nouser(), "User #{username} does not exist"} + end + def output({:error, {:no_such_vhost, vhost}}, _) do + {:error, "Virtual host #{vhost} does not exist"} + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "clear_permissions [--vhost <vhost>] <username>" + + def usage_additional() do + [ + ["<username>", "Name of the user whose permissions should be revoked"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :access_control + def description(), do: "Revokes user permissions for a vhost" + + def banner([username], %{vhost: vhost}) do + "Clearing permissions for user \"#{username}\" in vhost \"#{vhost}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_policy_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_policy_command.ex new file mode 100644 index 0000000000..057c2e8c24 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_policy_command.ex @@ -0,0 +1,49 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ClearPolicyCommand do + alias RabbitMQ.CLI.Core.{Helpers, DocGuide} + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([key], %{node: node_name, vhost: vhost}) do + :rabbit_misc.rpc_call(node_name, :rabbit_policy, :delete, [ + vhost, + key, + Helpers.cli_acting_user() + ]) + end + + def usage, do: "clear_policy [--vhost <vhost>] <name>" + + def usage_additional() do + [ + ["<name>", "Name of policy to clear (remove)"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.parameters() + ] + end + + def help_section(), do: :policies + + def description(), do: "Clears (removes) a policy" + + def banner([key], %{vhost: vhost}) do + "Clearing policy \"#{key}\" on vhost \"#{vhost}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_topic_permissions_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_topic_permissions_command.ex new file mode 100644 index 0000000000..5d0b249db6 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_topic_permissions_command.ex @@ -0,0 +1,85 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ClearTopicPermissionsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ExitCodes, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + + def validate([_ | _] = args, _) when length(args) > 2 do + {:validation_failure, :too_many_args} + end + + def validate([_], _), do: :ok + def validate([_, _], _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([username], %{node: node_name, vhost: vhost}) do + :rabbit_misc.rpc_call(node_name, :rabbit_auth_backend_internal, :clear_topic_permissions, [ + username, + vhost, + Helpers.cli_acting_user() + ]) + end + + def run([username, exchange], %{node: node_name, vhost: vhost}) do + :rabbit_misc.rpc_call(node_name, :rabbit_auth_backend_internal, :clear_topic_permissions, [ + username, + vhost, + exchange, + Helpers.cli_acting_user() + ]) + end + + def output({:error, {:no_such_user, username}}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => "User #{username} does not exist"}} + end + def output({:error, {:no_such_vhost, vhost}}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => "Virtual host #{vhost} does not exist"}} + end + def output({:error, {:no_such_user, username}}, _) do + {:error, ExitCodes.exit_nouser(), "User #{username} does not exist"} + end + def output({:error, {:no_such_vhost, vhost}}, _) do + {:error, "Virtual host #{vhost} does not exist"} + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "clear_topic_permissions [--vhost <vhost>] <username> [<exchange>]" + + def usage_additional() do + [ + ["<username>", "Name of the user whose topic permissions should be revoked"], + ["<exchange>", "Exchange the permissions are for"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :access_control + def description(), do: "Clears user topic permissions for a vhost or exchange" + + def banner([username], %{vhost: vhost}) do + "Clearing topic permissions for user \"#{username}\" in vhost \"#{vhost}\" ..." + end + + def banner([username, exchange], %{vhost: vhost}) do + "Clearing topic permissions on \"#{exchange}\" for user \"#{username}\" in vhost \"#{vhost}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_user_limits_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_user_limits_command.ex new file mode 100644 index 0000000000..301de613bb --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_user_limits_command.ex @@ -0,0 +1,50 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ClearUserLimitsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsTwoPositionalArguments + + def run([username, limit_type], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit_auth_backend_internal, :clear_user_limits, [ + username, + limit_type, + Helpers.cli_acting_user() + ]) + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def usage, do: "clear_user_limits username <limit_type> | all" + + def usage_additional() do + [ + ["<limit_type>", "Limit type, must be max-connections or max-channels"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :user_management + + def description(), do: "Clears user connection/channel limits" + + def banner([username, "all"], %{}) do + "Clearing all limits for user \"#{username}\" ..." + end + def banner([username, limit_type], %{}) do + "Clearing \"#{limit_type}\" limit for user \"#{username}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_vhost_limits_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_vhost_limits_command.ex new file mode 100644 index 0000000000..a73f0ff670 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/clear_vhost_limits_command.ex @@ -0,0 +1,43 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ClearVhostLimitsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, vhost: vhost}) do + :rabbit_misc.rpc_call(node_name, :rabbit_vhost_limit, :clear, [ + vhost, + Helpers.cli_acting_user() + ]) + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def usage, do: "clear_vhost_limits [--vhost <vhost>]" + + def usage_doc_guides() do + [ + DocGuide.virtual_hosts() + ] + end + + def help_section(), do: :virtual_hosts + + def description(), do: "Clears virtual host limits" + + def banner([], %{vhost: vhost}) do + "Clearing vhost \"#{vhost}\" limits ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/close_all_connections_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/close_all_connections_command.ex new file mode 100644 index 0000000000..d4c5b5f17a --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/close_all_connections_command.ex @@ -0,0 +1,124 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.CloseAllConnectionsCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches(), do: [global: :boolean, per_connection_delay: :integer, limit: :integer] + + def merge_defaults(args, opts) do + {args, Map.merge(%{global: false, vhost: "/", per_connection_delay: 0, limit: 0}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([explanation], %{ + node: node_name, + vhost: vhost, + global: global_opt, + per_connection_delay: delay, + limit: limit + }) do + conns = + case global_opt do + false -> + per_vhost = + :rabbit_misc.rpc_call(node_name, :rabbit_connection_tracking, :list, [vhost]) + + apply_limit(per_vhost, limit) + + true -> + :rabbit_misc.rpc_call(node_name, :rabbit_connection_tracking, :list_on_node, [node_name]) + end + + case conns do + {:badrpc, _} = err -> + err + + _ -> + :rabbit_misc.rpc_call( + node_name, + # As of 3.7.15, this function was moved to the rabbit_connection_tracking module. + # rabbit_connection_tracking_handler still contains a delegating function with the same name. + # Continue using this one for now for maximum CLI/server version compatibility. MK. + :rabbit_connection_tracking_handler, + :close_connections, + [conns, explanation, delay] + ) + + {:ok, "Closed #{length(conns)} connections"} + end + end + + def run(args, %{ + node: node_name, + global: global_opt, + per_connection_delay: delay, + limit: limit + }) do + run(args, %{ + node: node_name, + vhost: nil, + global: global_opt, + per_connection_delay: delay, + limit: limit + }) + end + + def output({:stream, stream}, _opts) do + {:stream, Stream.filter(stream, fn x -> x != :ok end)} + end + use RabbitMQ.CLI.DefaultOutput + + def banner([explanation], %{node: node_name, global: true}) do + "Closing all connections to node #{node_name} (across all vhosts), reason: #{explanation}..." + end + + def banner([explanation], %{vhost: vhost, limit: 0}) do + "Closing all connections in vhost #{vhost}, reason: #{explanation}..." + end + + def banner([explanation], %{vhost: vhost, limit: limit}) do + "Closing #{limit} connections in vhost #{vhost}, reason: #{explanation}..." + end + + def usage do + "close_all_connections [--vhost <vhost> --limit <limit>] [-n <node> --global] [--per-connection-delay <delay>] <explanation>" + end + + def usage_additional do + [ + ["--global", "consider connections across all virtual hosts"], + ["--limit <number>", "close up to this many connections"], + ["--per-connection-delay <milliseconds>", "inject a delay between closures"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.connections() + ] + end + + def help_section(), do: :operations + + def description(), do: "Instructs the broker to close all connections for the specified vhost or entire RabbitMQ node" + + # + # Implementation + # + + defp apply_limit(conns, 0) do + conns + end + + defp apply_limit(conns, number) do + :lists.sublist(conns, number) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/close_connection_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/close_connection_command.ex new file mode 100644 index 0000000000..371c582b19 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/close_connection_command.ex @@ -0,0 +1,46 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.CloseConnectionCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsTwoPositionalArguments + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([pid, explanation], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit_networking, :close_connection, [ + :rabbit_misc.string_to_pid(pid), + explanation + ]) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "close_connection <connection pid> <explanation>" + + def usage_additional do + [ + ["<connection pid>", "connection identifier (Erlang PID), see list_connections"], + ["<explanation>", "reason for connection closure"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.connections() + ] + end + + def help_section(), do: :operations + + def description(), do: "Instructs the broker to close the connection associated with the Erlang process id" + + def banner([pid, explanation], _), do: "Closing connection #{pid}, reason: #{explanation}..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/cluster_status_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/cluster_status_command.ex new file mode 100644 index 0000000000..20f96e8075 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/cluster_status_command.ex @@ -0,0 +1,285 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ClusterStatusCommand do + alias RabbitMQ.CLI.Core.DocGuide + import RabbitMQ.CLI.Core.{Alarms, ANSI, Listeners, Platform, FeatureFlags} + import RabbitMQ.CLI.Core.Distribution, only: [per_node_timeout: 2] + import RabbitMQ.CLI.Core.DataCoercion + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @default_timeout 60_000 + + def scopes(), do: [:ctl, :diagnostics] + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults(args, opts) do + timeout = + case opts[:timeout] do + nil -> @default_timeout + :infinity -> @default_timeout + other -> other + end + + {args, Map.merge(%{timeout: timeout}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_mnesia, :status, []) do + {:badrpc, _} = err -> + err + + status -> + case :rabbit_misc.rpc_call(node_name, :rabbit_mnesia, :cluster_nodes, [:running]) do + {:badrpc, _} = err -> + err + + {:error, {:corrupt_or_missing_cluster_files, _, _}} -> + {:error, "Could not read mnesia files containing cluster status"} + + nodes -> + count = length(nodes) + alarms_by_node = Enum.map(nodes, fn n -> alarms_by_node(n, per_node_timeout(timeout, count)) end) + listeners_by_node = Enum.map(nodes, fn n -> listeners_of(n, per_node_timeout(timeout, count)) end) + versions_by_node = Enum.map(nodes, fn n -> versions_by_node(n, per_node_timeout(timeout, count)) end) + maintenance_status_by_node = Enum.map(nodes, + fn n -> maintenance_status_by_node(n, per_node_timeout(timeout, count)) end) + + feature_flags = case :rabbit_misc.rpc_call(node_name, :rabbit_ff_extra, :cli_info, [], timeout) do + {:badrpc, {:EXIT, {:undef, _}}} -> [] + {:badrpc, _} = err -> err + val -> val + end + + status ++ + [{:alarms, alarms_by_node}] ++ + [{:listeners, listeners_by_node}] ++ + [{:versions, versions_by_node}] ++ + [{:maintenance_status, maintenance_status_by_node}] ++ + [{:feature_flags, feature_flags}] + end + end + end + + def output({:error, :timeout}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), + "Error: timed out while waiting for a response from #{node_name}."} + end + + def output(result, %{formatter: "erlang"}) do + {:ok, result} + end + + def output(result, %{formatter: "json"}) when is_list(result) do + # format more data structures as map for sensible JSON output + m = result_map(result) + |> Map.update(:alarms, [], fn xs -> alarm_maps(xs) end) + |> Map.update(:listeners, %{}, fn m -> + Enum.map(m, fn {n, xs} -> {n, listener_maps(xs)} end) |> Enum.into(%{}) + end) + + {:ok, m} + end + + def output(result, %{node: node_name}) when is_list(result) do + m = result_map(result) + + cluster_name_section = [ + "#{bright("Basics")}\n", + "Cluster name: #{m[:cluster_name]}" + ] + + disk_nodes_section = [ + "\n#{bright("Disk Nodes")}\n", + ] ++ node_lines(m[:disk_nodes]) + + ram_nodes_section = case m[:ram_nodes] do + [] -> [] + xs -> [ + "\n#{bright("RAM Nodes")}\n", + ] ++ node_lines(xs) + end + + running_nodes_section = [ + "\n#{bright("Running Nodes")}\n", + ] ++ node_lines(m[:running_nodes]) + + versions_section = [ + "\n#{bright("Versions")}\n", + ] ++ version_lines(m[:versions]) + + alarms_section = [ + "\n#{bright("Alarms")}\n", + ] ++ case m[:alarms] do + [] -> ["(none)"] + xs -> alarm_lines(xs, node_name) + end + + partitions_section = [ + "\n#{bright("Network Partitions")}\n" + ] ++ case map_size(m[:partitions]) do + 0 -> ["(none)"] + _ -> partition_lines(m[:partitions]) + end + + listeners_section = [ + "\n#{bright("Listeners")}\n" + ] ++ case map_size(m[:listeners]) do + 0 -> ["(none)"] + _ -> Enum.reduce(m[:listeners], [], fn {node, listeners}, acc -> + acc ++ listener_lines(listeners, node) + end) + end + + maintenance_section = [ + "\n#{bright("Maintenance status")}\n", + ] ++ maintenance_lines(m[:maintenance_status]) + + feature_flags_section = [ + "\n#{bright("Feature flags")}\n" + ] ++ case Enum.count(m[:feature_flags]) do + 0 -> ["(none)"] + _ -> feature_flag_lines(m[:feature_flags]) + end + + lines = cluster_name_section ++ disk_nodes_section ++ ram_nodes_section ++ running_nodes_section ++ + versions_section ++ maintenance_section ++ alarms_section ++ partitions_section ++ + listeners_section ++ feature_flags_section + + {:ok, Enum.join(lines, line_separator())} + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.String + + def usage, do: "cluster_status" + + def usage_doc_guides() do + [ + DocGuide.clustering(), + DocGuide.cluster_formation(), + DocGuide.monitoring() + ] + end + + def help_section(), do: :cluster_management + + def description(), do: "Displays all the nodes in the cluster grouped by node type, together with the currently running nodes" + + def banner(_, %{node: node_name}), do: "Cluster status of node #{node_name} ..." + + # + # Implementation + # + + defp result_map(result) do + # [{nodes,[{disc,[hare@warp10,rabbit@warp10]},{ram,[flopsy@warp10]}]}, + # {running_nodes,[flopsy@warp10,hare@warp10,rabbit@warp10]}, + # {cluster_name,<<"rabbit@localhost">>}, + # {partitions,[{flopsy@warp10,[rabbit@vagrant]}, + # {hare@warp10,[rabbit@vagrant]}]}, + # {alarms,[{flopsy@warp10,[]}, + # {hare@warp10,[]}, + # {rabbit@warp10,[{resource_limit,memory,rabbit@warp10}]}]}] + %{ + cluster_name: Keyword.get(result, :cluster_name), + disk_nodes: result |> Keyword.get(:nodes, []) |> Keyword.get(:disc, []), + ram_nodes: result |> Keyword.get(:nodes, []) |> Keyword.get(:ram, []), + running_nodes: result |> Keyword.get(:running_nodes, []) |> Enum.map(&to_string/1), + alarms: Keyword.get(result, :alarms) |> Keyword.values |> Enum.concat |> Enum.uniq, + maintenance_status: Keyword.get(result, :maintenance_status, []) |> Enum.into(%{}), + partitions: Keyword.get(result, :partitions, []) |> Enum.into(%{}), + listeners: Keyword.get(result, :listeners, []) |> Enum.into(%{}), + versions: Keyword.get(result, :versions, []) |> Enum.into(%{}), + feature_flags: Keyword.get(result, :feature_flags, []) |> Enum.map(fn ff -> Enum.into(ff, %{}) end) + } + end + + defp alarms_by_node(node, timeout) do + alarms = case :rabbit_misc.rpc_call(to_atom(node), :rabbit, :alarms, [], timeout) do + {:badrpc, _} -> [] + xs -> xs + end + + {node, alarms} + end + + defp listeners_of(node, timeout) do + # This may seem inefficient since this call returns all known listeners + # in the cluster, so why do we run it on every node? See the badrpc clause, + # some nodes may be inavailable or partitioned from other nodes. This way we + # gather as complete a picture as possible. MK. + listeners = case :rabbit_misc.rpc_call(to_atom(node), :rabbit_networking, :active_listeners, [], timeout) do + {:badrpc, _} -> [] + xs -> xs + end + + {node, listeners_on(listeners, node)} + end + + defp versions_by_node(node, timeout) do + {rmq_name, rmq_vsn, otp_vsn} = case :rabbit_misc.rpc_call( + to_atom(node), :rabbit, :product_info, [], timeout) do + {:badrpc, _} -> + {nil, nil, nil} + map -> + %{:otp_release => otp} = map + name = case map do + %{:product_name => v} -> v + %{:product_base_name => v} -> v + end + vsn = case map do + %{:product_version => v} -> v + %{:product_base_version => v} -> v + end + {name, vsn, otp} + end + + {node, %{rabbitmq_name: to_string(rmq_name), rabbitmq_version: to_string(rmq_vsn), erlang_version: to_string(otp_vsn)}} + end + + defp maintenance_status_by_node(node, timeout) do + target = to_atom(node) + result = case :rabbit_misc.rpc_call(target, + :rabbit_maintenance, :status_local_read, [target], timeout) do + {:badrpc, _} -> "unknown" + :regular -> "not under maintenance" + :draining -> magenta("marked for maintenance") + # forward compatibility: should we figure out a way to know when + # draining completes (it involves inherently asynchronous cluster + # operations such as quorum queue leader re-election), we'd introduce + # a new state + :drained -> magenta("marked for maintenance") + value -> to_string(value) + end + + {node, result} + end + + defp node_lines(nodes) do + Enum.map(nodes, &to_string/1) |> Enum.sort + end + + defp version_lines(mapping) do + Enum.map(mapping, fn {node, %{rabbitmq_name: rmq_name, rabbitmq_version: rmq_vsn, erlang_version: otp_vsn}} -> + "#{node}: #{rmq_name} #{rmq_vsn} on Erlang #{otp_vsn}" + end) + end + + defp partition_lines(mapping) do + Enum.map(mapping, fn {node, unreachable_peers} -> "Node #{node} cannot communicate with #{Enum.join(unreachable_peers, ", ")}" end) + end + + defp maintenance_lines(mapping) do + Enum.map(mapping, fn {node, status} -> "Node: #{node}, status: #{status}" end) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/decode_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/decode_command.ex new file mode 100644 index 0000000000..015617b102 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/decode_command.ex @@ -0,0 +1,116 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +alias RabbitMQ.CLI.Core.Helpers + +defmodule RabbitMQ.CLI.Ctl.Commands.DecodeCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def switches() do + [ + cipher: :atom, + hash: :atom, + iterations: :integer + ] + end + + def distribution(_), do: :none + + def merge_defaults(args, opts) do + with_defaults = Map.merge(%{ + cipher: :rabbit_pbe.default_cipher(), + hash: :rabbit_pbe.default_hash(), + iterations: :rabbit_pbe.default_iterations() + }, opts) + {args, with_defaults} + end + + def validate(args, _) when length(args) < 2 do + {:validation_failure, {:not_enough_args, "Please provide a value to decode and a passphrase"}} + end + + def validate(args, _) when length(args) > 2 do + {:validation_failure, :too_many_args} + end + + def validate(args, opts) when length(args) === 2 do + case {supports_cipher(opts.cipher), supports_hash(opts.hash), opts.iterations > 0} do + {false, _, _} -> + {:validation_failure, {:bad_argument, "The requested cipher is not supported"}} + + {_, false, _} -> + {:validation_failure, {:bad_argument, "The requested hash is not supported"}} + + {_, _, false} -> + {:validation_failure, + {:bad_argument, + "The requested number of iterations is incorrect (must be a positive integer)"}} + + {true, true, true} -> + :ok + end + end + + def run([value, passphrase], %{cipher: cipher, hash: hash, iterations: iterations}) do + try do + term_value = Helpers.evaluate_input_as_term(value) + + term_to_decrypt = + case term_value do + {:encrypted, _} = encrypted -> + encrypted + _ -> + {:encrypted, term_value} + end + + result = :rabbit_pbe.decrypt_term(cipher, hash, iterations, passphrase, term_to_decrypt) + {:ok, result} + catch + _, _ -> + {:error, + "Failed to decrypt the value. Things to check: is the passphrase correct? Are the cipher and hash algorithms the same as those used for encryption?"} + end + end + + def formatter(), do: RabbitMQ.CLI.Formatters.Erlang + + def banner([_, _], _) do + "Decrypting value ..." + end + + def usage, do: "decode value passphrase [--cipher <cipher>] [--hash <hash>] [--iterations <iterations>]" + + def usage_additional() do + [ + ["<value>", "config value to decode"], + ["<passphrase>", "passphrase to use with the config value encryption key"], + ["--cipher <cipher>", "cipher suite to use"], + ["--hash <hash>", "hashing function to use"], + ["--iterations <iterations>", "number of iteration to apply"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.configuration() + ] + end + + def help_section(), do: :configuration + + def description(), do: "Decrypts an encrypted configuration value" + + # + # Implementation + # + + defp supports_cipher(cipher), do: Enum.member?(:rabbit_pbe.supported_ciphers(), cipher) + + defp supports_hash(hash), do: Enum.member?(:rabbit_pbe.supported_hashes(), hash) +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/delete_queue_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/delete_queue_command.ex new file mode 100644 index 0000000000..5e5fe9b9c0 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/delete_queue_command.ex @@ -0,0 +1,125 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.DeleteQueueCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches(), do: [if_empty: :boolean, if_unused: :boolean, timeout: :integer] + def aliases(), do: [e: :if_empty, u: :if_unused, t: :timeout] + + def merge_defaults(args, opts) do + { + args, + Map.merge(%{if_empty: false, if_unused: false, vhost: "/"}, opts) + } + end + + def validate([], _opts) do + {:validation_failure, :not_enough_args} + end + + def validate(args, _opts) when length(args) > 1 do + {:validation_failure, :too_many_args} + end + + def validate([""], _opts) do + { + :validation_failure, + {:bad_argument, "queue name cannot be an empty string"} + } + end + + def validate([_], _opts) do + :ok + end + + ## Validate rabbit application is running + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([qname], %{ + node: node, + vhost: vhost, + if_empty: if_empty, + if_unused: if_unused, + timeout: timeout + }) do + ## Generate queue resource name from queue name and vhost + queue_resource = :rabbit_misc.r(vhost, :queue, qname) + ## Lookup a queue on broker node using resource name + case :rabbit_misc.rpc_call(node, :rabbit_amqqueue, :lookup, [queue_resource]) do + {:ok, queue} -> + ## Delete queue + :rabbit_misc.rpc_call( + node, + :rabbit_amqqueue, + :delete, + [queue, if_unused, if_empty, "cli_user"], + timeout + ) + + {:error, _} = error -> + error + end + end + + def output({:error, :not_found}, _options) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_usage(), "Queue not found"} + end + + def output({:error, :not_empty}, _options) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_usage(), "Queue is not empty"} + end + + def output({:error, :in_use}, _options) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_usage(), "Queue is in use"} + end + + def output({:ok, qlen}, _options) do + {:ok, "Queue was successfully deleted with #{qlen} messages"} + end + + ## Use default output for all non-special case outputs + use RabbitMQ.CLI.DefaultOutput + + def banner([qname], %{vhost: vhost, if_empty: if_empty, if_unused: if_unused}) do + if_empty_str = + case if_empty do + true -> ["if queue is empty "] + false -> [] + end + + if_unused_str = + case if_unused do + true -> ["if queue is unused "] + false -> [] + end + + "Deleting queue '#{qname}' on vhost '#{vhost}' " <> + Enum.join(Enum.concat([if_empty_str, if_unused_str]), "and ") <> "..." + end + + def usage(), do: "delete_queue <queue_name> [--if-empty|-e] [--if-unused|-u]" + + def usage_additional() do + [ + ["<queue_name>", "name of the queue to delete"], + ["--if-empty", "delete the queue if it is empty (has no messages ready for delivery)"], + ["--if-unused", "delete the queue only if it has no consumers"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.queues() + ] + end + + def help_section(), do: :queues + + def description(), do: "Deletes a queue" +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/delete_user_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/delete_user_command.ex new file mode 100644 index 0000000000..84f00a96f4 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/delete_user_command.ex @@ -0,0 +1,52 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.DeleteUserCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ExitCodes, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([username], %{node: node_name}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :delete_user, + [username, Helpers.cli_acting_user()] + ) + end + + def output({:error, {:no_such_user, username}}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => "User #{username} does not exists"}} + end + def output({:error, {:no_such_user, username}}, _) do + {:error, ExitCodes.exit_nouser(), "User \"#{username}\" does not exist"} + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "delete_user <username>" + + def usage_additional() do + [ + ["<username>", "Name of the user to delete."] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :user_management + + def description(), do: "Removes a user from the internal database. Has no effect on users provided by external backends such as LDAP" + + def banner([arg], _), do: "Deleting user \"#{arg}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/delete_vhost_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/delete_vhost_command.ex new file mode 100644 index 0000000000..8ff6e1f047 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/delete_vhost_command.ex @@ -0,0 +1,41 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.DeleteVhostCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([arg], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit_vhost, :delete, [arg, Helpers.cli_acting_user()]) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "delete_vhost <vhost>" + + def usage_additional() do + [ + ["<vhost>", "Name of the virtual host to delete."] + ] + end + + def usage_doc_guides() do + [ + DocGuide.virtual_hosts() + ] + end + + def help_section(), do: :virtual_hosts + + def description(), do: "Deletes a virtual host" + + def banner([arg], _), do: "Deleting vhost \"#{arg}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/enable_feature_flag_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/enable_feature_flag_command.ex new file mode 100644 index 0000000000..6af5a79e49 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/enable_feature_flag_command.ex @@ -0,0 +1,60 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2018-2020 VMware, Inc. or its affiliates. All rights reserved. + + +defmodule RabbitMQ.CLI.Ctl.Commands.EnableFeatureFlagCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts), do: {args, opts} + + def validate([], _), do: {:validation_failure, :not_enough_args} + def validate([_|_] = args, _) when length(args) > 1, do: {:validation_failure, :too_many_args} + def validate([""], _), do: {:validation_failure, {:bad_argument, "feature_flag cannot be an empty string."}} + def validate([_], _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run(["all"], %{node: node_name}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_feature_flags, :enable_all, []) do + # Server does not support feature flags, consider none are available. + # See rabbitmq/rabbitmq-cli#344 for context. MK. + {:badrpc, {:EXIT, {:undef, _}}} -> {:error, :unsupported} + {:badrpc, _} = err -> err + other -> other + end + end + + def run([feature_flag], %{node: node_name}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_feature_flags, :enable, [String.to_atom(feature_flag)]) do + # Server does not support feature flags, consider none are available. + # See rabbitmq/rabbitmq-cli#344 for context. MK. + {:badrpc, {:EXIT, {:undef, _}}} -> {:error, :unsupported} + {:badrpc, _} = err -> err + other -> other + end + end + + def output({:error, :unsupported}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_usage, "This feature flag is not supported by node #{node_name}"} + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "enable_feature_flag <all | feature_flag>" + + def usage_additional() do + [ + ["<feature_flag>", "name of the feature flag to enable, or \"all\" to enable all supported flags"] + ] +end + + def help_section(), do: :feature_flags + + def description(), do: "Enables a feature flag or all supported feature flags on the target node" + + def banner(["all"], _), do: "Enabling all feature flags ..." + + def banner([feature_flag], _), do: "Enabling feature flag \"#{feature_flag}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/encode_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/encode_command.ex new file mode 100644 index 0000000000..c625b4a5f5 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/encode_command.ex @@ -0,0 +1,102 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.EncodeCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def switches() do + [ + cipher: :atom, + hash: :atom, + iterations: :integer + ] + end + + def distribution(_), do: :none + + def merge_defaults(args, opts) do + with_defaults = Map.merge(%{ + cipher: :rabbit_pbe.default_cipher(), + hash: :rabbit_pbe.default_hash(), + iterations: :rabbit_pbe.default_iterations() + }, opts) + {args, with_defaults} + end + + def validate(args, _) when length(args) < 2 do + {:validation_failure, {:not_enough_args, "Please provide a value to decode and a passphrase."}} + end + + def validate(args, _) when length(args) > 2 do + {:validation_failure, :too_many_args} + end + + def validate(args, opts) when length(args) === 2 do + case {supports_cipher(opts.cipher), supports_hash(opts.hash), opts.iterations > 0} do + {false, _, _} -> + {:validation_failure, {:bad_argument, "The requested cipher is not supported."}} + + {_, false, _} -> + {:validation_failure, {:bad_argument, "The requested hash is not supported"}} + + {_, _, false} -> + {:validation_failure, {:bad_argument, "The requested number of iterations is incorrect"}} + + {true, true, true} -> + :ok + end + end + + def run([value, passphrase], %{cipher: cipher, hash: hash, iterations: iterations}) do + try do + term_value = Helpers.evaluate_input_as_term(value) + result = {:encrypted, _} = :rabbit_pbe.encrypt_term(cipher, hash, iterations, passphrase, term_value) + {:ok, result} + catch + _, _ -> + {:error, "Error during cipher operation."} + end + end + + def formatter(), do: RabbitMQ.CLI.Formatters.Erlang + + def banner([_, _], _) do + "Encrypting value ..." + end + + def usage, do: "encode value passphrase [--cipher <cipher>] [--hash <hash>] [--iterations <iterations>]" + + def usage_additional() do + [ + ["<value>", "config value to encode"], + ["<passphrase>", "passphrase to use with the config value encryption key"], + ["--cipher <cipher>", "cipher suite to use"], + ["--hash <hash>", "hashing function to use"], + ["--iterations <iterations>", "number of iteration to apply"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.configuration() + ] + end + + def help_section(), do: :configuration + + def description(), do: "Encrypts a sensitive configuration value" + + # + # Implementation + # + + defp supports_cipher(cipher), do: Enum.member?(:rabbit_pbe.supported_ciphers(), cipher) + + defp supports_hash(hash), do: Enum.member?(:rabbit_pbe.supported_hashes(), hash) +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/environment_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/environment_command.ex new file mode 100644 index 0000000000..ac807512a9 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/environment_command.ex @@ -0,0 +1,38 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.EnvironmentCommand do + alias RabbitMQ.CLI.Core.DocGuide + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit, :environment, []) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Erlang + + def usage, do: "environment" + + def usage_doc_guides() do + [ + DocGuide.configuration(), + DocGuide.monitoring() + ] + end + + def help_section(), do: :configuration + + def description(), do: "Displays the name and value of each variable in the application environment for each running application" + + def banner(_, %{node: node_name}), do: "Application environment of node #{node_name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/eval_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/eval_command.ex new file mode 100644 index 0000000000..35fe0a8803 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/eval_command.ex @@ -0,0 +1,107 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.EvalCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ErlEval, ExitCodes, Input} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate([], _) do + # value will be provided via standard input + :ok + end + + def validate(["" | _], _) do + {:validation_failure, "Expression must not be blank"} + end + + def validate([expr | _], _) do + case ErlEval.parse_expr(expr) do + {:ok, _} -> :ok + {:error, err} -> {:validation_failure, err} + end + end + + def run([], %{node: node_name} = opts) do + case Input.consume_multiline_string() do + :eof -> {:error, :not_enough_args} + expr -> + case ErlEval.parse_expr(expr) do + {:ok, parsed} -> + bindings = make_bindings([], opts) + + case :rabbit_misc.rpc_call(node_name, :erl_eval, :exprs, [parsed, bindings]) do + {:value, value, _} -> {:ok, value} + err -> err + end + + {:error, msg} -> {:error, msg} + end + end + end + def run([expr | arguments], %{node: node_name} = opts) do + case ErlEval.parse_expr(expr) do + {:ok, parsed} -> + bindings = make_bindings(arguments, opts) + + case :rabbit_misc.rpc_call(node_name, :erl_eval, :exprs, [parsed, bindings]) do + {:value, value, _} -> {:ok, value} + err -> err + end + + {:error, msg} -> {:error, msg} + end + end + + def output({:error, :not_enough_args}, _) do + {:error, ExitCodes.exit_dataerr(), "Expression to evaluate is not provided via argument or stdin"} + end + def output({:error, msg}, _) do + {:error, ExitCodes.exit_dataerr(), "Evaluation failed: #{msg}"} + end + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Erlang + + def usage, do: "eval <expression>" + + def usage_additional() do + [ + ["<expression>", "Expression to evaluate"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.cli(), + DocGuide.monitoring(), + DocGuide.troubleshooting() + ] + end + + def help_section(), do: :operations + + def description(), do: "Evaluates a snippet of Erlang code on the target node" + + def banner(_, _), do: nil + + # + # Implementation + # + + defp make_bindings(args, opts) do + Enum.with_index(args, 1) + |> Enum.map(fn {val, index} -> {String.to_atom("_#{index}"), val} end) + |> Enum.concat(option_bindings(opts)) + end + + defp option_bindings(opts) do + Enum.to_list(opts) + |> Enum.map(fn {key, val} -> {String.to_atom("_#{key}"), val} end) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/eval_file_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/eval_file_command.ex new file mode 100644 index 0000000000..6f46abbf17 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/eval_file_command.ex @@ -0,0 +1,75 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.EvalFileCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ErlEval, ExitCodes} + alias RabbitMQ.CLI.Ctl.Commands.EvalCommand + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + + def validate(["" | _], _) do + {:validation_failure, "File path must not be blank"} + end + + def validate([file_path], _) do + case File.read(file_path) do + {:ok, expr} -> + case ErlEval.parse_expr(expr) do + {:ok, _} -> :ok + {:error, err} -> {:validation_failure, err} + end + {:error, :enoent} -> + {:validation_failure, "File #{file_path} does not exist"} + {:error, :eacces} -> + {:validation_failure, "Insufficient permissions to read file #{file_path}"} + {:error, err} -> + {:validation_failure, err} + end + end + + def run([file_path], opts) do + case File.read(file_path) do + {:ok, expr} -> EvalCommand.run([expr], opts) + {:error, err} -> {:error, err} + end + + end + + def output({:error, msg}, _) do + {:error, ExitCodes.exit_dataerr(), "Evaluation failed: #{msg}"} + end + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Erlang + + def usage, do: "eval_file <file path>" + + def usage_additional() do + [ + ["<file path>", "Path to the file to evaluate"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.cli(), + DocGuide.monitoring(), + DocGuide.troubleshooting() + ] + end + + def help_section(), do: :operations + + def description(), do: "Evaluates a file that contains a snippet of Erlang code on the target node" + + def banner(_, _), do: nil +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/exec_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/exec_command.ex new file mode 100644 index 0000000000..469047c1af --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/exec_command.ex @@ -0,0 +1,80 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ExecCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def switches(), do: [offline: :boolean] + + def distribution(%{offline: true}), do: :none + def distribution(%{}), do: :cli + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + + def validate(args, _) when length(args) > 1 do + {:validation_failure, :too_many_args} + end + + def validate([""], _) do + {:validation_failure, "Expression must not be blank"} + end + + def validate([string], _) do + try do + Code.compile_string(string) + :ok + rescue + ex in SyntaxError -> + {:validation_failure, "SyntaxError: " <> Exception.message(ex)} + + _ -> + :ok + end + end + + def run([expr], %{} = opts) do + try do + {val, _} = Code.eval_string(expr, [options: opts], __ENV__) + {:ok, val} + rescue + ex -> + {:error, Exception.message(ex)} + end + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Inspect + + def banner(_, _), do: nil + + def usage, do: "exec <expression> [--offline]" + + def usage_additional() do + [ + ["<expression>", "Expression to evaluate"], + ["--offline", "disable inter-node communication"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.cli(), + DocGuide.monitoring(), + DocGuide.troubleshooting() + ] + end + + def help_section(), do: :operations + + def description(), do: "Evaluates a snippet of Elixir code on the CLI node" +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/export_definitions_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/export_definitions_command.ex new file mode 100644 index 0000000000..e4b026f160 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/export_definitions_command.ex @@ -0,0 +1,143 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ExportDefinitionsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ExitCodes, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(["-"] = args, opts) do + {args, Map.merge(%{format: "json", silent: true}, Helpers.case_insensitive_format(opts))} + end + def merge_defaults(args, opts) do + {args, Map.merge(%{format: "json"}, Helpers.case_insensitive_format(opts))} + end + + def switches(), do: [timeout: :integer, format: :string] + def aliases(), do: [t: :timeout] + + def validate(_, %{format: format}) + when format != "json" and format != "JSON" and format != "erlang" do + {:validation_failure, {:bad_argument, "Format should be either json or erlang"}} + end + def validate([], _) do + {:validation_failure, :not_enough_args} + end + def validate(args, _) when length(args) > 1 do + {:validation_failure, :too_many_args} + end + # output to stdout + def validate(["-"], _) do + :ok + end + def validate([path], _) do + dir = Path.dirname(path) + case File.exists?(dir, [raw: true]) do + true -> :ok + false -> {:validation_failure, {:bad_argument, "Directory #{dir} does not exist"}} + end + end + def validate(_, _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run(["-"], %{node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_definitions, :all_definitions, [], timeout) do + {:error, _} = err -> err + {:error, _, _} = err -> err + result -> {:ok, result} + end + end + def run([path], %{node: node_name, timeout: timeout, format: format}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_definitions, :all_definitions, [], timeout) do + {:badrpc, _} = err -> err + {:error, _} = err -> err + {:error, _, _} = err -> err + result -> + # write to the file in run/2 because output/2 is not meant to + # produce side effects + body = serialise(result, format) + abs_path = Path.absname(path) + + File.rm(abs_path) + case File.write(abs_path, body) do + # no output + :ok -> {:ok, nil} + {:error, :enoent} -> + {:error, ExitCodes.exit_dataerr(), "Parent directory or file #{path} does not exist"} + {:error, :enotdir} -> + {:error, ExitCodes.exit_dataerr(), "Parent directory of file #{path} is not a directory"} + {:error, :enospc} -> + {:error, ExitCodes.exit_dataerr(), "No space left on device hosting #{path}"} + {:error, :eacces} -> + {:error, ExitCodes.exit_dataerr(), "No permissions to write to file #{path} or its parent directory"} + {:error, :eisdir} -> + {:error, ExitCodes.exit_dataerr(), "Path #{path} is a directory"} + {:error, err} -> + {:error, ExitCodes.exit_dataerr(), "Could not write to file #{path}: #{err}"} + end + end + end + + def output({:ok, nil}, _) do + {:ok, nil} + end + def output({:ok, result}, %{format: "json"}) when is_map(result) do + {:ok, serialise(result, "json")} + end + def output({:ok, result}, %{format: "erlang"}) when is_map(result) do + {:ok, serialise(result, "erlang")} + end + use RabbitMQ.CLI.DefaultOutput + + def printer(), do: RabbitMQ.CLI.Printers.StdIORaw + + def usage, do: "export_definitions <file_path | \"-\"> [--format <json | erlang>]" + + def usage_additional() do + [ + ["<file>", "Local file path to export to. Pass a dash (-) for stdout."], + ["--format", "output format to use: json or erlang"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.definitions() + ] + end + + def help_section(), do: :definitions + + def description(), do: "Exports definitions in JSON or compressed Erlang Term Format." + + def banner([path], %{format: fmt}), do: "Exporting definitions in #{human_friendly_format(fmt)} to a file at \"#{path}\" ..." + + # + # Implementation + # + + defp serialise(raw_map, "json") do + # make sure all runtime parameter values are maps, otherwise + # they will end up being a list of pairs (a keyword list/proplist) + # in the resulting JSON document + map = Map.update!(raw_map, :parameters, fn(params) -> + Enum.map(params, fn(param) -> + Map.update!(param, "value", &:rabbit_data_coercion.to_map/1) + end) + end) + {:ok, json} = JSON.encode(map) + json + end + + defp serialise(map, "erlang") do + :erlang.term_to_binary(map, [{:compressed, 9}]) + end + + defp human_friendly_format("JSON"), do: "JSON" + defp human_friendly_format("json"), do: "JSON" + defp human_friendly_format("erlang"), do: "Erlang term format" +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/force_boot_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/force_boot_command.ex new file mode 100644 index 0000000000..261f86c6c1 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/force_boot_command.ex @@ -0,0 +1,57 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ForceBootCommand do + alias RabbitMQ.CLI.Core.{Config, DocGuide} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + ## + def validate_execution_environment(args, opts) do + ## We don't use RequiresRabbitAppStopped helper because we don't want to fail + ## the validation if the node is not running. + case RabbitMQ.CLI.Core.Validators.rabbit_is_not_running(args, opts) do + :ok -> :ok + {:validation_failure, _} = failure -> failure + _other -> RabbitMQ.CLI.Core.Validators.node_is_not_running(args, opts) + end + end + + def run([], %{node: node_name} = opts) do + case :rabbit_misc.rpc_call(node_name, :rabbit_mnesia, :force_load_next_boot, []) do + {:badrpc, :nodedown} -> + case Config.get_option(:mnesia_dir, opts) do + nil -> + {:error, :mnesia_dir_not_found} + + dir -> + File.write(Path.join(dir, "force_load"), "") + end + + _ -> + :ok + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "force_boot" + + def usage_doc_guides() do + [ + DocGuide.clustering() + ] + end + + def help_section(), do: :cluster_management + + def description(), do: "Forces node to start even if it cannot contact or rejoin any of its previously known peers" + + def banner(_, _), do: nil +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/force_gc_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/force_gc_command.ex new file mode 100644 index 0000000000..975154be50 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/force_gc_command.ex @@ -0,0 +1,35 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ForceGcCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit_runtime, :gc_all_processes, [], timeout) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "force_gc" + + def usage_doc_guides() do + [ + DocGuide.memory_use() + ] + end + + def help_section(), do: :operations + + def description, do: "Makes all Erlang processes on the target node perform/schedule a full sweep garbage collection" + + def banner([], %{node: node_name}), do: "Will ask all processes on node #{node_name} to schedule a full sweep GC" +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/force_reset_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/force_reset_command.ex new file mode 100644 index 0000000000..5f202f9d08 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/force_reset_command.ex @@ -0,0 +1,40 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ForceResetCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ExitCodes} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppStopped + + def run([], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit_mnesia, :force_reset, []) + end + + def output({:error, :mnesia_unexpectedly_running}, %{node: node_name}) do + {:error, ExitCodes.exit_software(), + RabbitMQ.CLI.DefaultOutput.mnesia_running_error(node_name)} + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "force_reset" + + def usage_doc_guides() do + [ + DocGuide.clustering() + ] + end + + def help_section(), do: :cluster_management + + def description(), do: "Forcefully returns a RabbitMQ node to its virgin state" + + def banner(_, %{node: node_name}), do: "Forcefully resetting node #{node_name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/forget_cluster_node_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/forget_cluster_node_command.ex new file mode 100644 index 0000000000..cdf5ae7fbe --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/forget_cluster_node_command.ex @@ -0,0 +1,122 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ForgetClusterNodeCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Distribution, Validators} + import RabbitMQ.CLI.Core.DataCoercion + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches(), do: [offline: :boolean] + + def merge_defaults(args, opts) do + {args, Map.merge(%{offline: false}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + + def validate_execution_environment([_node_to_remove] = args, %{offline: true} = opts) do + Validators.chain( + [ + &Validators.node_is_not_running/2, + &Validators.mnesia_dir_is_set/2, + &Validators.feature_flags_file_is_set/2, + &Validators.rabbit_is_loaded/2 + ], + [args, opts] + ) + end + + def validate_execution_environment([_], %{offline: false}) do + :ok + end + + def run([node_to_remove], %{node: node_name, offline: true} = opts) do + Stream.concat([ + become(node_name, opts), + RabbitMQ.CLI.Core.Helpers.defer(fn -> + :rabbit_event.start_link() + :rabbit_mnesia.forget_cluster_node(to_atom(node_to_remove), true) + end) + ]) + end + + def run([node_to_remove], %{node: node_name, offline: false}) do + atom_name = to_atom(node_to_remove) + args = [atom_name, false] + case :rabbit_misc.rpc_call(node_name, :rabbit_mnesia, :forget_cluster_node, args) do + {:error, {:failed_to_remove_node, ^atom_name, {:active, _, _}}} -> + {:error, "RabbitMQ on node #{node_to_remove} must be stopped with 'rabbitmqctl -n #{node_to_remove} stop_app' before it can be removed"}; + {:error, _} = error -> error; + {:badrpc, _} = error -> error; + :ok -> + case :rabbit_misc.rpc_call(node_name, :rabbit_quorum_queue, :shrink_all, [atom_name]) do + {:error, _} -> + {:error, "RabbitMQ failed to shrink some of the quorum queues on node #{node_to_remove}"}; + _ -> :ok + end + other -> other + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage() do + "forget_cluster_node [--offline] <existing_cluster_member_node>" + end + + def usage_additional() do + [ + ["--offline", "try to update cluster membership state directly. Use when target node is stopped. Only works for local nodes."] + ] + end + + def usage_doc_guides() do + [ + DocGuide.clustering(), + DocGuide.cluster_formation() + ] + end + + def help_section(), do: :cluster_management + + def description(), do: "Removes a node from the cluster" + + def banner([node_to_remove], %{offline: true}) do + "Removing node #{node_to_remove} from the cluster. Warning: quorum queues cannot be shrunk in offline mode" + end + def banner([node_to_remove], _) do + "Removing node #{node_to_remove} from the cluster" + end + + # + # Implementation + # + + defp become(node_name, opts) do + :error_logger.tty(false) + + case :net_adm.ping(node_name) do + :pong -> + exit({:node_running, node_name}) + + :pang -> + :ok = :net_kernel.stop() + + Stream.concat([ + [" * Impersonating node: #{node_name}..."], + RabbitMQ.CLI.Core.Helpers.defer(fn -> + {:ok, _} = Distribution.start_as(node_name, opts) + " done" + end), + RabbitMQ.CLI.Core.Helpers.defer(fn -> + dir = :mnesia.system_info(:directory) + " * Mnesia directory: #{dir}..." + end) + ]) + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/help_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/help_command.ex new file mode 100644 index 0000000000..8f459cc83f --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/help_command.ex @@ -0,0 +1,343 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +alias RabbitMQ.CLI.CommandBehaviour + +defmodule RabbitMQ.CLI.Ctl.Commands.HelpCommand do + alias RabbitMQ.CLI.Core.{CommandModules, Config, ExitCodes} + alias RabbitMQ.CLI.Core.CommandModules + + import RabbitMQ.CLI.Core.ANSI + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics, :plugins, :queues, :upgrade] + def switches(), do: [list_commands: :boolean] + + def distribution(_), do: :none + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate([], _), do: :ok + def validate([_command], _), do: :ok + def validate(args, _) when length(args) > 1 do + {:validation_failure, :too_many_args} + end + + def run([command_name | _], opts) do + CommandModules.load(opts) + + module_map = CommandModules.module_map() + case module_map[command_name] do + nil -> + # command not found + # {:error, all_usage(opts)} + case RabbitMQ.CLI.AutoComplete.suggest_command(command_name, module_map) do + {:suggest, suggested} -> + suggest_message = "\nCommand '#{command_name}' not found. \n" <> + "Did you mean '#{suggested}'? \n" + {:error, ExitCodes.exit_usage(), suggest_message} + nil -> + {:error, ExitCodes.exit_usage(), "\nCommand '#{command_name}' not found."} + end + + command -> + {:ok, command_usage(command, opts)} + end + end + + def run([], opts) do + CommandModules.load(opts) + + case opts[:list_commands] do + true -> + {:ok, commands_description()} + _ -> + {:ok, all_usage(opts)} + end + end + + def output({:ok, result}, _) do + {:ok, result} + end + def output({:error, result}, _) do + {:error, ExitCodes.exit_usage(), result} + end + use RabbitMQ.CLI.DefaultOutput + + def banner(_, _), do: nil + + def help_section(), do: :help + + def description(), do: "Displays usage information for a command" + + def usage(), do: "help (<command> | [--list-commands])" + + def usage_additional() do + [ + ["--list-commands", "only output a list of discovered commands"] + ] + end + + + # + # Implementation + # + + def all_usage(opts) do + tool_name = program_name(opts) + tool_usage(tool_name) ++ + ["\n\nAvailable commands:\n"] ++ commands_description() ++ + help_footer(tool_name) + end + + def command_usage(command, opts) do + Enum.join([base_usage(command, opts)] ++ + command_description(command) ++ + additional_usage(command) ++ + relevant_doc_guides(command) ++ + general_options_usage(), + "\n\n") <> "\n" + end + + defp tool_usage(tool_name) do + [ + "\n#{bright("Usage")}\n\n" <> + "#{tool_name} [--node <node>] [--timeout <timeout>] [--longnames] [--quiet] <command> [<command options>]" + ] + end + + def base_usage(command, opts) do + tool_name = program_name(opts) + + maybe_timeout = + case command_supports_timeout(command) do + true -> " [--timeout <timeout>]" + false -> "" + end + + Enum.join([ + "\n#{bright("Usage")}\n\n", + "#{tool_name} [--node <node>] [--longnames] [--quiet] " <> + flatten_string(command.usage(), maybe_timeout) + ]) + end + + defp flatten_string(list, additional) when is_list(list) do + list + |> Enum.map(fn line -> line <> additional end) + |> Enum.join("\n") + end + + defp flatten_string(str, additional) when is_binary(str) do + str <> additional + end + + defp general_options_usage() do + [ + "#{bright("General Options")} + +The following options are accepted by most or all commands. + +short | long | description +-----------------|---------------|-------------------------------- +-? | --help | displays command help +-n <node> | --node <node> | connect to node <node> +-l | --longnames | use long host names +-t | --timeout <n> | for commands that support it, operation timeout in seconds +-q | --quiet | suppress informational messages +-s | --silent | suppress informational messages + | and table header row +-p | --vhost | for commands that are scoped to a virtual host, + | | virtual host to use + | --formatter | alternative result formatter to use + | if supported: json, pretty_table, table, csv, erlang + not all commands support all (or any) alternative formatters."] + end + + defp command_description(command) do + case CommandBehaviour.description(command) do + "" -> [] + other -> [other <> ".\n"] + end + end + + defp list_item_formatter([option, description]) do + "#{option}\n\t#{description}\n" + end + defp list_item_formatter({option, description}) do + "#{option}\n\t#{description}\n" + end + defp list_item_formatter(line) do + "#{line}\n" + end + + defp additional_usage(command) do + command_usage = + case CommandBehaviour.usage_additional(command) do + list when is_list(list) -> list |> Enum.map(&list_item_formatter/1) + bin when is_binary(bin) -> ["#{bin}\n"] + end + case command_usage do + [] -> [] + usage -> + [flatten_string(["#{bright("Arguments and Options")}\n" | usage], "")] + end + end + + defp relevant_doc_guides(command) do + guide_list = + case CommandBehaviour.usage_doc_guides(command) do + list when is_list(list) -> list |> Enum.map(fn ln -> " * #{ln}\n" end) + bin when is_binary(bin) -> [" * #{bin}\n"] + end + case guide_list do + [] -> [] + usage -> + [flatten_string(["#{bright("Relevant Doc Guides")}\n" | usage], "")] + end + end + + defp help_footer(tool_name) do + ["Use '#{tool_name} help <command>' to learn more about a specific command"] + end + + defp command_supports_timeout(command) do + nil != CommandBehaviour.switches(command)[:timeout] + end + + defp commands_description() do + module_map = CommandModules.module_map() + + pad_commands_to = Enum.reduce(module_map, 0, + fn({name, _}, longest) -> + name_length = String.length(name) + case name_length > longest do + true -> name_length + false -> longest + end + end) + + lines = module_map + |> Enum.map( + fn({name, cmd}) -> + description = CommandBehaviour.description(cmd) + help_section = CommandBehaviour.help_section(cmd) + {name, {description, help_section}} + end) + |> Enum.group_by(fn({_, {_, help_section}}) -> help_section end) + |> Enum.sort_by( + fn({help_section, _}) -> + case help_section do + :deprecated -> 999 + :other -> 100 + {:plugin, _} -> 99 + :help -> 1 + :node_management -> 2 + :cluster_management -> 3 + :replication -> 3 + :user_management -> 4 + :access_control -> 5 + :observability_and_health_checks -> 6 + :parameters -> 7 + :policies -> 8 + :virtual_hosts -> 9 + _ -> 98 + end + end) + |> Enum.map( + fn({help_section, section_helps}) -> + [ + "\n" <> bright(section_head(help_section)) <> ":\n\n" | + Enum.sort(section_helps) + |> Enum.map( + fn({name, {description, _}}) -> + " #{String.pad_trailing(name, pad_commands_to)} #{description}\n" + end) + ] + + end) + |> Enum.concat() + + lines ++ ["\n"] + end + + defp section_head(help_section) do + case help_section do + :help -> + "Help" + :user_management -> + "Users" + :cluster_management -> + "Cluster" + :replication -> + "Replication" + :node_management -> + "Nodes" + :queues -> + "Queues" + :observability_and_health_checks -> + "Monitoring, observability and health checks" + :virtual_hosts -> + "Virtual hosts" + :access_control -> + "Access Control" + :parameters -> + "Parameters" + :policies -> + "Policies" + :configuration -> + "Configuration and Environment" + :feature_flags -> + "Feature flags" + :other -> + "Other" + {:plugin, plugin} -> + plugin_section(plugin) <> " plugin" + custom -> + snake_case_to_capitalized_string(custom) + end + end + + defp strip_rabbitmq_prefix(value, regex) do + Regex.replace(regex, value, "") + end + + defp format_known_plugin_name_fragments(value) do + case value do + ["amqp1.0"] -> "AMQP 1.0" + ["amqp1", "0"] -> "AMQP 1.0" + ["management"] -> "Management" + ["management", "agent"] -> "Management" + ["mqtt"] -> "MQTT" + ["stomp"] -> "STOMP" + ["web", "mqtt"] -> "Web MQTT" + ["web", "stomp"] -> "Web STOMP" + [other] -> snake_case_to_capitalized_string(other) + fragments -> snake_case_to_capitalized_string(Enum.join(fragments, "_")) + end + end + + defp plugin_section(plugin) do + regex = Regex.recompile!(~r/^rabbitmq_/) + + to_string(plugin) + # drop rabbitmq_ + |> strip_rabbitmq_prefix(regex) + |> String.split("_") + |> format_known_plugin_name_fragments() + end + + defp snake_case_to_capitalized_string(value) do + to_string(value) + |> String.split("_") + |> Enum.map(&String.capitalize/1) + |> Enum.join(" ") + end + + defp program_name(opts) do + Config.get_option(:script_name, opts) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/hipe_compile_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/hipe_compile_command.ex new file mode 100644 index 0000000000..13f3468cb6 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/hipe_compile_command.ex @@ -0,0 +1,98 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.HipeCompileCommand do + @moduledoc """ + HiPE support has been deprecated since Erlang/OTP 22 (mid-2019) and + won't be a part of Erlang/OTP 24. + + Therefore this command is DEPRECATED and is no-op. + """ + + alias RabbitMQ.CLI.Core.{DocGuide, Validators} + import RabbitMQ.CLI.Core.CodePath + + @behaviour RabbitMQ.CLI.CommandBehaviour + + # + # API + # + + def distribution(_), do: :none + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate([], _), do: {:validation_failure, :not_enough_args} + + def validate([target_dir], opts) do + :ok + |> Validators.validate_step(fn -> + case acceptable_path?(target_dir) do + true -> :ok + false -> {:error, {:bad_argument, "Target directory path cannot be blank"}} + end + end) + |> Validators.validate_step(fn -> + case File.dir?(target_dir) do + true -> + :ok + + false -> + case File.mkdir_p(target_dir) do + :ok -> + :ok + + {:error, perm} when perm == :eperm or perm == :eacces -> + {:error, + {:bad_argument, + "Cannot create target directory #{target_dir}: insufficient permissions"}} + end + end + end) + |> Validators.validate_step(fn -> require_rabbit(opts) end) + end + + def validate(_, _), do: {:validation_failure, :too_many_args} + + def run([_target_dir], _opts) do + :ok + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "hipe_compile <directory>" + + def usage_additional do + [ + ["<directory>", "Target directory for HiPE-compiled modules"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.configuration(), + DocGuide.erlang_versions() + ] + end + + def help_section(), do: :deprecated + + def description() do + "DEPRECATED. This command is a no-op. HiPE is no longer supported by modern Erlang versions" + end + + def banner([_target_dir], _) do + "This command is a no-op. HiPE is no longer supported by modern Erlang versions" + end + + # + # Implementation + # + + # Accepts any non-blank path + defp acceptable_path?(value) do + String.length(String.trim(value)) != 0 + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/import_definitions_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/import_definitions_command.ex new file mode 100644 index 0000000000..45ca0074f3 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/import_definitions_command.ex @@ -0,0 +1,136 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ImportDefinitionsCommand do + alias RabbitMQ.CLI.Core.{Config, DocGuide, ExitCodes, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(["-"] = args, opts) do + {args, Map.merge(%{format: "json", silent: true}, Helpers.case_insensitive_format(opts))} + end + def merge_defaults(args, opts) do + {args, Map.merge(%{format: "json"}, Helpers.case_insensitive_format(opts))} + end + + def switches(), do: [timeout: :integer, format: :string] + def aliases(), do: [t: :timeout] + + def validate(_, %{format: format}) + when format != "json" and format != "JSON" and format != "erlang" do + {:validation_failure, {:bad_argument, "Format should be either json or erlang"}} + end + def validate(args, _) when length(args) > 1 do + {:validation_failure, :too_many_args} + end + def validate([path], _) do + case File.exists?(path, [raw: true]) do + true -> :ok + false -> {:validation_failure, {:bad_argument, "File #{path} does not exist"}} + end + end + def validate(_, _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, format: format, timeout: timeout}) do + case IO.read(:stdio, :all) do + :eof -> {:error, :not_enough_args} + bin -> + case deserialise(bin, format) do + {:error, error} -> + {:error, ExitCodes.exit_dataerr(), "Failed to deserialise input (format: #{human_friendly_format(format)}) (error: #{inspect(error)})"} + {:ok, map} -> + :rabbit_misc.rpc_call(node_name, :rabbit_definitions, :import_parsed, [map], timeout) + end + end + end + def run([path], %{node: node_name, timeout: timeout, format: format}) do + abs_path = Path.absname(path) + + case File.read(abs_path) do + {:ok, ""} -> + {:error, ExitCodes.exit_dataerr(), "File #{path} is zero-sized"} + {:ok, bin} -> + case deserialise(bin, format) do + {:error, error} -> + {:error, ExitCodes.exit_dataerr(), "Failed to deserialise input (format: #{human_friendly_format(format)}) (error: #{inspect(error)})"} + {:ok, map} -> + :rabbit_misc.rpc_call(node_name, :rabbit_definitions, :import_parsed, [map], timeout) + end + {:error, :enoent} -> + {:error, ExitCodes.exit_dataerr(), "Parent directory or file #{path} does not exist"} + {:error, :enotdir} -> + {:error, ExitCodes.exit_dataerr(), "Parent directory of file #{path} is not a directory"} + {:error, :eacces} -> + {:error, ExitCodes.exit_dataerr(), "No permissions to read from file #{path} or its parent directory"} + {:error, :eisdir} -> + {:error, ExitCodes.exit_dataerr(), "Path #{path} is a directory"} + {:error, err} -> + {:error, ExitCodes.exit_dataerr(), "Could not read from file #{path}: #{err}"} + end + end + + def output(:ok, %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => "ok", "node" => node_name}} + end + def output(:ok, opts) do + case Config.output_less?(opts) do + true -> :ok + false -> {:ok, "Successfully started definition import. " <> + "This process is asynchronous and can take some time.\n"} + end + end + use RabbitMQ.CLI.DefaultOutput + + def printer(), do: RabbitMQ.CLI.Printers.StdIORaw + + def usage, do: "import_definitions <file_path | \"-\"> [--format <json | erlang>]" + + def usage_additional() do + [ + ["[file]", "Local file path to import from. If omitted will be read from standard input."], + ["--format", "input format to use: json or erlang"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.definitions() + ] + end + + def help_section(), do: :definitions + + def description(), do: "Imports definitions in JSON or compressed Erlang Term Format." + + def banner([], %{format: fmt}) do + "Importing definitions in #{human_friendly_format(fmt)} from standard input ..." + end + def banner([path], %{format: fmt}) do + "Importing definitions in #{human_friendly_format(fmt)} from a file at \"#{path}\" ..." + end + + # + # Implementation + # + + defp deserialise(bin, "json") do + JSON.decode(bin) + end + + defp deserialise(bin, "erlang") do + try do + {:ok, :erlang.binary_to_term(bin)} + rescue e in ArgumentError -> + {:error, e.message} + end + end + + defp human_friendly_format("JSON"), do: "JSON" + defp human_friendly_format("json"), do: "JSON" + defp human_friendly_format("erlang"), do: "Erlang term format" +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/join_cluster_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/join_cluster_command.ex new file mode 100644 index 0000000000..765fbd43f1 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/join_cluster_command.ex @@ -0,0 +1,95 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.JoinClusterCommand do + alias RabbitMQ.CLI.Core.{Config, DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches() do + [ + disc: :boolean, + ram: :boolean + ] + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{disc: false, ram: false}, opts)} + end + + def validate(_, %{disc: true, ram: true}) do + {:validation_failure, {:bad_argument, "The node type must be either disc or ram."}} + end + + def validate([], _), do: {:validation_failure, :not_enough_args} + def validate([_], _), do: :ok + def validate(_, _), do: {:validation_failure, :too_many_args} + + use RabbitMQ.CLI.Core.RequiresRabbitAppStopped + + def run([target_node], %{node: node_name, ram: ram, disc: disc} = opts) do + node_type = + case {ram, disc} do + {true, false} -> :ram + {false, true} -> :disc + ## disc is default + {false, false} -> :disc + end + + long_or_short_names = Config.get_option(:longnames, opts) + target_node_normalised = Helpers.normalise_node(target_node, long_or_short_names) + + :rabbit_misc.rpc_call( + node_name, + :rabbit_mnesia, + :join_cluster, + [target_node_normalised, node_type] + ) + end + + def output({:ok, :already_member}, _) do + {:ok, "The node is already a member of this cluster"} + end + + def output({:error, :mnesia_unexpectedly_running}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), + RabbitMQ.CLI.DefaultOutput.mnesia_running_error(node_name)} + end + + def output({:error, :cannot_cluster_node_with_itself}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), + "Error: cannot cluster node with itself: #{node_name}"} + end + + use RabbitMQ.CLI.DefaultOutput + + def banner([target_node], %{node: node_name}) do + "Clustering node #{node_name} with #{target_node}" + end + + def usage() do + "join_cluster [--disc|--ram] <existing_cluster_member>" + end + + def usage_additional() do + [ + ["<existing_cluster_member>", "Existing cluster member (node) to join"], + ["--disc", "new node should be a disk one (stores its schema on disk). Highly recommended, used by default."], + ["--ram", "new node should be a RAM one (stores schema in RAM). Not recommended. Consult clustering doc guides first."] + ] + end + + def usage_doc_guides() do + [ + DocGuide.clustering(), + DocGuide.cluster_formation() + ] + end + + def help_section(), do: :cluster_management + + def description(), do: "Instructs the node to become a member of the cluster that the specified node is in" +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_bindings_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_bindings_command.ex new file mode 100644 index 0000000000..19e8844089 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_bindings_command.ex @@ -0,0 +1,74 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListBindingsCommand do + alias RabbitMQ.CLI.Ctl.{InfoKeys, RpcStream} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @info_keys ~w(source_name source_kind destination_name destination_kind routing_key arguments)a + + def info_keys(), do: @info_keys + + def scopes(), do: [:ctl, :diagnostics] + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults([], opts) do + merge_defaults( + ~w(source_name source_kind + destination_name destination_kind + routing_key arguments), + opts + ) + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/", table_headers: true}, opts)} + end + + def validate(args, _) do + case InfoKeys.validate_info_keys(args, @info_keys) do + {:ok, _} -> :ok + err -> err + end + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([_ | _] = args, %{node: node_name, timeout: timeout, vhost: vhost}) do + info_keys = InfoKeys.prepare_info_keys(args) + + RpcStream.receive_list_items( + node_name, + :rabbit_binding, + :info_all, + [vhost, info_keys], + timeout, + info_keys + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage() do + "list_bindings [--vhost <vhost>] [--no-table-headers] [<column> ...]" + end + + def usage_additional() do + [ + ["<column>", "must be one of " <> Enum.join(Enum.sort(@info_keys), ", ")] + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Lists all bindings on a vhost" + + def banner(_, %{vhost: vhost}), do: "Listing bindings for vhost #{vhost}..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_channels_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_channels_command.ex new file mode 100644 index 0000000000..5ae7450da1 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_channels_command.ex @@ -0,0 +1,85 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. +## + +defmodule RabbitMQ.CLI.Ctl.Commands.ListChannelsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + alias RabbitMQ.CLI.Ctl.{InfoKeys, RpcStream} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + + @info_keys ~w(pid connection name number user vhost transactional + confirm consumer_count messages_unacknowledged + messages_uncommitted acks_uncommitted messages_unconfirmed + prefetch_count global_prefetch_count)a + + def info_keys(), do: @info_keys + + def merge_defaults([], opts) do + merge_defaults(~w(pid user consumer_count messages_unacknowledged), opts) + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{table_headers: true}, opts)} + end + + def validate(args, _) do + case InfoKeys.validate_info_keys(args, @info_keys) do + {:ok, _} -> :ok + err -> err + end + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], opts) do + run(~w(pid user consumer_count messages_unacknowledged), opts) + end + + def run([_ | _] = args, %{node: node_name, timeout: timeout}) do + info_keys = InfoKeys.prepare_info_keys(args) + + Helpers.with_nodes_in_cluster(node_name, fn nodes -> + RpcStream.receive_list_items( + node_name, + :rabbit_channel, + :emit_info_all, + [nodes, info_keys], + timeout, + info_keys, + Kernel.length(nodes) + ) + end) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def banner(_, _), do: "Listing channels ..." + + def usage() do + "list_channels [--no-table-headers] [<column> ...]" + end + + def usage_additional() do + [ + ["<column>", "must be one of " <> Enum.join(Enum.sort(@info_keys), ", ")] + ] + end + + def usage_doc_guides() do + [ + DocGuide.channels() + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Lists all channels in the node" +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_ciphers_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_ciphers_command.ex new file mode 100644 index 0000000000..eb7075d261 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_ciphers_command.ex @@ -0,0 +1,40 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListCiphersCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def scopes(), do: [:ctl, :diagnostics] + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def distribution(_), do: :none + + def run(_, _) do + {:ok, :rabbit_pbe.supported_ciphers()} + end + + def formatter(), do: RabbitMQ.CLI.Formatters.Erlang + + def usage, do: "list_ciphers" + + def usage_doc_guides() do + [ + DocGuide.configuration(), + DocGuide.tls() + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Lists cipher suites supported by encoding commands" + + def banner(_, _), do: "Listing supported ciphers ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_connections_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_connections_command.ex new file mode 100644 index 0000000000..0e28272ea8 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_connections_command.ex @@ -0,0 +1,84 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListConnectionsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + alias RabbitMQ.CLI.Ctl.{InfoKeys, RpcStream} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + @info_keys ~w(pid name port host peer_port peer_host ssl ssl_protocol + ssl_key_exchange ssl_cipher ssl_hash peer_cert_subject + peer_cert_issuer peer_cert_validity state + channels protocol auth_mechanism user vhost timeout frame_max + channel_max client_properties recv_oct recv_cnt send_oct + send_cnt send_pend connected_at)a + + def info_keys(), do: @info_keys + + def merge_defaults([], opts) do + merge_defaults(~w(user peer_host peer_port state), opts) + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{table_headers: true}, opts)} + end + + def validate(args, _) do + case InfoKeys.validate_info_keys(args, @info_keys) do + {:ok, _} -> :ok + err -> err + end + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([_ | _] = args, %{node: node_name, timeout: timeout}) do + info_keys = InfoKeys.prepare_info_keys(args) + + Helpers.with_nodes_in_cluster(node_name, fn nodes -> + RpcStream.receive_list_items( + node_name, + :rabbit_networking, + :emit_connection_info_all, + [nodes, info_keys], + timeout, + info_keys, + Kernel.length(nodes) + ) + end) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage() do + "list_connections [--no-table-headers] [<column> ...]" + end + + def usage_additional() do + [ + ["<column>", "must be one of " <> Enum.join(Enum.sort(@info_keys), ", ")] + ] + end + + def usage_doc_guides() do + [ + DocGuide.connections() + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Lists AMQP 0.9.1 connections for the node" + + def banner(_, _), do: "Listing connections ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_consumers_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_consumers_command.ex new file mode 100644 index 0000000000..90c587cbe8 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_consumers_command.ex @@ -0,0 +1,108 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListConsumersCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + alias RabbitMQ.CLI.Ctl.{InfoKeys, RpcStream} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + @info_keys ~w(queue_name channel_pid consumer_tag + ack_required prefetch_count active activity_status arguments)a + + def info_keys(), do: @info_keys + + def merge_defaults([], opts) do + {Enum.map(@info_keys -- [:activity_status], &Atom.to_string/1), + Map.merge(%{vhost: "/", table_headers: true}, opts)} + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/", table_headers: true}, opts)} + end + + def validate(args, _) do + case InfoKeys.validate_info_keys(args, @info_keys) do + {:ok, _} -> :ok + err -> err + end + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([_ | _] = args, %{node: node_name, timeout: timeout, vhost: vhost}) do + info_keys = InfoKeys.prepare_info_keys(args) + + Helpers.with_nodes_in_cluster(node_name, fn nodes -> + RpcStream.receive_list_items_with_fun( + node_name, + [{:rabbit_amqqueue, + :emit_consumers_all, + [nodes, vhost]}], + timeout, + info_keys, + Kernel.length(nodes), + fn item -> fill_consumer_active_fields(item) end + ) + end) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage() do + "list_consumers [--vhost <vhost>] [--no-table-headers] [<column> ...]" + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Lists all consumers for a vhost" + + def usage_additional() do + [ + ["<column>", "must be one of " <> Enum.join(Enum.sort(@info_keys), ", ")] + ] + end + + def usage_doc_guides() do + [ + DocGuide.consumers() + ] + end + + def banner(_, %{vhost: vhost}), do: "Listing consumers in vhost #{vhost} ..." + + # + # Implementation + # + + # add missing fields if response comes from node < 3.8 + def fill_consumer_active_fields({[], {chunk, :continue}}) do + {[], {chunk, :continue}} + end + + def fill_consumer_active_fields({items, {chunk, :continue}}) do + {Enum.map(items, fn item -> + case Keyword.has_key?(item, :active) do + true -> + item + false -> + Keyword.drop(item, [:arguments]) + ++ [active: true, activity_status: :up] + ++ [arguments: Keyword.get(item, :arguments, [])] + end + end), {chunk, :continue}} + end + + def fill_consumer_active_fields(v) do + v + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_exchanges_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_exchanges_command.ex new file mode 100644 index 0000000000..a3b8b3521b --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_exchanges_command.ex @@ -0,0 +1,67 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListExchangesCommand do + alias RabbitMQ.CLI.Ctl.{InfoKeys, RpcStream} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @info_keys ~w(name type durable auto_delete internal arguments policy)a + + def info_keys(), do: @info_keys + + def scopes(), do: [:ctl, :diagnostics] + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults([], opts) do + merge_defaults(~w(name type), opts) + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/", table_headers: true}, opts)} + end + + def validate(args, _) do + case InfoKeys.validate_info_keys(args, @info_keys) do + {:ok, _} -> :ok + err -> err + end + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([_ | _] = args, %{node: node_name, timeout: timeout, vhost: vhost}) do + info_keys = InfoKeys.prepare_info_keys(args) + + RpcStream.receive_list_items( + node_name, + :rabbit_exchange, + :info_all, + [vhost, info_keys], + timeout, + info_keys + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage(), do: "list_exchanges [--vhost <vhost>] [--no-table-headers] [<column> ...]" + + def usage_additional() do + [ + ["<column>", "must be one of " <> Enum.join(Enum.sort(@info_keys), ", ")] + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Lists exchanges" + + def banner(_, %{vhost: vhost}), do: "Listing exchanges for vhost #{vhost} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_feature_flags_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_feature_flags_command.ex new file mode 100644 index 0000000000..46b4bc82c2 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_feature_flags_command.ex @@ -0,0 +1,94 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2018-2020 VMware, Inc. or its affiliates. All rights reserved. + + +defmodule RabbitMQ.CLI.Ctl.Commands.ListFeatureFlagsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Validators} + alias RabbitMQ.CLI.Ctl.InfoKeys + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + @info_keys ~w(name state stability provided_by desc doc_url)a + + def info_keys(), do: @info_keys + + def scopes(), do: [:ctl, :diagnostics] + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults([], opts), do: {["name", "state"], opts} + def merge_defaults(args, opts), do: {args, opts} + + def validate(args, _) do + case InfoKeys.validate_info_keys(args, @info_keys) do + {:ok, _} -> :ok + err -> err + end + end + + def validate_execution_environment(args, opts) do + Validators.chain( + [ + &Validators.rabbit_is_loaded/2, + &Validators.rabbit_is_running/2 + ], + [args, opts] + ) + end + + def run([_|_] = args, %{node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_ff_extra, :cli_info, [], timeout) do + # Server does not support feature flags, consider none are available. + # See rabbitmq/rabbitmq-cli#344 for context. MK. + {:badrpc, {:EXIT, {:undef, _}}} -> [] + {:badrpc, _} = err -> err + val -> filter_by_arg(val, args) + end + + end + + def banner(_, _), do: "Listing feature flags ..." + + def usage, do: "list_feature_flags [<column> ...]" + + def usage_additional() do + [ + ["<column>", "must be one of " <> Enum.join(Enum.sort(@info_keys), ", ")] + ] + end + + def usage_doc_guides() do + [ + DocGuide.feature_flags() + ] + end + + def help_section(), do: :feature_flags + + def description(), do: "Lists feature flags" + + # + # Implementation + # + + defp filter_by_arg(ff_info, _) when is_tuple(ff_info) do + # tuple means unexpected data + ff_info + end + + defp filter_by_arg(ff_info, [_|_] = args) when is_list(ff_info) do + symbol_args = InfoKeys.prepare_info_keys(args) + Enum.map(ff_info, + fn(ff) -> + symbol_args + |> Enum.filter(fn(arg) -> ff[arg] != nil end) + |> Enum.map(fn(arg) -> {arg, ff[arg]} end) + end + ) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_global_parameters_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_global_parameters_command.ex new file mode 100644 index 0000000000..8d3f2d795a --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_global_parameters_command.ex @@ -0,0 +1,48 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListGlobalParametersCommand do + alias RabbitMQ.CLI.Core.DocGuide + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, Map.merge(%{table_headers: true}, opts)} + end + + def scopes(), do: [:ctl, :diagnostics] + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_runtime_parameters, + :list_global_formatted, + [], + timeout + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage, do: "list_global_parameters [--no-table-headers]" + + def usage_doc_guides() do + [ + DocGuide.parameters() + ] + end + + def help_section(), do: :parameters + + def description(), do: "Lists global runtime parameters" + + def banner(_, _), do: "Listing global runtime parameters ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_hashes_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_hashes_command.ex new file mode 100644 index 0000000000..9e0f25e6dd --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_hashes_command.ex @@ -0,0 +1,40 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListHashesCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def scopes(), do: [:ctl, :diagnostics] + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def distribution(_), do: :none + + def run(_, _) do + {:ok, :rabbit_pbe.supported_hashes()} + end + + def formatter(), do: RabbitMQ.CLI.Formatters.Erlang + + def usage, do: "list_hashes" + + def usage_doc_guides() do + [ + DocGuide.configuration(), + DocGuide.tls() + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Lists hash functions supported by encoding commands" + + def banner(_, _), do: "Listing supported hash algorithms ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_operator_policies_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_operator_policies_command.ex new file mode 100644 index 0000000000..dd2c54dfc0 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_operator_policies_command.ex @@ -0,0 +1,49 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListOperatorPoliciesCommand do + alias RabbitMQ.CLI.Core.DocGuide + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/", table_headers: true}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout, vhost: vhost}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_policy, + :list_formatted_op, + [vhost], + timeout + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage, do: "list_operator_policies [--vhost <vhost>] [--no-table-headers]" + + def usage_doc_guides() do + [ + DocGuide.parameters() + ] + end + + def help_section(), do: :policies + + def description(), do: "Lists operator policy overrides for a virtual host" + + def banner(_, %{vhost: vhost}), + do: "Listing operator policy overrides for vhost \"#{vhost}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_parameters_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_parameters_command.ex new file mode 100644 index 0000000000..2d51f08527 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_parameters_command.ex @@ -0,0 +1,49 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListParametersCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/", table_headers: true}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout, vhost: vhost}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_runtime_parameters, + :list_formatted, + [vhost], + timeout + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage, do: "list_parameters [--vhost <vhost>] [--no-table-headers]" + + def usage_doc_guides() do + [ + DocGuide.parameters() + ] + end + + def help_section(), do: :parameters + + def description(), do: "Lists runtime parameters for a virtual host" + + def banner(_, %{vhost: vhost}), do: "Listing runtime parameters for vhost \"#{vhost}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_permissions_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_permissions_command.ex new file mode 100644 index 0000000000..feaf917cfa --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_permissions_command.ex @@ -0,0 +1,49 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListPermissionsCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/", table_headers: true}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout, vhost: vhost}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :list_vhost_permissions, + [vhost], + timeout + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage, do: "list_permissions [--vhost <vhost>] [--no-table-headers]" + + def usage_doc_guides() do + [ + DocGuide.access_control(), + DocGuide.virtual_hosts() + ] + end + + def help_section(), do: :access_control + def description(), do: "Lists user permissions in a virtual host" + + def banner(_, %{vhost: vhost}), do: "Listing permissions for vhost \"#{vhost}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_policies_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_policies_command.ex new file mode 100644 index 0000000000..9fe8e37dc1 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_policies_command.ex @@ -0,0 +1,49 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListPoliciesCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/", table_headers: true}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout, vhost: vhost}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_policy, + :list_formatted, + [vhost], + timeout + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage, do: "list_policies [--vhost <vhost>] [--no-table-headers]" + + def usage_doc_guides() do + [ + DocGuide.parameters() + ] + end + + def help_section(), do: :policies + + def description(), do: "Lists all policies in a virtual host" + + def banner(_, %{vhost: vhost}), do: "Listing policies for vhost \"#{vhost}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_queues_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_queues_command.ex new file mode 100644 index 0000000000..21f9fa78ec --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_queues_command.ex @@ -0,0 +1,143 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListQueuesCommand do + require RabbitMQ.CLI.Ctl.InfoKeys + require RabbitMQ.CLI.Ctl.RpcStream + + alias RabbitMQ.CLI.Ctl.{InfoKeys, RpcStream} + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @default_timeout 60_000 + @info_keys ~w(name durable auto_delete + arguments policy pid owner_pid exclusive exclusive_consumer_pid + exclusive_consumer_tag messages_ready messages_unacknowledged messages + messages_ready_ram messages_unacknowledged_ram messages_ram + messages_persistent message_bytes message_bytes_ready + message_bytes_unacknowledged message_bytes_ram message_bytes_persistent + head_message_timestamp disk_reads disk_writes consumers + consumer_utilisation memory slave_pids synchronised_slave_pids state type + leader members online)a + + def description(), do: "Lists queues and their properties" + def usage(), do: "list_queues [--vhost <vhost>] [--online] [--offline] [--local] [--no-table-headers] [<column>, ...]" + def scopes(), do: [:ctl, :diagnostics] + def switches(), do: [offline: :boolean, + online: :boolean, + local: :boolean, + timeout: :integer] + def aliases(), do: [t: :timeout] + + def info_keys(), do: @info_keys + + defp default_opts() do + %{vhost: "/", offline: false, online: false, local: false, table_headers: true} + end + + def merge_defaults([_ | _] = args, opts) do + timeout = + case opts[:timeout] do + nil -> @default_timeout + :infinity -> @default_timeout + other -> other + end + + {args, + Map.merge( + default_opts(), + Map.merge(opts, %{timeout: timeout}) + )} + end + + def merge_defaults([], opts) do + merge_defaults(~w(name messages), opts) + end + + def validate(args, _opts) do + case InfoKeys.validate_info_keys(args, @info_keys) do + {:ok, _} -> :ok + err -> err + end + end + + # note that --offline for this command has a different meaning: + # it lists queues with unavailable masters + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([_ | _] = args, %{ + node: node_name, + timeout: timeout, + vhost: vhost, + online: online_opt, + offline: offline_opt, + local: local_opt + }) do + {online, offline} = + case {online_opt, offline_opt} do + {false, false} -> {true, true} + other -> other + end + + info_keys = InfoKeys.prepare_info_keys(args) + + Helpers.with_nodes_in_cluster(node_name, fn nodes -> + offline_mfa = {:rabbit_amqqueue, :emit_info_down, [vhost, info_keys]} + local_mfa = {:rabbit_amqqueue, :emit_info_local, [vhost, info_keys]} + online_mfa = {:rabbit_amqqueue, :emit_info_all, [nodes, vhost, info_keys]} + + {chunks, mfas} = + case {local_opt, offline, online} do + # Local takes precedence + {true, _, _} -> {1, [local_mfa]} + {_, true, true} -> {Kernel.length(nodes) + 1, [offline_mfa, online_mfa]} + {_, false, true} -> {Kernel.length(nodes), [online_mfa]} + {_, true, false} -> {1, [offline_mfa]} + end + + RpcStream.receive_list_items_with_fun(node_name, mfas, timeout, info_keys, chunks, fn + {{:error, {:badrpc, {:timeout, to}}}, :finished} -> + {{:error, + {:badrpc, + {:timeout, to, + "Some queue(s) are unresponsive, use list_unresponsive_queues command."}}}, + :finished} + + any -> + any + end) + end) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def help_section(), do: :observability_and_health_checks + + def usage_additional do + [ + ["<column>", "must be one of " <> Enum.join(Enum.sort(@info_keys), ", ")], + ["--online", "lists only queues on online (reachable) nodes"], + ["--offline", "lists only queues on offline (unreachable) nodes"], + ["--local", "only return queues hosted on the target node"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.queues() + ] + end + + def banner(_, %{vhost: vhost, timeout: timeout}) do + [ + "Timeout: #{timeout / 1000} seconds ...", + "Listing queues for vhost #{vhost} ..." + ] + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_topic_permissions_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_topic_permissions_command.ex new file mode 100644 index 0000000000..1a22b3b26d --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_topic_permissions_command.ex @@ -0,0 +1,48 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListTopicPermissionsCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/", table_headers: true}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout, vhost: vhost}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :list_vhost_topic_permissions, + [vhost], + timeout + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage, do: "list_topic_permissions [--vhost <vhost>] [--no-table-headers]" + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :access_control + def description(), do: "Lists topic permissions in a virtual host" + + def banner(_, %{vhost: vhost}), do: "Listing topic permissions for vhost \"#{vhost}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_unresponsive_queues_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_unresponsive_queues_command.ex new file mode 100644 index 0000000000..91d6d624f5 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_unresponsive_queues_command.ex @@ -0,0 +1,95 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListUnresponsiveQueuesCommand do + require RabbitMQ.CLI.Ctl.InfoKeys + require RabbitMQ.CLI.Ctl.RpcStream + + alias RabbitMQ.CLI.Ctl.{InfoKeys, RpcStream} + alias RabbitMQ.CLI.Core.Helpers + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @info_keys ~w(name durable auto_delete + arguments pid recoverable_slaves)a + + def info_keys(), do: @info_keys + + def scopes(), do: [:ctl, :diagnostics] + + def switches() do + [queue_timeout: :integer, local: :boolean, timeout: :integer] + end + + def aliases(), do: [t: :timeout] + + defp default_opts() do + %{vhost: "/", local: false, queue_timeout: 15, table_headers: true} + end + + def merge_defaults([_ | _] = args, opts) do + {args, Map.merge(default_opts(), opts)} + end + + def merge_defaults([], opts) do + merge_defaults(~w(name), opts) + end + + def validate(args, _opts) do + case InfoKeys.validate_info_keys(args, @info_keys) do + {:ok, _} -> :ok + err -> err + end + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run(args, %{ + node: node_name, + vhost: vhost, + timeout: timeout, + queue_timeout: qtimeout, + local: local_opt + }) do + info_keys = InfoKeys.prepare_info_keys(args) + queue_timeout = qtimeout * 1000 + + Helpers.with_nodes_in_cluster(node_name, fn nodes -> + local_mfa = {:rabbit_amqqueue, :emit_unresponsive_local, [vhost, info_keys, queue_timeout]} + all_mfa = {:rabbit_amqqueue, :emit_unresponsive, [nodes, vhost, info_keys, queue_timeout]} + + {chunks, mfas} = + case local_opt do + true -> {1, [local_mfa]} + false -> {Kernel.length(nodes), [all_mfa]} + end + + RpcStream.receive_list_items(node_name, mfas, timeout, info_keys, chunks) + end) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def banner(_, %{vhost: vhost}), do: "Listing unresponsive queues for vhost #{vhost} ..." + + def usage() do + "list_unresponsive_queues [--local] [--queue-timeout <milliseconds>] [<column> ...] [--no-table-headers]" + end + + def usage_additional() do + [ + ["<column>", "must be one of " <> Enum.join(Enum.sort(@info_keys), ", ")], + ["--local", "only return queues hosted on the target node"], + ["--queue-timeout <milliseconds>", "per-queue timeout to use when checking for responsiveness"] + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Tests queues to respond within timeout. Lists those which did not respond" +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_user_limits_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_user_limits_command.ex new file mode 100644 index 0000000000..5e0de38b3f --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_user_limits_command.ex @@ -0,0 +1,91 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListUserLimitsCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + def switches(), do: [global: :boolean, user: :string] + + def merge_defaults(args, %{global: true} = opts) do + {args, Map.merge(%{table_headers: true}, opts)} + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{user: "guest", table_headers: true}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, global: true}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_auth_backend_internal, :get_user_limits, []) do + [] -> + [] + + {:error, err} -> + {:error, err} + + {:badrpc, node} -> + {:badrpc, node} + + val -> + Enum.map(val, fn {user, val} -> + {:ok, val_encoded} = JSON.encode(Map.new(val)) + [user: user, limits: val_encoded] + end) + end + end + + def run([], %{node: node_name, user: username}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_auth_backend_internal, :get_user_limits, [username]) do + :undefined -> + {:error, {:no_such_user, username}} + + {:error, err} -> + {:error, err} + + {:badrpc, node} -> + {:badrpc, node} + + val when is_list(val) or is_map(val) -> + {:ok, val_encoded} = JSON.encode(Map.new(val)) + val_encoded + end + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage, do: "list_user_limits [--user <username>] [--global]" + + def usage_additional() do + [ + ["--global", "list limits for all the users"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :user_management + + def description(), do: "Displays configured user limits" + + def banner([], %{global: true}) do + "Listing limits for all users ..." + end + + def banner([], %{user: username}) do + "Listing limits for user \"#{username}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_user_permissions_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_user_permissions_command.ex new file mode 100644 index 0000000000..bd302eefd0 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_user_permissions_command.ex @@ -0,0 +1,58 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListUserPermissionsCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def scopes(), do: [:ctl, :diagnostics] + def switches(), do: [timeout: :integer] + def aliases(), do: [t: :timeout] + + def merge_defaults(args, opts) do + {args, Map.merge(%{table_headers: true}, opts)} + end + + def validate([], _), do: {:validation_failure, :not_enough_args} + def validate([_ | _] = args, _) when length(args) > 1, do: {:validation_failure, :too_many_args} + def validate([_], _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([username], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :list_user_permissions, + [username], + timeout + ) + end + + def usage, do: "list_user_permissions [--no-table-headers] <username>" + + def usage_additional do + [ + ["<username>", "Name of the user"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control(), + DocGuide.virtual_hosts() + ] + end + + def help_section(), do: :access_control + def description(), do: "Lists permissions of a user across all virtual hosts" + + def banner([username], _), do: "Listing permissions for user \"#{username}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_user_topic_permissions_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_user_topic_permissions_command.ex new file mode 100644 index 0000000000..48b7fee5e2 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_user_topic_permissions_command.ex @@ -0,0 +1,54 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListUserTopicPermissionsCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults(args, opts) do + {args, Map.merge(%{table_headers: false}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([username], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :list_user_topic_permissions, + [username], + timeout + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage, do: "list_user_topic_permissions [--no-table-headers] <username>" + + def usage_additional do + [ + ["<username>", "Name of the user"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :access_control + def description(), do: "Lists user topic permissions" + + def banner([username], _), do: "Listing topic permissions for user \"#{username}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_users_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_users_command.ex new file mode 100644 index 0000000000..e87ea386d0 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_users_command.ex @@ -0,0 +1,43 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListUsersCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults(args, opts) do + {args, Map.merge(%{table_headers: true}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit_auth_backend_internal, :list_users, [], timeout) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage, do: "list_users [--no-table-headers]" + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :user_management + + def description(), do: "List user names and tags" + + def banner(_, _), do: "Listing users ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_vhost_limits_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_vhost_limits_command.ex new file mode 100644 index 0000000000..67b138f1e0 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_vhost_limits_command.ex @@ -0,0 +1,90 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListVhostLimitsCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + def switches(), do: [global: :boolean] + + def merge_defaults(args, %{global: true} = opts) do + {args, Map.merge(%{table_headers: true}, opts)} + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/", table_headers: true}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, global: true}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_vhost_limit, :list, []) do + [] -> + [] + + {:error, err} -> + {:error, err} + + {:badrpc, node} -> + {:badrpc, node} + + val -> + Enum.map(val, fn {vhost, val} -> + {:ok, val_encoded} = JSON.encode(Map.new(val)) + [vhost: vhost, limits: val_encoded] + end) + end + end + + def run([], %{node: node_name, vhost: vhost}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_vhost_limit, :list, [vhost]) do + [] -> + [] + + {:error, err} -> + {:error, err} + + {:badrpc, node} -> + {:badrpc, node} + + val when is_list(val) or is_map(val) -> + JSON.encode(Map.new(val)) + end + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage, do: "list_vhost_limits [--vhost <vhost>] [--global] [--no-table-headers]" + + def usage_additional() do + [ + ["--global", "list global limits (those not associated with a virtual host)"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.virtual_hosts() + ] + end + + def help_section(), do: :virtual_hosts + + def description(), do: "Displays configured virtual host limits" + + def banner([], %{global: true}) do + "Listing limits for all vhosts ..." + end + + def banner([], %{vhost: vhost}) do + "Listing limits for vhost \"#{vhost}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_vhosts_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_vhosts_command.ex new file mode 100644 index 0000000000..b570aa7486 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/list_vhosts_command.ex @@ -0,0 +1,84 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ListVhostsCommand do + alias RabbitMQ.CLI.Core.DocGuide + alias RabbitMQ.CLI.Ctl.InfoKeys + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + @info_keys ~w(name description tags tracing cluster_state)a + + def info_keys(), do: @info_keys + + def scopes(), do: [:ctl, :diagnostics] + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults([], opts) do + merge_defaults(["name"], opts) + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{table_headers: true}, opts)} + end + + def validate(args, _) do + case InfoKeys.validate_info_keys(args, @info_keys) do + {:ok, _} -> :ok + err -> err + end + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([_ | _] = args, %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit_vhost, :info_all, [], timeout) + |> filter_by_arg(args) + end + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage, do: "list_vhosts [--no-table-headers] [<column> ...]" + + def usage_additional() do + [ + ["<column>", "must be one of " <> Enum.join(Enum.sort(@info_keys), ", ")] + ] + end + + def usage_doc_guides() do + [ + DocGuide.virtual_hosts(), + DocGuide.access_control() + ] + end + + def help_section(), do: :access_control + + def description(), do: "Lists virtual hosts" + + def banner(_, _), do: "Listing vhosts ..." + + # + # Implementation + # + + defp filter_by_arg(vhosts, _) when is_tuple(vhosts) do + vhosts + end + + defp filter_by_arg(vhosts, [_ | _] = args) do + symbol_args = InfoKeys.prepare_info_keys(args) + + vhosts + |> Enum.map(fn vhost -> + symbol_args + |> Enum.filter(fn arg -> vhost[arg] != nil end) + |> Enum.map(fn arg -> {arg, vhost[arg]} end) + end) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/node_health_check_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/node_health_check_command.ex new file mode 100644 index 0000000000..31ea748d9f --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/node_health_check_command.ex @@ -0,0 +1,87 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.NodeHealthCheckCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @default_timeout 70_000 + + def scopes(), do: [:ctl, :diagnostics] + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults(args, opts) do + timeout = + case opts[:timeout] do + nil -> @default_timeout + :infinity -> @default_timeout + other -> other + end + + {args, Map.merge(opts, %{timeout: timeout})} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_health_check, :node, [node_name, timeout]) do + :ok -> + :ok + + true -> + :ok + + {:badrpc, _} = err -> + err + + {:error_string, error_message} -> + {:healthcheck_failed, error_message} + + {:node_is_ko, error_message, _exit_code} -> + {:healthcheck_failed, error_message} + + other -> + other + end + end + + def output(:ok, _) do + {:ok, "Health check passed"} + end + + def output({:healthcheck_failed, message}, _) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), + "Error: health check failed. Message: #{message}"} + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "node_health_check" + + def usage_doc_guides() do + [ + DocGuide.monitoring() + ] + end + + def help_section(), do: :deprecated + def description() do + "DEPRECATED. Performs intrusive, opinionated health checks on a fully booted node. " <> + "See https://www.rabbitmq.com/monitoring.html#health-checks instead" + end + + def banner(_, %{node: node_name, timeout: timeout}) do + [ + "This command is DEPRECATED and will be removed in a future version.", + "It performs intrusive, opinionated health checks and requires a fully booted node.", + "Use one of the options covered in https://www.rabbitmq.com/monitoring.html#health-checks instead.", + "Timeout: #{trunc(timeout / 1000)} seconds ...", + "Checking health of node #{node_name} ..." + ] + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/ping_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/ping_command.ex new file mode 100644 index 0000000000..7efb3b39f3 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/ping_command.ex @@ -0,0 +1,90 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.PingCommand do + alias RabbitMQ.CLI.Core.DocGuide + @behaviour RabbitMQ.CLI.CommandBehaviour + + @default_timeout 60_000 + + def scopes(), do: [:ctl, :diagnostics] + + def merge_defaults(args, opts) do + timeout = + case opts[:timeout] do + nil -> @default_timeout + :infinity -> @default_timeout + other -> other + end + + {args, Map.merge(opts, %{timeout: timeout})} + end + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout}) do + # this is very similar to what net_adm:ping/1 does reimplemented with support for custom timeouts + # and error values that are used by CLI commands + msg = "Failed to connect and authenticate to #{node_name} in #{timeout} ms" + + try do + case :gen.call({:net_kernel, node_name}, :"$gen_call", {:is_auth, node()}, timeout) do + :ok -> + :ok + + {:ok, _} -> + :ok + + _ -> + :erlang.disconnect_node(node_name) + {:error, msg} + end + catch + :exit, _ -> + :erlang.disconnect_node(node_name) + {:error, msg} + + _ -> + :erlang.disconnect_node(node_name) + {:error, msg} + end + end + + def output(:ok, _) do + {:ok, "Ping succeeded"} + end + + def output({:error, :timeout}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), + "Error: timed out while waiting for a response from #{node_name}."} + end + use RabbitMQ.CLI.DefaultOutput + + def usage() do + "ping" + end + + def usage_doc_guides() do + [ + DocGuide.monitoring() + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Checks that the node OS process is up, registered with EPMD and CLI tools can authenticate with it" + + def banner([], %{node: node_name, timeout: timeout}) when is_number(timeout) do + "Will ping #{node_name}. This only checks if the OS process is running and registered with epmd. Timeout: #{ + timeout + } ms." + end + + def banner([], %{node: node_name, timeout: _timeout}) do + "Will ping #{node_name}. This only checks if the OS process is running and registered with epmd." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/purge_queue_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/purge_queue_command.ex new file mode 100644 index 0000000000..1be25beb7d --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/purge_queue_command.ex @@ -0,0 +1,73 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.PurgeQueueCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([queue], %{node: node_name, vhost: vhost, timeout: timeout}) do + res = + :rabbit_misc.rpc_call( + node_name, + :rabbit_amqqueue, + :lookup, + [:rabbit_misc.r(vhost, :queue, queue)], + timeout + ) + + case res do + {:ok, q} -> purge(node_name, q, timeout) + _ -> res + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "purge_queue <queue>" + + def usage_additional() do + [ + ["<queue>", "Name of the queue to purge"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.queues() + ] + end + + def help_section(), do: :queues + + def description(), do: "Purges a queue (removes all messages in it)" + + def banner([queue], %{vhost: vhost}) do + "Purging queue '#{queue}' in vhost '#{vhost}' ..." + end + + # + # Implementation + # + + defp purge(node_name, q, timeout) do + res = :rabbit_misc.rpc_call(node_name, :rabbit_amqqueue, :purge, [q], timeout) + + case res do + {:ok, _message_count} -> :ok + _ -> res + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/rename_cluster_node_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/rename_cluster_node_command.ex new file mode 100644 index 0000000000..7faa30d00b --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/rename_cluster_node_command.ex @@ -0,0 +1,108 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.RenameClusterNodeCommand do + require Integer + alias RabbitMQ.CLI.Core.{DocGuide, Validators} + import RabbitMQ.CLI.Core.DataCoercion + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts), do: {args, opts} + + def validate(args, _) when length(args) < 2 do + {:validation_failure, :not_enough_args} + end + + def validate(_, _) do + :ok + end + + def validate_execution_environment(args, opts) do + Validators.chain( + [ + &validate_args_count_even/2, + &Validators.node_is_not_running/2, + &Validators.mnesia_dir_is_set/2, + &Validators.feature_flags_file_is_set/2, + &Validators.rabbit_is_loaded/2 + ], + [args, opts] + ) + end + + def run(nodes, %{node: node_name}) do + node_pairs = make_node_pairs(nodes) + + try do + :rabbit_mnesia_rename.rename(node_name, node_pairs) + catch + _, reason -> + {:rename_failed, reason} + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage() do + "rename_cluster_node <oldnode1> <newnode1> [oldnode2] [newnode2] ..." + end + + def usage_additional() do + [ + ["<oldnode>", "Original node name"], + ["<newnode>", "New node name"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.clustering() + ] + end + + def help_section(), do: :cluster_management + + def description(), do: "Renames cluster nodes in the local database" + + def banner(args, _) do + [ + "Renaming cluster nodes: \n ", + for {node_from, node_to} <- make_node_pairs(args) do + "#{node_from} -> #{node_to} \n" + end + ] + |> List.flatten() + |> Enum.join() + end + + # + # Implementation + # + + defp validate_args_count_even(args, _) do + case agrs_count_even?(args) do + true -> + :ok + + false -> + {:validation_failure, + {:bad_argument, "Argument list should contain even number of nodes"}} + end + end + + defp agrs_count_even?(args) do + Integer.is_even(length(args)) + end + + defp make_node_pairs([]) do + [] + end + + defp make_node_pairs([from, to | rest]) do + [{to_atom(from), to_atom(to)} | make_node_pairs(rest)] + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/report_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/report_command.ex new file mode 100644 index 0000000000..c06497a7e6 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/report_command.ex @@ -0,0 +1,118 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ReportCommand do + alias RabbitMQ.CLI.Core.DocGuide + alias RabbitMQ.CLI.Ctl.Commands.{ + ClusterStatusCommand, + EnvironmentCommand, + ListBindingsCommand, + ListChannelsCommand, + ListConnectionsCommand, + ListExchangesCommand, + ListGlobalParametersCommand, + ListParametersCommand, + ListPermissionsCommand, + ListPoliciesCommand, + ListQueuesCommand, + StatusCommand + } + alias RabbitMQ.CLI.Diagnostics.Commands.{ + CommandLineArgumentsCommand, + OsEnvCommand + } + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics] + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate([_ | _] = args, _) when length(args) != 0, + do: {:validation_failure, :too_many_args} + + def validate([], %{formatter: formatter}) do + case formatter do + "report" -> :ok + _other -> {:validation_failure, "Only report formatter is supported"} + end + end + + def validate([], _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name} = opts) do + case :rabbit_misc.rpc_call(node_name, :rabbit_vhost, :list_names, []) do + {:badrpc, _} = err -> + err + + vhosts -> + data = [ + run_command(StatusCommand, [], opts), + run_command(ClusterStatusCommand, [], opts), + run_command(EnvironmentCommand, [], opts), + run_command(ListConnectionsCommand, info_keys(ListConnectionsCommand), opts), + run_command(ListChannelsCommand, info_keys(ListChannelsCommand), opts), + run_command(CommandLineArgumentsCommand, [], opts), + run_command(OsEnvCommand, [], opts) + ] + + vhost_data = + vhosts + |> Enum.flat_map(fn v -> + opts = Map.put(opts, :vhost, v) + + [ + run_command(ListQueuesCommand, info_keys(ListQueuesCommand), opts), + run_command(ListExchangesCommand, info_keys(ListExchangesCommand), opts), + run_command(ListBindingsCommand, info_keys(ListBindingsCommand), opts), + run_command(ListPermissionsCommand, [], opts), + run_command(ListPoliciesCommand, [], opts), + run_command(ListGlobalParametersCommand, [], opts), + run_command(ListParametersCommand, [], opts), + + ] + end) + + data ++ vhost_data + end + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Report + + def usage, do: "report" + + def usage_doc_guides() do + [ + DocGuide.monitoring() + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Generate a server status report containing a concatenation of all server status information for support purposes" + + def banner(_, %{node: node_name}), do: "Reporting server status of node #{node_name} ..." + + # + # Implementation + # + + defp run_command(command, args, opts) do + {args, opts} = command.merge_defaults(args, opts) + banner = command.banner(args, opts) + command_result = command.run(args, opts) |> command.output(opts) + {command, banner, command_result} + end + + defp info_keys(command) do + command.info_keys() + |> Enum.map(&to_string/1) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/reset_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/reset_command.ex new file mode 100644 index 0000000000..575ef2491d --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/reset_command.ex @@ -0,0 +1,40 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ResetCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppStopped + + def run([], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit_mnesia, :reset, []) + end + + def output({:error, :mnesia_unexpectedly_running}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), + RabbitMQ.CLI.DefaultOutput.mnesia_running_error(node_name)} + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "reset" + + def usage_doc_guides() do + [ + DocGuide.clustering() + ] + end + + def help_section(), do: :node_management + + def description(), do: "Instructs a RabbitMQ node to leave the cluster and return to its virgin state" + + def banner(_, %{node: node_name}), do: "Resetting node #{node_name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/restart_vhost_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/restart_vhost_command.ex new file mode 100644 index 0000000000..36a7f702bc --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/restart_vhost_command.ex @@ -0,0 +1,62 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +alias RabbitMQ.CLI.Core.ExitCodes + +defmodule RabbitMQ.CLI.Ctl.Commands.RestartVhostCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults(args, opts), do: {args, Map.merge(%{vhost: "/"}, opts)} + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, vhost: vhost, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit_vhost_sup_sup, :start_vhost, [vhost], timeout) + end + + def output({:ok, _pid}, %{vhost: vhost, node: node_name}) do + {:ok, "Successfully restarted vhost '#{vhost}' on node '#{node_name}'"} + end + + def output({:error, {:already_started, _pid}}, %{vhost: vhost, node: node_name}) do + {:ok, "Vhost '#{vhost}' is already running on node '#{node_name}'"} + end + + def output({:error, err}, %{vhost: vhost, node: node_name}) do + {:error, ExitCodes.exit_software(), + ["Failed to start vhost '#{vhost}' on node '#{node_name}'", "Reason: #{inspect(err)}"]} + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "restart_vhost [--vhost <vhost>]" + + def usage_additional() do + [ + ["--vhost", "Virtual host name"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.virtual_hosts(), + DocGuide.monitoring() + ] + end + + def help_section(), do: :virtual_hosts + + def description(), do: "Restarts a failed vhost data stores and queues" + + def banner(_, %{node: node_name, vhost: vhost}) do + "Trying to restart vhost '#{vhost}' on node '#{node_name}' ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/resume_listeners_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/resume_listeners_command.ex new file mode 100644 index 0000000000..1f13660e0d --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/resume_listeners_command.ex @@ -0,0 +1,45 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ResumeListenersCommand do + @moduledoc """ + Resumes all client connection listeners making them accept new client + connections. This command is the opposite of `SuspendListenersCommand`. + + This command is meant to be used when automating upgrades. + See also `SuspendListenersCommand`. + """ + + @behaviour RabbitMQ.CLI.CommandBehaviour + + alias RabbitMQ.CLI.Core.DocGuide + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit_maintenance, :resume_all_client_listeners, [], timeout) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "resume_listeners" + + def usage_doc_guides() do + [ + DocGuide.upgrade() + ] + end + + def help_section(), do: :operations + + def description(), do: "Resumes client connection listeners making them accept client connections again" + + def banner(_, %{node: node_name}) do + "Will resume client connection listeners on node #{node_name}. " + <> "The node will now accept client connections" + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/rotate_logs_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/rotate_logs_command.ex new file mode 100644 index 0000000000..f3de3671fc --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/rotate_logs_command.ex @@ -0,0 +1,34 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.RotateLogsCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit, :rotate_logs, []) + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "rotate_logs" + + def usage_doc_guides() do + [ + DocGuide.logging() + ] + end + + def help_section(), do: :node_management + + def description(), do: "Instructs the RabbitMQ node to perform internal log rotation" + + def banner(_, %{node: node_name}), do: "Rotating logs for node #{node_name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_cluster_name_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_cluster_name_command.ex new file mode 100644 index 0000000000..f919cb2ae6 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_cluster_name_command.ex @@ -0,0 +1,47 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetClusterNameCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([cluster_name], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit_nodes, :set_cluster_name, [ + cluster_name, + Helpers.cli_acting_user() + ]) + end + + use RabbitMQ.CLI.DefaultOutput + + def banner([cluster_name], _) do + "Setting cluster name to #{cluster_name} ..." + end + + def usage, do: "set_cluster_name <name>" + + def usage_additional() do + [ + ["<name>", "New cluster name"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.virtual_hosts(), + DocGuide.access_control() + ] + end + + def help_section(), do: :configuration + + def description(), do: "Sets the cluster name" +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_disk_free_limit_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_disk_free_limit_command.ex new file mode 100644 index 0000000000..cf97c4655e --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_disk_free_limit_command.ex @@ -0,0 +1,140 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetDiskFreeLimitCommand do + alias RabbitMQ.CLI.Core.DocGuide + import RabbitMQ.CLI.Core.Memory + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + + def validate(["mem_relative"], _) do + {:validation_failure, :not_enough_args} + end + + def validate(["mem_relative" | _] = args, _) when length(args) != 2 do + {:validation_failure, :too_many_args} + end + + def validate([limit], _) do + case Integer.parse(limit) do + {_, ""} -> + :ok + + {limit_val, units} -> + case memory_unit_absolute(limit_val, units) do + scaled_limit when is_integer(scaled_limit) -> :ok + _ -> {:validation_failure, :bad_argument} + end + + _ -> + {:validation_failure, :bad_argument} + end + end + + def validate(["mem_relative", fraction], _) do + case Float.parse(fraction) do + {val, ""} when val >= 0.0 -> :ok + _ -> {:validation_failure, :bad_argument} + end + end + + def validate([_ | rest], _) when length(rest) > 0 do + {:validation_failure, :too_many_args} + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run(["mem_relative", _] = args, opts) do + set_disk_free_limit_relative(args, opts) + end + + def run([limit], %{node: _} = opts) when is_binary(limit) do + case Integer.parse(limit) do + {limit_val, ""} -> set_disk_free_limit_absolute([limit_val], opts) + {limit_val, units} -> set_disk_free_limit_in_units([limit_val, units], opts) + end + end + + def run([limit], opts) do + set_disk_free_limit_absolute([limit], opts) + end + + use RabbitMQ.CLI.DefaultOutput + + def banner(["mem_relative", arg], %{node: node_name}) do + "Setting disk free limit on #{node_name} to #{arg} times the total RAM ..." + end + + def banner([arg], %{node: node_name}), + do: "Setting disk free limit on #{node_name} to #{arg} bytes ..." + + def usage, do: "set_disk_free_limit <disk_limit> | mem_relative <fraction>" + + def usage_additional() do + [ + ["<disk_limit>", "New limit as an absolute value with units, e.g. 1GB"], + ["mem_relative <fraction>", "New limit as a fraction of total memory reported by the OS"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.disk_alarms(), + DocGuide.alarms() + ] + end + + def help_section(), do: :configuration + + def description(), do: "Sets the disk_free_limit setting" + + # + # Implementation + # + + defp set_disk_free_limit_relative(["mem_relative", fraction], %{node: node_name}) + when is_float(fraction) do + make_rpc_call(node_name, [{:mem_relative, fraction}]) + end + + defp set_disk_free_limit_relative(["mem_relative", integer_input], %{node: node_name}) + when is_integer(integer_input) do + make_rpc_call(node_name, [{:mem_relative, integer_input * 1.0}]) + end + + defp set_disk_free_limit_relative(["mem_relative", fraction_str], %{node: _} = opts) + when is_binary(fraction_str) do + {fraction_val, ""} = Float.parse(fraction_str) + set_disk_free_limit_relative(["mem_relative", fraction_val], opts) + end + + ## ------------------------ Absolute Size Call ----------------------------- + + defp set_disk_free_limit_absolute([limit], %{node: node_name}) when is_integer(limit) do + make_rpc_call(node_name, [limit]) + end + + defp set_disk_free_limit_absolute([limit], %{node: _} = opts) when is_float(limit) do + set_disk_free_limit_absolute([limit |> Float.floor() |> round], opts) + end + + defp set_disk_free_limit_in_units([limit_val, units], opts) do + case memory_unit_absolute(limit_val, units) do + scaled_limit when is_integer(scaled_limit) -> + set_disk_free_limit_absolute([scaled_limit], opts) + end + end + + defp make_rpc_call(node_name, args) do + :rabbit_misc.rpc_call(node_name, :rabbit_disk_monitor, :set_disk_free_limit, args) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_global_parameter_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_global_parameter_command.ex new file mode 100644 index 0000000000..8c46e9d592 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_global_parameter_command.ex @@ -0,0 +1,57 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetGlobalParameterCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate(args, _) when length(args) < 2 do + {:validation_failure, :not_enough_args} + end + def validate(args, _) when length(args) > 2 do + {:validation_failure, :too_many_args} + end + def validate(_, _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([name, value], %{node: node_name}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_runtime_parameters, + :parse_set_global, + [name, value, Helpers.cli_acting_user()] + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "set_global_parameter <name> <value>" + + def usage_additional() do + [ + ["<name>", "global parameter name (identifier)"], + ["<value>", "parameter value"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.parameters() + ] + end + + def help_section(), do: :parameters + + def description(), do: "Sets a runtime parameter." + + def banner([name, value], _) do + "Setting global runtime parameter \"#{name}\" to \"#{value}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_log_level_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_log_level_command.ex new file mode 100644 index 0000000000..f5a8eacbfc --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_log_level_command.ex @@ -0,0 +1,74 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetLogLevelCommand do + alias RabbitMQ.CLI.Core.DocGuide + @behaviour RabbitMQ.CLI.CommandBehaviour + @known_levels [ + "debug", + "info", + "notice", + "warning", + "error", + "critical", + "alert", + "emergency", + "none" + ] + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + def validate(args, _) when length(args) > 1 do + {:validation_failure, :too_many_args} + end + + def validate([level], _) do + case Enum.member?(@known_levels, level) do + true -> + :ok + + false -> + {:error, "level #{level} is not supported. Try one of debug, info, warning, error, none"} + end + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([log_level], %{node: node_name}) do + arg = String.to_atom(log_level) + :rabbit_misc.rpc_call(node_name, :rabbit_lager, :set_log_level, [arg]) + end + + def usage, do: "set_log_level <log_level>" + + def usage_additional() do + [ + ["<log_level>", "new log level"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.logging() + ] + end + + def help_section(), do: :configuration + + def description(), do: "Sets log level in the running node" + + def banner([log_level], _), do: "Setting log level to \"#{log_level}\" ..." + + def output({:error, {:invalid_log_level, level}}, _opts) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), + "level #{level} is not supported. Try one of debug, info, warning, error, none"} + end + + use RabbitMQ.CLI.DefaultOutput +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_operator_policy_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_operator_policy_command.ex new file mode 100644 index 0000000000..3118c125cb --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_operator_policy_command.ex @@ -0,0 +1,79 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetOperatorPolicyCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches(), do: [priority: :integer, apply_to: :string] + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/", priority: 0, apply_to: "all"}, opts)} + end + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + + def validate([_ | _] = args, _) when length(args) < 3 do + {:validation_failure, :not_enough_args} + end + + def validate([_ | _] = args, _) when length(args) > 3 do + {:validation_failure, :too_many_args} + end + + def validate(_, _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([name, pattern, definition], %{ + node: node_name, + vhost: vhost, + priority: priority, + apply_to: apply_to + }) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_policy, + :parse_set_op, + [vhost, name, pattern, definition, priority, apply_to, Helpers.cli_acting_user()] + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage() do + "set_operator_policy [--vhost <vhost>] [--priority <priority>] [--apply-to <apply-to>] <name> <pattern> <definition>" + end + + def usage_additional() do + [ + ["<name>", "policy name (identifier)"], + ["<pattern>", "a regular expression pattern that will be used to match queue, exchanges, etc"], + ["<definition>", "policy definition (arguments). Must be a valid JSON document"], + ["--priority <priority>", "policy priority"], + ["--apply-to <queues | exchanges | all>", "policy should only apply to queues, exchanges, or all entities (both of the above)"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.parameters() + ] + end + + def help_section(), do: :policies + + def description(), do: "Sets an operator policy that overrides a subset of arguments in user policies" + + def banner([name, pattern, definition], %{vhost: vhost, priority: priority}) do + "Setting operator policy override \"#{name}\" for pattern \"#{pattern}\" to \"#{definition}\" with priority \"#{ + priority + }\" for vhost \"#{vhost}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_parameter_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_parameter_command.ex new file mode 100644 index 0000000000..910cc6ef73 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_parameter_command.ex @@ -0,0 +1,68 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetParameterCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + + def validate([_ | _] = args, _) when length(args) < 3 do + {:validation_failure, :not_enough_args} + end + + def validate([_ | _] = args, _) when length(args) > 3 do + {:validation_failure, :too_many_args} + end + + def validate(_, _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([component_name, name, value], %{node: node_name, vhost: vhost}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_runtime_parameters, + :parse_set, + [vhost, component_name, name, value, Helpers.cli_acting_user()] + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "set_parameter [--vhost <vhost>] <component_name> <name> <value>" + + def usage_additional() do + [ + ["<component_name>", "component name"], + ["<name>", "parameter name (identifier)"], + ["<value>", "parameter value"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.parameters() + ] + end + + def help_section(), do: :parameters + + def description(), do: "Sets a runtime parameter." + + def banner([component_name, name, value], %{vhost: vhost}) do + "Setting runtime parameter \"#{name}\" for component \"#{component_name}\" to \"#{value}\" in vhost \"#{ + vhost + }\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_permissions_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_permissions_command.ex new file mode 100644 index 0000000000..c87969121c --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_permissions_command.ex @@ -0,0 +1,78 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetPermissionsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ExitCodes, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + + def validate([_ | _] = args, _) when length(args) < 4 do + {:validation_failure, :not_enough_args} + end + + def validate([_ | _] = args, _) when length(args) > 4 do + {:validation_failure, :too_many_args} + end + + def validate(_, _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([user, conf, write, read], %{node: node_name, vhost: vhost}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :set_permissions, + [user, vhost, conf, write, read, Helpers.cli_acting_user()] + ) + end + + def output({:error, {:no_such_user, username}}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => "User #{username} does not exist"}} + end + def output({:error, {:no_such_vhost, vhost}}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => "Virtual host #{vhost} does not exist"}} + end + def output({:error, {:no_such_user, username}}, _) do + {:error, ExitCodes.exit_nouser(), "User #{username} does not exist"} + end + def output({:error, {:no_such_vhost, vhost}}, _) do + {:error, "Virtual host #{vhost} does not exist"} + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "set_permissions [--vhost <vhost>] <username> <conf> <write> <read>" + + def usage_additional() do + [ + ["<username>", "Self-explanatory"], + ["<conf>", "Configuration permission pattern"], + ["<write>", "Write permission pattern"], + ["<read>", "Read permission pattern"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control(), + DocGuide.virtual_hosts() + ] + end + + def help_section(), do: :access_control + def description(), do: "Sets user permissions for a vhost" + + def banner([user | _], %{vhost: vhost}), + do: "Setting permissions for user \"#{user}\" in vhost \"#{vhost}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_policy_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_policy_command.ex new file mode 100644 index 0000000000..af34f3c659 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_policy_command.ex @@ -0,0 +1,76 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetPolicyCommand do + alias RabbitMQ.CLI.Core.{Helpers, DocGuide} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches(), do: [priority: :integer, apply_to: :string] + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/", priority: 0, apply_to: "all"}, opts)} + end + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + def validate(args, _) when length(args) < 3 do + {:validation_failure, :not_enough_args} + end + def validate(args, _) when length(args) > 3 do + {:validation_failure, :too_many_args} + end + def validate(_, _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([name, pattern, definition], %{ + node: node_name, + vhost: vhost, + priority: priority, + apply_to: apply_to + }) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_policy, + :parse_set, + [vhost, name, pattern, definition, priority, apply_to, Helpers.cli_acting_user()] + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage() do + "set_policy [--vhost <vhost>] [--priority <priority>] [--apply-to <apply-to>] <name> <pattern> <definition>" + end + + def usage_additional() do + [ + ["<name>", "policy name (identifier)"], + ["<pattern>", "regular expression pattern that will be used to match queues, exchanges, etc"], + ["<definition>", "policy definition (arguments). Must be a valid JSON document"], + ["--priority <priority>", "policy priority"], + ["--apply-to <queues | exchanges | all>", "policy should only apply to queues, exchanges, or all entities (both of the above)"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.parameters() + ] + end + + def help_section(), do: :policies + + def description(), do: "Sets or updates a policy" + + def banner([name, pattern, definition], %{vhost: vhost, priority: priority}) do + "Setting policy \"#{name}\" for pattern \"#{pattern}\" to \"#{definition}\" with priority \"#{ + priority + }\" for vhost \"#{vhost}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_topic_permissions_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_topic_permissions_command.ex new file mode 100644 index 0000000000..c57dc1659b --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_topic_permissions_command.ex @@ -0,0 +1,75 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetTopicPermissionsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ExitCodes, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + def validate(args, _) when length(args) < 4 do + {:validation_failure, :not_enough_args} + end + def validate(args, _) when length(args) > 4 do + {:validation_failure, :too_many_args} + end + def validate(_, _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([user, exchange, write_pattern, read_pattern], %{node: node_name, vhost: vhost}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :set_topic_permissions, + [user, vhost, exchange, write_pattern, read_pattern, Helpers.cli_acting_user()] + ) + end + + def output({:error, {:no_such_user, username}}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => "User #{username} does not exist"}} + end + def output({:error, {:no_such_vhost, vhost}}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => "Virtual host #{vhost} does not exist"}} + end + def output({:error, {:no_such_user, username}}, _) do + {:error, ExitCodes.exit_nouser(), "User #{username} does not exist"} + end + def output({:error, {:no_such_vhost, vhost}}, _) do + {:error, "Virtual host #{vhost} does not exist"} + end + use RabbitMQ.CLI.DefaultOutput + + def usage do + "set_topic_permissions [--vhost <vhost>] <username> <exchange> <write> <read>" + end + + def usage_additional do + [ + ["<username>", "Self-explanatory"], + ["<exchange>", "Topic exchange to set the permissions for"], + ["<write>", "Write permission pattern"], + ["<read>", "Read permission pattern"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :access_control + + def description(), do: "Sets user topic permissions for an exchange" + + def banner([user, exchange, _, _], %{vhost: vhost}), + do: + "Setting topic permissions on \"#{exchange}\" for user \"#{user}\" in vhost \"#{vhost}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_user_limits_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_user_limits_command.ex new file mode 100644 index 0000000000..603a8008e7 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_user_limits_command.ex @@ -0,0 +1,48 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetUserLimitsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsTwoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([username, definition], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit_auth_backend_internal, :set_user_limits, [ + username, + definition, + Helpers.cli_acting_user() + ]) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "set_user_limits <username> <definition>" + + def usage_additional() do + [ + ["<username>", "Self-explanatory"], + ["<definition>", "Limit definitions as a JSON document"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control() + ] + end + + def help_section(), do: :user_management + + def description(), do: "Sets user limits" + + def banner([username, definition], %{}) do + "Setting user limits to \"#{definition}\" for user \"#{username}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_user_tags_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_user_tags_command.ex new file mode 100644 index 0000000000..eba8ed6123 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_user_tags_command.ex @@ -0,0 +1,61 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetUserTagsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, ExitCodes, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts), do: {args, opts} + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + def validate(_, _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([user | tags], %{node: node_name}) do + :rabbit_misc.rpc_call( + node_name, + :rabbit_auth_backend_internal, + :set_tags, + [user, tags, Helpers.cli_acting_user()] + ) + end + + def output({:error, {:no_such_user, username}}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => "User #{username} does not exists"}} + end + def output({:error, {:no_such_user, username}}, _) do + {:error, ExitCodes.exit_nouser(), "User \"#{username}\" does not exist"} + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "set_user_tags <username> <tag> [...]" + + def usage_additional() do + [ + ["<username>", "Self-explanatory"], + ["<tags>", "Space separated list of tags"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.management(), + DocGuide.access_control() + ] + end + + def help_section(), do: :user_management + + def description(), do: "Sets user tags" + + def banner([user | tags], _) do + "Setting tags for user \"#{user}\" to [#{tags |> Enum.join(", ")}] ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_vhost_limits_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_vhost_limits_command.ex new file mode 100644 index 0000000000..f25f1c7bc4 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_vhost_limits_command.ex @@ -0,0 +1,50 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetVhostLimitsCommand do + alias RabbitMQ.CLI.Core.{DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([definition], %{node: node_name, vhost: vhost}) do + :rabbit_misc.rpc_call(node_name, :rabbit_vhost_limit, :parse_set, [ + vhost, + definition, + Helpers.cli_acting_user() + ]) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "set_vhost_limits [--vhost <vhost>] <definition>" + + def usage_additional() do + [ + ["<definition>", "Limit definitions, must be a valid JSON document"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.virtual_hosts() + ] + end + + def help_section(), do: :virtual_hosts + + def description(), do: "Sets virtual host limits" + + def banner([definition], %{vhost: vhost}) do + "Setting vhost limits to \"#{definition}\" for vhost \"#{vhost}\" ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_vm_memory_high_watermark_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_vm_memory_high_watermark_command.ex new file mode 100644 index 0000000000..a4e4527f8f --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/set_vm_memory_high_watermark_command.ex @@ -0,0 +1,146 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SetVmMemoryHighWatermarkCommand do + alias RabbitMQ.CLI.Core.DocGuide + import RabbitMQ.CLI.Core.Memory + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + + def validate(["absolute"], _) do + {:validation_failure, :not_enough_args} + end + + def validate(["absolute" | _] = args, _) when length(args) > 2 do + {:validation_failure, :too_many_args} + end + + def validate(["absolute", arg], _) do + case Integer.parse(arg) do + :error -> + {:validation_failure, :bad_argument} + + {_, rest} -> + case Enum.member?(memory_units(), rest) do + true -> + :ok + + false -> + case Float.parse(arg) do + {_, orest} when orest == rest -> + {:validation_failure, {:bad_argument, "Invalid units."}} + + _ -> + {:validation_failure, {:bad_argument, "The threshold should be an integer."}} + end + end + end + end + + def validate([_ | _] = args, _) when length(args) > 1 do + {:validation_failure, :too_many_args} + end + + def validate([arg], _) when is_number(arg) and (arg < 0.0 or arg > 1.0) do + {:validation_failure, + {:bad_argument, "The threshold should be a fraction between 0.0 and 1.0"}} + end + + def validate([arg], %{}) when is_binary(arg) do + case Float.parse(arg) do + {arg, ""} when is_number(arg) and (arg < 0.0 or arg > 1.0) -> + {:validation_failure, + {:bad_argument, "The threshold should be a fraction between 0.0 and 1.0"}} + + {_, ""} -> + :ok + + _ -> + {:validation_failure, :bad_argument} + end + end + + def validate(_, _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run(["absolute", arg], opts) do + case Integer.parse(arg) do + {num, rest} -> + valid_units = rest in memory_units() + set_vm_memory_high_watermark_absolute({num, rest}, valid_units, opts) + end + end + + def run([arg], %{node: node_name}) when is_number(arg) and arg >= 0.0 do + :rabbit_misc.rpc_call( + node_name, + :vm_memory_monitor, + :set_vm_memory_high_watermark, + [arg] + ) + end + + def run([arg], %{} = opts) when is_binary(arg) do + case Float.parse(arg) do + {num, ""} -> run([num], opts) + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage do + "set_vm_memory_high_watermark <fraction> | absolute <value>" + end + + def usage_additional() do + [ + ["<fraction>", "New limit as a fraction of total memory reported by the OS"], + ["absolute <value>", "New limit as an absolute value with units, e.g. 1GB"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.alarms(), + DocGuide.memory_use(), + ] + end + + def help_section(), do: :configuration + + def description(), do: "Sets the vm_memory_high_watermark setting" + + def banner(["absolute", arg], %{node: node_name}) do + "Setting memory threshold on #{node_name} to #{arg} bytes ..." + end + + def banner([arg], %{node: node_name}) do + "Setting memory threshold on #{node_name} to #{arg} ..." + end + + # + # Implementation + # + + defp set_vm_memory_high_watermark_absolute({num, rest}, true, %{node: node_name}) + when num > 0 do + val = memory_unit_absolute(num, rest) + + :rabbit_misc.rpc_call( + node_name, + :vm_memory_monitor, + :set_vm_memory_high_watermark, + [{:absolute, val}] + ) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/shutdown_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/shutdown_command.ex new file mode 100644 index 0000000000..10700bf309 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/shutdown_command.ex @@ -0,0 +1,106 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.ShutdownCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + alias RabbitMQ.CLI.Core.{OsPid, NodeName} + + def switches() do + [timeout: :integer, + wait: :boolean] + end + + def aliases(), do: [timeout: :t] + + def merge_defaults(args, opts) do + {args, Map.merge(%{wait: true, timeout: 120}, opts)} + end + + def validate([], %{wait: false}) do + :ok + end + + def validate([], %{node: node_name, wait: true}) do + local_hostname = NodeName.hostname_from_node(Node.self()) + remote_hostname = NodeName.hostname_from_node(node_name) + case addressing_local_node?(local_hostname, remote_hostname) do + true -> :ok; + false -> + msg = "\nThis command can only --wait for shutdown of local nodes " <> + "but node #{node_name} seems to be remote " <> + "(local hostname: #{local_hostname}, remote: #{remote_hostname}).\n" <> + "Pass --no-wait to shut node #{node_name} down without waiting.\n" + {:validation_failure, {:unsupported_target, msg}} + end + end + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, wait: false, timeout: timeout}) do + shut_down_node_without_waiting(node_name, timeout) + end + + def run([], %{node: node_name, wait: true, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :os, :getpid, []) do + pid when is_list(pid) -> + shut_down_node_and_wait_pid_to_stop(node_name, pid, timeout) + other -> + other + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "shutdown [--wait]" + + def usage_additional() do + [ + ["--wait", "if set, will wait for target node to terminate (by inferring and monitoring its PID file). Only works for local nodes."], + ["--no-wait", "if set, will not wait for target node to terminate"] + ] + end + + def help_section(), do: :node_management + + def description(), do: "Stops RabbitMQ and its runtime (Erlang VM). Monitors progress for local nodes. Does not require a PID file path." + + def banner(_, _), do: nil + + + # + # Implementation + # + + def addressing_local_node?(_, remote_hostname) when remote_hostname == :localhost , do: :true + def addressing_local_node?(_, remote_hostname) when remote_hostname == 'localhost', do: :true + def addressing_local_node?(_, remote_hostname) when remote_hostname == "localhost", do: :true + def addressing_local_node?(local_hostname, remote_hostname) do + local_hostname == remote_hostname + end + + defp shut_down_node_without_waiting(node_name, timeout) do + :rabbit_misc.rpc_call(node_name, :rabbit, :stop_and_halt, [], timeout) + end + + defp shut_down_node_and_wait_pid_to_stop(node_name, pid, timeout) do + {:stream, + RabbitMQ.CLI.Core.Helpers.stream_until_error([ + fn -> "Shutting down RabbitMQ node #{node_name} running at PID #{pid}" end, + fn -> + res = shut_down_node_without_waiting(node_name, timeout) + + case res do + :ok -> "Waiting for PID #{pid} to terminate" + {:badrpc, err} -> {:error, err} + {:error, _} = err -> err + end + end, + fn -> + OsPid.wait_for_os_process_death(pid) + "RabbitMQ node #{node_name} running at PID #{pid} successfully shut down" + end + ])} + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/start_app_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/start_app_command.ex new file mode 100644 index 0000000000..900bd762fa --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/start_app_command.ex @@ -0,0 +1,25 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.StartAppCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit, :start, []) + end + + def usage, do: "start_app" + + def help_section(), do: :node_management + + def description(), do: "Starts the RabbitMQ application but leaves the runtime (Erlang VM) running" + + def banner(_, %{node: node_name}), do: "Starting node #{node_name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/status_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/status_command.ex new file mode 100644 index 0000000000..582f514f27 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/status_command.ex @@ -0,0 +1,253 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.StatusCommand do + alias RabbitMQ.CLI.Core.DocGuide + alias RabbitMQ.CLI.InformationUnit, as: IU + import RabbitMQ.CLI.Core.{Alarms, ANSI, DataCoercion, Listeners, Memory, Platform} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @default_timeout 60_000 + + def scopes(), do: [:ctl, :diagnostics] + + def switches(), do: [unit: :string, timeout: :integer] + def aliases(), do: [t: :timeout] + + def merge_defaults(args, opts) do + timeout = + case opts[:timeout] do + nil -> @default_timeout + :infinity -> @default_timeout + other -> other + end + + {args, Map.merge(%{unit: "gb", timeout: timeout}, opts)} + end + + def validate(args, _) when length(args) > 0 do + {:validation_failure, :too_many_args} + end + def validate(_, %{unit: unit}) do + case IU.known_unit?(unit) do + true -> + :ok + + false -> + {:validation_failure, "unit '#{unit}' is not supported. Please use one of: bytes, mb, gb"} + end + end + def validate(_, _), do: :ok + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit, :status, [], timeout) + end + + def output({:error, :timeout}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), + "Error: timed out while waiting for a response from #{node_name}."} + end + + def output(result, %{formatter: "erlang"}) do + {:ok, result} + end + + def output(result, %{formatter: "json"}) when is_list(result) do + m = result_map(result) |> Map.update(:alarms, [], fn xs -> alarm_maps(xs) end) + + {:ok, m} + end + + def output(result, %{node: node_name, unit: unit}) when is_list(result) do + m = result_map(result) + + product_name_section = case m do + %{:product_name => product_name} when product_name != "" -> + ["Product name: #{product_name}"] + _ -> + [] + end + product_version_section = case m do + %{:product_version => product_version} when product_version != "" -> + ["Product version: #{product_version}"] + _ -> + [] + end + + runtime_section = [ + "#{bright("Runtime")}\n", + "OS PID: #{m[:pid]}", + "OS: #{m[:os]}", + # TODO: format + "Uptime (seconds): #{m[:uptime]}", + "Is under maintenance?: #{m[:is_under_maintenance]}" + ] ++ + product_name_section ++ + product_version_section ++ + [ + "RabbitMQ version: #{m[:rabbitmq_version]}", + "Node name: #{node_name}", + "Erlang configuration: #{m[:erlang_version]}", + "Erlang processes: #{m[:processes][:used]} used, #{m[:processes][:limit]} limit", + "Scheduler run queue: #{m[:run_queue]}", + "Cluster heartbeat timeout (net_ticktime): #{m[:net_ticktime]}" + ] + + plugin_section = [ + "\n#{bright("Plugins")}\n", + "Enabled plugin file: #{m[:enabled_plugin_file]}", + "Enabled plugins:\n" + ] ++ Enum.map(m[:active_plugins], fn pl -> " * #{pl}" end) + + data_directory_section = [ + "\n#{bright("Data directory")}\n", + "Node data directory: #{m[:data_directory]}", + "Raft data directory: #{m[:raft_data_directory]}" + ] + + config_section = [ + "\n#{bright("Config files")}\n" + ] ++ Enum.map(m[:config_files], fn path -> " * #{path}" end) + + log_section = [ + "\n#{bright("Log file(s)")}\n" + ] ++ Enum.map(m[:log_files], fn path -> " * #{path}" end) + + alarms_section = [ + "\n#{bright("Alarms")}\n", + ] ++ case m[:alarms] do + [] -> ["(none)"] + xs -> alarm_lines(xs, node_name) + end + + breakdown = compute_relative_values(m[:memory]) + memory_calculation_strategy = to_atom(m[:vm_memory_calculation_strategy]) + total_memory = get_in(m[:memory], [:total, memory_calculation_strategy]) + + readable_watermark_setting = case m[:vm_memory_high_watermark_setting] do + %{:relative => val} -> "#{val} of available memory" + # absolute value + %{:absolute => val} -> "#{IU.convert(val, unit)} #{unit}" + end + memory_section = [ + "\n#{bright("Memory")}\n", + "Total memory used: #{IU.convert(total_memory, unit)} #{unit}", + "Calculation strategy: #{memory_calculation_strategy}", + "Memory high watermark setting: #{readable_watermark_setting}, computed to: #{IU.convert(m[:vm_memory_high_watermark_limit], unit)} #{unit}\n" + ] ++ Enum.map(breakdown, fn({category, val}) -> "#{category}: #{IU.convert(val[:bytes], unit)} #{unit} (#{val[:percentage]} %)" end) + + file_descriptors = [ + "\n#{bright("File Descriptors")}\n", + "Total: #{m[:file_descriptors][:total_used]}, limit: #{m[:file_descriptors][:total_limit]}", + "Sockets: #{m[:file_descriptors][:sockets_used]}, limit: #{m[:file_descriptors][:sockets_limit]}" + ] + + disk_space_section = [ + "\n#{bright("Free Disk Space")}\n", + "Low free disk space watermark: #{IU.convert(m[:disk_free_limit], unit)} #{unit}", + "Free disk space: #{IU.convert(m[:disk_free], unit)} #{unit}" + ] + + totals_section = [ + "\n#{bright("Totals")}\n", + "Connection count: #{m[:totals][:connection_count]}", + "Queue count: #{m[:totals][:queue_count]}", + "Virtual host count: #{m[:totals][:virtual_host_count]}" + ] + + listeners_section = [ + "\n#{bright("Listeners")}\n", + ] ++ case m[:listeners] do + [] -> ["(none)"] + xs -> listener_lines(xs) + end + lines = runtime_section ++ plugin_section ++ data_directory_section ++ + config_section ++ log_section ++ alarms_section ++ memory_section ++ + file_descriptors ++ disk_space_section ++ totals_section ++ listeners_section + + {:ok, Enum.join(lines, line_separator())} + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.String + + def usage, do: "status [--unit <unit>]" + + def usage_additional() do + [ + ["--unit <bytes | mb | gb>", "byte multiple (bytes, megabytes, gigabytes) to use"], + ["--formatter <json | erlang>", "alternative formatter (JSON, Erlang terms)"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.monitoring() + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Displays status of a node" + + def banner(_, %{node: node_name}), do: "Status of node #{node_name} ..." + + # + # Implementation + # + + defp result_map(result) do + %{ + os: os_name(Keyword.get(result, :os)), + pid: Keyword.get(result, :pid), + product_name: Keyword.get(result, :product_name) |> to_string, + product_version: Keyword.get(result, :product_version) |> to_string, + rabbitmq_version: Keyword.get(result, :rabbitmq_version) |> to_string, + erlang_version: Keyword.get(result, :erlang_version) |> to_string |> String.trim_trailing, + uptime: Keyword.get(result, :uptime), + is_under_maintenance: Keyword.get(result, :is_under_maintenance, false), + processes: Enum.into(Keyword.get(result, :processes), %{}), + run_queue: Keyword.get(result, :run_queue), + net_ticktime: net_ticktime(result), + + vm_memory_calculation_strategy: Keyword.get(result, :vm_memory_calculation_strategy), + vm_memory_high_watermark_setting: Keyword.get(result, :vm_memory_high_watermark) |> formatted_watermark, + vm_memory_high_watermark_limit: Keyword.get(result, :vm_memory_limit), + + disk_free_limit: Keyword.get(result, :disk_free_limit), + disk_free: Keyword.get(result, :disk_free), + + file_descriptors: Enum.into(Keyword.get(result, :file_descriptors), %{}), + + alarms: Keyword.get(result, :alarms), + listeners: listener_maps(Keyword.get(result, :listeners, [])), + memory: Keyword.get(result, :memory) |> Enum.into(%{}), + + data_directory: Keyword.get(result, :data_directory) |> to_string, + raft_data_directory: Keyword.get(result, :raft_data_directory) |> to_string, + + config_files: Keyword.get(result, :config_files) |> Enum.map(&to_string/1), + log_files: Keyword.get(result, :log_files) |> Enum.map(&to_string/1), + + active_plugins: Keyword.get(result, :active_plugins) |> Enum.map(&to_string/1), + enabled_plugin_file: Keyword.get(result, :enabled_plugin_file) |> to_string, + + totals: Keyword.get(result, :totals) + } + end + + defp net_ticktime(result) do + case Keyword.get(result, :kernel) do + {:net_ticktime, n} -> n + n when is_integer(n) -> n + _ -> :undefined + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/stop_app_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/stop_app_command.ex new file mode 100644 index 0000000000..c3cbe3b1fd --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/stop_app_command.ex @@ -0,0 +1,26 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.StopAppCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit, :stop, []) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "stop_app" + + def help_section(), do: :node_management + + def description(), do: "Stops the RabbitMQ application, leaving the runtime (Erlang VM) running" + + def banner(_, %{node: node_name}), do: "Stopping rabbit application on node #{node_name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/stop_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/stop_command.ex new file mode 100644 index 0000000000..becb75a0b5 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/stop_command.ex @@ -0,0 +1,72 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.StopCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + alias RabbitMQ.CLI.Core.OsPid + + def merge_defaults(args, opts) do + {args, Map.merge(%{idempotent: false}, opts)} + end + + def switches(), do: [idempotent: :boolean] + + def validate([], _), do: :ok + def validate([_pidfile_path], _), do: :ok + def validate([_ | _] = args, _) when length(args) > 1, do: {:validation_failure, :too_many_args} + + def run([], %{node: node_name, idempotent: true}) do + case :rabbit_misc.rpc_call(node_name, :rabbit, :stop_and_halt, []) do + {:badrpc, :nodedown} -> {:ok, "Node #{node_name} is no longer running"} + any -> any + end + end + + def run([], %{node: node_name, idempotent: false}) do + :rabbit_misc.rpc_call(node_name, :rabbit, :stop_and_halt, []) + end + + def run([pidfile_path], %{node: node_name}) do + ret = OsPid.read_pid_from_file(pidfile_path, true) + :rabbit_misc.rpc_call(node_name, :rabbit, :stop_and_halt, []) + + case ret do + {:error, details} -> + {:error, "could not read pid from file #{pidfile_path}. Error: #{details}"} + + {:error, :could_not_read_pid_from_file, {:contents, s}} -> + {:error, "could not read pid from file #{pidfile_path}. File contents: #{s}"} + + {:error, :could_not_read_pid_from_file, details} -> + {:error, "could not read pid from file #{pidfile_path}. Error: #{details}"} + + pid -> + OsPid.wait_for_os_process_death(pid) + {:ok, "process #{pid} (take from pid file #{pidfile_path}) is no longer running"} + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "stop [--idempotent] [<pidfile>]" + + def usage_additional() do + [ + ["<pidfile>", "node PID file path to monitor. To avoid using a PID file, use 'rabbitmqctl shutdown'"], + ["--idempotent", "return success if target node is not running (cannot be contacted)"] + ] + end + + def description(), do: "Stops RabbitMQ and its runtime (Erlang VM). Requires a local node pid file path to monitor progress." + + def help_section(), do: :node_management + + def banner([pidfile_path], %{node: node_name}) do + "Stopping and halting node #{node_name} (will monitor pid file #{pidfile_path}) ..." + end + + def banner(_, %{node: node_name}), do: "Stopping and halting node #{node_name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/suspend_listeners_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/suspend_listeners_command.ex new file mode 100644 index 0000000000..31fcf738b9 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/suspend_listeners_command.ex @@ -0,0 +1,46 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SuspendListenersCommand do + @moduledoc """ + Suspends all client connection listeners. Suspended listeners will not + accept any new connections but already established ones will not be interrupted. + `ResumeListenersCommand` will undo the effect of this command. + + This command is meant to be used when automating upgrades. + See also `ResumeListenersCommand`. + """ + + @behaviour RabbitMQ.CLI.CommandBehaviour + + alias RabbitMQ.CLI.Core.DocGuide + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit_maintenance, :suspend_all_client_listeners, [], timeout) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "suspend_listeners" + + def usage_doc_guides() do + [ + DocGuide.upgrade() + ] + end + + def help_section(), do: :operations + + def description(), do: "Suspends client connection listeners so that no new client connections are accepted" + + def banner(_, %{node: node_name}) do + "Will suspend client connection listeners on node #{node_name}. " + <> "The node will no longer accept client connections!" + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/sync_queue_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/sync_queue_command.ex new file mode 100644 index 0000000000..4b7112af57 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/sync_queue_command.ex @@ -0,0 +1,54 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.SyncQueueCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([queue], %{vhost: vhost, node: node_name}) do + :rpc.call( + node_name, + :rabbit_mirror_queue_misc, + :sync_queue, + [:rabbit_misc.r(vhost, :queue, queue)], + :infinity + ) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage do + "sync_queue [--vhost <vhost>] <queue>" + end + + def usage_additional() do + [ + ["<queue>", "Name of the queue to synchronise"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.mirroring() + ] + end + + def help_section(), do: :replication + + def description(), do: "Instructs a mirrored queue with unsynchronised mirrors (follower replicas) to synchronise them" + + def banner([queue], %{vhost: vhost, node: _node}) do + "Synchronising queue '#{queue}' in vhost '#{vhost}' ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/trace_off_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/trace_off_command.ex new file mode 100644 index 0000000000..f2b6cc217f --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/trace_off_command.ex @@ -0,0 +1,42 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.TraceOffCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(_, opts) do + {[], Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, vhost: vhost}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_trace, :stop, [vhost]) do + :ok -> {:ok, "Trace disabled for vhost #{vhost}"} + other -> other + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage do + "trace_off [--vhost <vhost>]" + end + + def usage_doc_guides() do + [ + DocGuide.firehose(), + DocGuide.virtual_hosts() + ] + end + + def help_section(), do: :virtual_hosts + + def banner(_, %{vhost: vhost}), do: "Stopping tracing for vhost \"#{vhost}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/trace_on_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/trace_on_command.ex new file mode 100644 index 0000000000..33bb5a06d6 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/trace_on_command.ex @@ -0,0 +1,42 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.TraceOnCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(_, opts) do + {[], Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, vhost: vhost}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_trace, :start, [vhost]) do + :ok -> {:ok, "Trace enabled for vhost #{vhost}"} + other -> other + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage do + "trace_on [--vhost <vhost>]" + end + + def usage_doc_guides() do + [ + DocGuide.firehose(), + DocGuide.virtual_hosts() + ] + end + + def help_section(), do: :virtual_hosts + + def banner(_, %{vhost: vhost}), do: "Starting tracing for vhost \"#{vhost}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/update_cluster_nodes_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/update_cluster_nodes_command.ex new file mode 100644 index 0000000000..94b218e2c9 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/update_cluster_nodes_command.ex @@ -0,0 +1,62 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2016-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.UpdateClusterNodesCommand do + alias RabbitMQ.CLI.Core.{Config, DocGuide, Helpers} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppStopped + + def run([seed_node], options=%{node: node_name}) do + long_or_short_names = Config.get_option(:longnames, options) + seed_node_normalised = Helpers.normalise_node(seed_node, long_or_short_names) + :rabbit_misc.rpc_call( + node_name, + :rabbit_mnesia, + :update_cluster_nodes, + [seed_node_normalised] + ) + end + + def usage() do + "update_cluster_nodes <seed_node>" + end + + def usage_additional() do + [ + ["<seed_node>", "Cluster node to seed known cluster members from"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.clustering() + ] + end + + def help_section(), do: :cluster_management + + def description(), do: "Instructs a cluster member node to sync the list of known cluster members from <seed_node>" + + def banner([seed_node], %{node: node_name}) do + "Will seed #{node_name} from #{seed_node} on next start" + end + + def output({:error, :mnesia_unexpectedly_running}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), + RabbitMQ.CLI.DefaultOutput.mnesia_running_error(node_name)} + end + + def output({:error, :cannot_cluster_node_with_itself}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), + "Error: cannot cluster node with itself: #{node_name}"} + end + + use RabbitMQ.CLI.DefaultOutput +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/version_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/version_command.ex new file mode 100644 index 0000000000..8028054932 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/version_command.ex @@ -0,0 +1,40 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.VersionCommand do + alias RabbitMQ.CLI.Core.{Validators, Version} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:ctl, :diagnostics, :plugins] + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def validate_execution_environment([] = args, opts) do + Validators.rabbit_is_loaded(args, opts) + end + + def run([], %{formatter: "json"}) do + {:ok, %{version: Version.local_version()}} + end + def run([], %{formatter: "csv"}) do + row = [version: Version.local_version()] + {:ok, [row]} + end + def run([], _opts) do + {:ok, Version.local_version()} + end + use RabbitMQ.CLI.DefaultOutput + + def help_section, do: :help + + def description, do: "Displays CLI tools version" + + def usage, do: "version" + + def banner(_, _), do: nil +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/wait_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/wait_command.ex new file mode 100644 index 0000000000..0699203de6 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/commands/wait_command.ex @@ -0,0 +1,269 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.Commands.WaitCommand do + alias RabbitMQ.CLI.Core.{Helpers, Validators} + + @behaviour RabbitMQ.CLI.CommandBehaviour + @default_timeout 10_000 + + def scopes(), do: [:ctl, :diagnostics] + + def switches(), do: [pid: :integer, timeout: :integer] + def aliases(), do: [P: :pid, t: :timeout] + + def merge_defaults(args, opts) do + timeout = + case opts[:timeout] do + nil -> @default_timeout + :infinity -> @default_timeout + val -> val + end + + {args, Map.put(opts, :timeout, timeout)} + end + + def validate([_ | _] = args, _) when length(args) > 1, do: {:validation_failure, :too_many_args} + def validate([_], %{pid: _}), do: {:validation_failure, "Cannot specify both pid and pidfile"} + def validate([_], _), do: :ok + def validate([], %{pid: _}), do: :ok + def validate([], _), do: {:validation_failure, "No pid or pidfile specified"} + + def validate_execution_environment([], %{pid: _} = opts) do + Validators.rabbit_is_loaded([], opts) + end + def validate_execution_environment([_pid_file], opts) do + Validators.rabbit_is_loaded([], opts) + end + + def run([pid_file], %{node: node_name, timeout: timeout} = opts) do + app_names = :rabbit_and_plugins + quiet = opts[:quiet] || false + + Helpers.stream_until_error_parameterised( + [ + log("Waiting for pid file '#{pid_file}' to appear", quiet), + fn _ -> wait_for_pid_file(pid_file, node_name, timeout) end, + log_param(fn pid -> "pid is #{pid}" end, quiet) + ] ++ + wait_for_pid_funs(node_name, app_names, timeout, quiet), + :init + ) + end + + def run([], %{node: node_name, pid: pid, timeout: timeout} = opts) do + app_names = :rabbit_and_plugins + quiet = opts[:quiet] || false + + Helpers.stream_until_error_parameterised( + wait_for_pid_funs(node_name, app_names, timeout, quiet), + pid + ) + end + + def output({:error, err}, opts) do + case format_error(err) do + :undefined -> RabbitMQ.CLI.DefaultOutput.output({:error, err}, opts) + error_str -> {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), error_str} + end + end + + def output({:stream, stream}, _opts) do + {:stream, + Stream.map(stream, fn + {:error, err} -> + {:error, + case format_error(err) do + :undefined -> err + error_str -> error_str + end} + + other -> + other + end)} + end + + use RabbitMQ.CLI.DefaultOutput + + # Banner is printed in wait steps + def banner(_, _), do: nil + + def usage, do: "wait [<pidfile>] [--pid|-P <pid>]" + + def usage_additional() do + [ + ["<pidfile>", "PID file path"], + ["--pid <pid>", "operating system PID to monitor"] + ] + end + + def help_section(), do: :node_management + + def description(), do: "Waits for RabbitMQ node startup by monitoring a local PID file. See also 'rabbitmqctl await_online_nodes'" + + # + # Implementation + # + + def wait_for(timeout, fun) do + sleep = 1000 + + case wait_for_loop(timeout, sleep, fun) do + {:error, :timeout} -> {:error, {:timeout, timeout}} + other -> other + end + end + + def wait_for_loop(timeout, _, _) when timeout <= 0 do + {:error, :timeout} + end + + def wait_for_loop(timeout, sleep, fun) do + time = :erlang.system_time(:milli_seconds) + + case fun.() do + {:error, :loop} -> + time_to_fun = :erlang.system_time(:milli_seconds) - time + + time_taken = + case {time_to_fun > timeout, time_to_fun > sleep} do + ## The function took longer than timeout + {true, _} -> + time_to_fun + + ## The function took longer than sleep + {false, true} -> + time_to_fun + + ## We need to sleep + {false, false} -> + :timer.sleep(sleep) + time_to_fun + sleep + end + + wait_for_loop(timeout - time_taken, sleep, fun) + + other -> + other + end + end + + defp wait_for_pid_funs(node_name, app_names, timeout, quiet) do + app_names_formatted = :io_lib.format('~p', [app_names]) + + [ + log_param( + fn pid -> + "Waiting for erlang distribution on node '#{node_name}' while OS process '#{pid}' is running" + end, + quiet + ), + fn pid -> wait_for_erlang_distribution(pid, node_name, timeout) end, + log( + "Waiting for applications '#{app_names_formatted}' to start on node '#{node_name}'", + quiet + ), + fn _ -> wait_for_application(node_name, app_names) end, + log("Applications '#{app_names_formatted}' are running on node '#{node_name}'", quiet) + ] + end + + defp log(_string, _quiet = true) do + fn val -> {:ok, val} end + end + + defp log(string, _quiet = false) do + fn val -> {:ok, val, string} end + end + + defp log_param(_fun, _quiet = true) do + fn val -> {:ok, val} end + end + + defp log_param(fun, _quiet = false) do + fn val -> {:ok, val, fun.(val)} end + end + + defp format_error(:process_not_running) do + "Error: process is not running." + end + + defp format_error({:garbage_in_pid_file, _}) do + "Error: garbage in pid file." + end + + defp format_error({:could_not_read_pid, err}) do + "Error: could not read pid. Detail: #{err}" + end + + defp format_error(_) do + :undefined + end + + defp wait_for_application(node_name, :rabbit_and_plugins) do + case :rabbit.await_startup(node_name) do + {:badrpc, err} -> {:error, {:badrpc, err}} + other -> other + end + end + + defp wait_for_erlang_distribution(pid, node_name, timeout) do + wait_for( + timeout, + fn -> + case check_distribution(pid, node_name) do + # Loop while node is available. + {:error, :pang} -> {:error, :loop} + other -> other + end + end + ) + end + + defp check_distribution(pid, node_name) do + case is_os_process_alive(pid) do + true -> + case Node.ping(node_name) do + :pong -> :ok + :pang -> {:error, :pang} + end + + false -> + {:error, :process_not_running} + end + end + + defp is_os_process_alive(pid) do + :rabbit_misc.is_os_process_alive(to_charlist(pid)) + end + + defp wait_for_pid_file(pid_file, node_name, timeout) do + wait_for( + timeout, + fn -> + case :file.read_file(pid_file) do + {:ok, bin} -> + case Integer.parse(bin) do + :error -> + {:error, {:garbage_in_pid_file, pid_file}} + + {pid, _} -> + case check_distribution(pid, node_name) do + :ok -> {:ok, pid} + _ -> {:error, :loop} + end + end + + {:error, :enoent} -> + {:error, :loop} + + {:error, err} -> + {:error, {:could_not_read_pid, err}} + end + end + ) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/info_keys.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/info_keys.ex new file mode 100644 index 0000000000..26f86ae51e --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/info_keys.ex @@ -0,0 +1,62 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.InfoKeys do + import RabbitCommon.Records + alias RabbitMQ.CLI.Core.DataCoercion + + def validate_info_keys(args, valid_keys) do + info_keys = prepare_info_keys(args) + + case invalid_info_keys(info_keys, Enum.map(valid_keys, &DataCoercion.to_atom/1)) do + [_ | _] = bad_info_keys -> + {:validation_failure, {:bad_info_key, bad_info_keys}} + + [] -> + {:ok, info_keys} + end + end + + def prepare_info_keys(args) do + args + |> Enum.flat_map(fn arg -> String.split(arg, ",", trim: true) end) + |> Enum.map(fn s -> String.replace(s, ",", "") end) + |> Enum.map(&String.trim/1) + |> Enum.map(&String.to_atom/1) + |> Enum.uniq() + end + + def with_valid_info_keys(args, valid_keys, fun) do + case validate_info_keys(args, valid_keys) do + {:ok, info_keys} -> fun.(info_keys) + err -> err + end + end + + defp invalid_info_keys(info_keys, valid_keys) do + MapSet.new(info_keys) + |> MapSet.difference(MapSet.new(valid_keys)) + |> MapSet.to_list() + end + + def info_for_keys(item, []) do + item + end + + def info_for_keys([{_, _} | _] = item, info_keys) do + item + |> Enum.filter(fn {k, _} -> Enum.member?(info_keys, k) end) + |> Enum.map(fn {k, v} -> {k, format_info_item(v)} end) + end + + defp format_info_item(resource(name: name)) do + name + end + + defp format_info_item(any) do + any + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/rpc_stream.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/rpc_stream.ex new file mode 100644 index 0000000000..4b672a6d88 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/ctl/rpc_stream.ex @@ -0,0 +1,124 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Ctl.RpcStream do + alias RabbitMQ.CLI.Ctl.InfoKeys + + def receive_list_items(node, mod, fun, args, timeout, info_keys) do + receive_list_items(node, [{mod, fun, args}], timeout, info_keys, 1) + end + + def receive_list_items(node, mod, fun, args, timeout, info_keys, chunks) do + receive_list_items(node, [{mod, fun, args}], timeout, info_keys, chunks) + end + + def receive_list_items(_node, _mfas, _timeout, _info_keys, 0) do + nil + end + + def receive_list_items(node, mfas, timeout, info_keys, chunks_init) do + receive_list_items_with_fun(node, mfas, timeout, info_keys, chunks_init, fn v -> v end) + end + + def receive_list_items_with_fun(node, mfas, timeout, info_keys, chunks_init, response_fun) do + pid = Kernel.self() + ref = Kernel.make_ref() + for {m, f, a} <- mfas, do: init_items_stream(node, m, f, a, timeout, pid, ref) + + Stream.unfold( + {chunks_init, :continue}, + fn + :finished -> + response_fun.(nil) + + {chunks, :continue} -> + received = + receive do + {^ref, :finished} when chunks === 1 -> + nil + + {^ref, :finished} -> + {[], {chunks - 1, :continue}} + + {^ref, {:timeout, t}} -> + {{:error, {:badrpc, {:timeout, t / 1000}}}, :finished} + + {^ref, []} -> + {[], {chunks, :continue}} + + {^ref, :error, {:badrpc, :timeout}} -> + {{:error, {:badrpc, {:timeout, timeout / 1000}}}, :finished} + + {^ref, result, :continue} -> + {result, {chunks, :continue}} + + {:error, _} = error -> + {error, :finished} + + {^ref, :error, error} -> + {{:error, simplify_emission_error(error)}, :finished} + + {:DOWN, _mref, :process, _pid, :normal} -> + {[], {chunks, :continue}} + + {:DOWN, _mref, :process, _pid, reason} -> + {{:error, simplify_emission_error(reason)}, :finished} + end + + response_fun.(received) + end + ) + |> display_list_items(info_keys) + end + + def simplify_emission_error({:badrpc, {:EXIT, {{:nocatch, error}, error_details}}}) do + {error, error_details} + end + + def simplify_emission_error({{:nocatch, error}, error_details}) do + {error, error_details} + end + + def simplify_emission_error(other) do + other + end + + defp display_list_items(items, info_keys) do + items + |> Stream.filter(fn + [] -> false + _ -> true + end) + |> Stream.map(fn + {:error, error} -> + error + + # here item is a list of keyword lists: + [[{_, _} | _] | _] = item -> + Enum.map(item, fn i -> InfoKeys.info_for_keys(i, info_keys) end) + + item -> + InfoKeys.info_for_keys(item, info_keys) + end) + end + + defp init_items_stream(_node, _mod, _fun, _args, 0, pid, ref) do + set_stream_timeout(pid, ref, 0) + end + + defp init_items_stream(node, mod, fun, args, timeout, pid, ref) do + :rabbit_control_misc.spawn_emitter_caller(node, mod, fun, args, ref, pid, timeout) + set_stream_timeout(pid, ref, timeout) + end + + defp set_stream_timeout(_, _, :infinity) do + :ok + end + + defp set_stream_timeout(pid, ref, timeout) do + Process.send_after(pid, {ref, {:timeout, timeout}}, timeout) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/default_output.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/default_output.ex new file mode 100644 index 0000000000..d5e3f94a15 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/default_output.ex @@ -0,0 +1,94 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. +alias RabbitMQ.CLI.Formatters.FormatterHelpers + +defmodule RabbitMQ.CLI.DefaultOutput do + # When `use RabbitMQ.CLI.DefaultOutput` is invoked, + # this will define output/2 that delegates to RabbitMQ.CLI.DefaultOutput.output/2. + defmacro __using__(_) do + quote do + def output(result, opts) do + RabbitMQ.CLI.DefaultOutput.output(result, opts) + end + end + end + + def output(result, opts \\ %{}) do + format_output(normalize_output(result, opts)) + end + + def mnesia_running_error(node_name) do + "Mnesia is still running on node #{node_name}.\n" <> + "Please stop RabbitMQ with 'rabbitmqctl stop_app' first." + end + + defp normalize_output(:ok, %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => "ok", "node" => node_name}} + end + defp normalize_output(:ok, _opts), do: :ok + defp normalize_output({:ok, value}, %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => "ok", "node" => node_name, "value" => value}} + end + defp normalize_output({:ok, _} = input, _opts), do: input + defp normalize_output({:stream, _} = input, _opts), do: input + defp normalize_output({:badrpc_multi, _, _} = input, _opts), do: {:error, input} + defp normalize_output({:badrpc, :nodedown} = input, _opts), do: {:error, input} + defp normalize_output({:badrpc, :timeout} = input, _opts), do: {:error, input} + defp normalize_output({:badrpc, {:timeout, _n}} = input, _opts), do: {:error, input} + defp normalize_output({:badrpc, {:timeout, _n, _msg}} = input, _opts), do: {:error, input} + defp normalize_output({:badrpc, {:EXIT, reason}}, _opts), do: {:error, reason} + defp normalize_output({:error, exit_code, string}, _opts) when is_integer(exit_code) do + {:error, exit_code, to_string(string)} + end + defp normalize_output({:error, format, args}, _opts) + when (is_list(format) or is_binary(format)) and is_list(args) do + {:error, to_string(:rabbit_misc.format(format, args))} + end + defp normalize_output({:error, _} = input, _opts), do: input + defp normalize_output({:error_string, string}, _opts) do + {:error, to_string(string)} + end + defp normalize_output(unknown, _opts) when is_atom(unknown), do: {:error, unknown} + defp normalize_output({unknown, _} = input, _opts) when is_atom(unknown), do: {:error, input} + defp normalize_output(result, _opts) when not is_atom(result), do: {:ok, result} + + + defp format_output({:error, _} = result) do + result + end + defp format_output({:error, _, _} = result) do + result + end + + defp format_output(:ok) do + :ok + end + + defp format_output({:ok, output}) do + case Enumerable.impl_for(output) do + nil -> + {:ok, output} + + ## Do not streamify plain maps + Enumerable.Map -> + {:ok, output} + + ## Do not streamify proplists + Enumerable.List -> + case FormatterHelpers.proplist?(output) do + true -> {:ok, output} + false -> {:stream, output} + end + + _ -> + {:stream, output} + end + end + + defp format_output({:stream, stream}) do + {:stream, stream} + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/alarms_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/alarms_command.ex new file mode 100644 index 0000000000..7669a523eb --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/alarms_command.ex @@ -0,0 +1,77 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.AlarmsCommand do + @moduledoc """ + Displays all alarms reported by the target node. + + Returns a code of 0 unless there were connectivity and authentication + errors. This command is not meant to be used in health checks. + """ + import RabbitMQ.CLI.Core.Platform, only: [line_separator: 0] + import RabbitMQ.CLI.Core.Alarms + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + # Example response when there are alarms: + # + # [ + # file_descriptor_limit, + # {{resource_limit,disk,hare@warp10},[]}, + # {{resource_limit,memory,hare@warp10},[]}, + # {{resource_limit,disk,rabbit@warp10},[]}, + # {{resource_limit,memory,rabbit@warp10},[]} + # ] + # + # The topmost file_descriptor_limit alarm is node-local. + :rabbit_misc.rpc_call(node_name, :rabbit_alarm, :get_alarms, [], timeout) + end + + def output([], %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => "ok", "node" => node_name, "alarms" => []}} + end + + def output([], %{node: node_name}) do + {:ok, "Node #{node_name} reported no alarms, local or clusterwide"} + end + + def output(alarms, %{node: node_name, formatter: "json"}) do + local = local_alarms(alarms, node_name) + global = clusterwide_alarms(alarms, node_name) + + {:ok, + %{ + "result" => "ok", + "local" => alarm_lines(local, node_name), + "global" => alarm_lines(global, node_name), + "message" => "Node #{node_name} reported alarms" + }} + end + + def output(alarms, %{node: node_name}) do + lines = alarm_lines(alarms, node_name) + + {:ok, Enum.join(lines, line_separator())} + end + + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Lists resource alarms (local or cluster-wide) in effect on the target node" + + def usage, do: "alarms" + + def banner([], %{node: node_name}) do + "Asking node #{node_name} to report any known resource alarms ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/certificates_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/certificates_command.ex new file mode 100644 index 0000000000..33320d8e37 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/certificates_command.ex @@ -0,0 +1,55 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.CertificatesCommand do + alias RabbitMQ.CLI.Core.DocGuide + @behaviour RabbitMQ.CLI.CommandBehaviour + + import RabbitMQ.CLI.Core.Listeners + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_networking, :active_listeners, [], timeout) do + {:error, _} = err -> + err + + {:error, _, _} = err -> + err + + xs when is_list(xs) -> + listeners = listeners_with_certificates(listeners_on(xs, node_name)) + + case listeners do + [] -> %{} + _ -> Enum.map(listeners, &listener_certs/1) + end + + other -> + other + end + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Erlang + + def usage, do: "certificates" + + def usage_doc_guides() do + [ + DocGuide.configuration(), + DocGuide.tls() + ] + end + + def help_section(), do: :configuration + + def description(), do: "Displays certificates (public keys) for every listener on target node that is configured to use TLS" + + def banner(_, %{node: node_name}), do: "Certificates of node #{node_name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_alarms_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_alarms_command.ex new file mode 100644 index 0000000000..04bb70317a --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_alarms_command.ex @@ -0,0 +1,86 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.CheckAlarmsCommand do + @moduledoc """ + Exits with a non-zero code if the target node reports any alarms, + local or clusterwide. + + This command is meant to be used in health checks. + """ + + import RabbitMQ.CLI.Core.Alarms + import RabbitMQ.CLI.Core.Platform, only: [line_separator: 0] + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + # Example response when there are alarms: + # + # [ + # file_descriptor_limit, + # {{resource_limit,disk,hare@warp10},[]}, + # {{resource_limit,memory,hare@warp10},[]}, + # {{resource_limit,disk,rabbit@warp10},[]}, + # {{resource_limit,memory,rabbit@warp10},[]} + # ] + # + # The topmost file_descriptor_limit alarm is node-local. + :rabbit_misc.rpc_call(node_name, :rabbit_alarm, :get_alarms, [], timeout) + end + + def output([], %{formatter: "json"}) do + {:ok, %{"result" => "ok"}} + end + + def output([], %{silent: true}) do + {:ok, :check_passed} + end + + def output([], %{node: node_name}) do + {:ok, "Node #{node_name} reported no alarms, local or clusterwide"} + end + + def output(alarms, %{node: node_name, formatter: "json"}) do + local = local_alarms(alarms, node_name) + global = clusterwide_alarms(alarms, node_name) + + {:error, :check_failed, + %{ + "result" => "error", + "local" => alarm_lines(local, node_name), + "global" => alarm_lines(global, node_name), + "message" => "Node #{node_name} reported alarms" + }} + end + + def output(alarms, %{silent: true} = _opts) when is_list(alarms) do + {:error, :check_failed} + end + + def output(alarms, %{node: node_name}) when is_list(alarms) do + lines = alarm_lines(alarms, node_name) + + {:error, :check_failed, Enum.join(lines, line_separator())} + end + + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Health check that exits with a non-zero code if the target node reports any alarms, local or cluster-wide." + + def usage, do: "check_alarms" + + def banner([], %{node: node_name}) do + "Asking node #{node_name} to report any local resource alarms ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_certificate_expiration_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_certificate_expiration_command.ex new file mode 100644 index 0000000000..d14ade59f6 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_certificate_expiration_command.ex @@ -0,0 +1,101 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.CheckCertificateExpirationCommand do + alias RabbitMQ.CLI.Core.DocGuide + alias RabbitMQ.CLI.TimeUnit, as: TU + @behaviour RabbitMQ.CLI.CommandBehaviour + + import RabbitMQ.CLI.Core.Listeners + + def switches(), do: [unit: :string, within: :integer] + + def merge_defaults(args, opts) do + {args, Map.merge(%{unit: "weeks", within: 4}, opts)} + end + + def validate(args, _) when length(args) > 0 do + {:validation_failure, :too_many_args} + end + def validate(_, %{unit: unit}) do + case TU.known_unit?(unit) do + true -> + :ok + + false -> + {:validation_failure, "unit '#{unit}' is not supported. Please use one of: days, weeks, months, years"} + end + end + def validate(_, _), do: :ok + + def run([], %{node: node_name, unit: unit, within: within, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_networking, :active_listeners, [], timeout) do + {:error, _} = err -> + err + + {:error, _, _} = err -> + err + + {:badrpc, _} = err -> + err + + xs when is_list(xs) -> + listeners = listeners_on(xs, node_name) + seconds = TU.convert(within, unit) + Enum.reduce(listeners, [], fn (listener, acc) -> case listener_expiring_within(listener, seconds) do + false -> acc + expiring -> [expiring | acc] + end + end) + end + end + + def output([], %{formatter: "json"}) do + {:ok, %{"result" => "ok"}} + end + + def output([], %{unit: unit, within: within}) do + unit_label = unit_label(within, unit) + {:ok, "No certificates are expiring within #{within} #{unit_label}."} + end + + def output(listeners, %{formatter: "json"}) do + {:error, :check_failed, %{"result" => "error", "expired" => Enum.map(listeners, &expired_listener_map/1)}} + end + + def output(listeners, %{}) do + {:error, :check_failed, Enum.map(listeners, &expired_listener_map/1)} + end + + def unit_label(1, unit) do + unit |> String.slice(0..-2) + end + def unit_label(_within, unit) do + unit + end + + def usage, do: "check_certificate_expiration [--within <period>] [--unit <unit>]" + + def usage_additional() do + [ + ["<period>", "period of time to check. Default is four (weeks)."], + ["<unit>", "time unit for the period, can be days, weeks, months, years. Default is weeks."], + ] + end + + def usage_doc_guides() do + [ + DocGuide.tls(), + DocGuide.networking() + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Checks the expiration date on the certificates for every listener configured to use TLS" + + def banner(_, %{node: node_name}), do: "Checking certificate expiration on node #{node_name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_local_alarms_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_local_alarms_command.ex new file mode 100644 index 0000000000..1b11537793 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_local_alarms_command.ex @@ -0,0 +1,85 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.CheckLocalAlarmsCommand do + @moduledoc """ + Exits with a non-zero code if the target node reports any local alarms. + + This command is meant to be used in health checks. + """ + + import RabbitMQ.CLI.Core.Alarms + import RabbitMQ.CLI.Core.Platform, only: [line_separator: 0] + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + # Example response when there are alarms: + # + # [ + # file_descriptor_limit, + # {{resource_limit,disk,hare@warp10},[]}, + # {{resource_limit,memory,hare@warp10},[]}, + # {{resource_limit,disk,rabbit@warp10},[]}, + # {{resource_limit,memory,rabbit@warp10},[]} + # ] + # + # The topmost file_descriptor_limit alarm is node-local. + case :rabbit_misc.rpc_call(node_name, :rabbit_alarm, :get_alarms, [], timeout) do + [] -> [] + xs when is_list(xs) -> local_alarms(xs, node_name) + other -> other + end + end + + def output([], %{formatter: "json"}) do + {:ok, %{"result" => "ok"}} + end + + def output([], %{silent: true}) do + {:ok, :check_passed} + end + + def output([], %{node: node_name}) do + {:ok, "Node #{node_name} reported no local alarms"} + end + + def output(alarms, %{node: node_name, formatter: "json"}) do + {:error, :check_failed, + %{ + "result" => "error", + "local" => alarm_lines(alarms, node_name), + "message" => "Node #{node_name} reported local alarms" + }} + end + + def output(_alarms, %{silent: true}) do + {:error, :check_failed} + end + + def output(alarms, %{node: node_name}) do + lines = alarm_lines(alarms, node_name) + + {:error, Enum.join(lines, line_separator())} + end + + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Health check that exits with a non-zero code if the target node reports any local alarms" + + def usage, do: "check_local_alarms" + + def banner([], %{node: node_name}) do + "Asking node #{node_name} to report any local resource alarms ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_port_connectivity_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_port_connectivity_command.ex new file mode 100644 index 0000000000..1c3d86ed83 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_port_connectivity_command.ex @@ -0,0 +1,119 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.CheckPortConnectivityCommand do + @moduledoc """ + Checks all listeners on the target node by opening a TCP connection to each + and immediately closing it. + + Returns a code of 0 unless there were connectivity and authentication + errors. This command is meant to be used in health checks. + """ + + import RabbitMQ.CLI.Diagnostics.Helpers, + only: [check_listener_connectivity: 3] + import RabbitMQ.CLI.Core.Platform, only: [line_separator: 0] + import RabbitMQ.CLI.Core.Listeners + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @default_timeout 30_000 + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + def merge_defaults(args, opts) do + timeout = + case opts[:timeout] do + nil -> @default_timeout + :infinity -> @default_timeout + other -> other + end + + {args, Map.merge(opts, %{timeout: timeout})} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_networking, :active_listeners, [], timeout) do + {:error, _} = err -> + err + + {:error, _, _} = err -> + err + + xs when is_list(xs) -> + locals = listeners_on(xs, node_name) + + case locals do + [] -> {true, locals} + _ -> check_connectivity_of(locals, node_name, timeout) + end + + other -> + other + end + end + + def output({true, listeners}, %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => "ok", "node" => node_name, "listeners" => listener_maps(listeners)}} + end + + def output({true, listeners}, %{node: node_name}) do + ports = + listeners + |> listener_maps + |> Enum.map(fn %{port: p} -> p end) + |> Enum.sort() + |> Enum.join(", ") + + {:ok, "Successfully connected to ports #{ports} on node #{node_name}."} + end + + def output({false, failures}, %{formatter: "json", node: node_name}) do + {:error, %{"result" => "error", "node" => node_name, "failures" => listener_maps(failures)}} + end + + def output({false, failures}, %{node: node_name}) do + lines = [ + "Connection to ports of the following listeners on node #{node_name} failed: " + | listener_lines(failures) + ] + + {:error, Enum.join(lines, line_separator())} + end + + def description(), do: "Basic TCP connectivity health check for each listener's port on the target node" + + def help_section(), do: :observability_and_health_checks + + def usage, do: "check_port_connectivity" + + def banner([], %{node: node_name}) do + "Testing TCP connections to all active listeners on node #{node_name} ..." + end + + # + # Implementation + # + + defp check_connectivity_of(listeners, node_name, timeout) do + # per listener timeout + t = Kernel.trunc(timeout / (length(listeners) + 1)) + + failures = + Enum.reject( + listeners, + fn l -> check_listener_connectivity(listener_map(l), node_name, t) end + ) + + case failures do + [] -> {true, listeners} + fs -> {false, fs} + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_port_listener_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_port_listener_command.ex new file mode 100644 index 0000000000..f321d444db --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_port_listener_command.ex @@ -0,0 +1,82 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.CheckPortListenerCommand do + @moduledoc """ + Exits with a non-zero code if there is no active listener + for the given port on the target node. + + This command is meant to be used in health checks. + """ + + import RabbitMQ.CLI.Core.Listeners, only: [listeners_on: 2, listener_maps: 1] + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsOnePositiveIntegerArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([port], %{node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_networking, :active_listeners, [], timeout) do + {:error, _} = err -> + err + + {:error, _, _} = err -> + err + + xs when is_list(xs) -> + locals = listeners_on(xs, node_name) |> listener_maps + + found = + Enum.any?(locals, fn %{port: p} -> + to_string(port) == to_string(p) + end) + + case found do + true -> {true, port} + false -> {false, port, locals} + end + + other -> + other + end + end + + def output({true, port}, %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => "ok", "node" => node_name, "port" => port}} + end + + def output({true, port}, %{node: node_name}) do + {:ok, "A listener for port #{port} is running on node #{node_name}."} + end + + def output({false, port, listeners}, %{formatter: "json"}) do + ports = Enum.map(listeners, fn %{port: p} -> p end) + + {:error, :check_failed, + %{"result" => "error", "missing" => port, "ports" => ports, "listeners" => listeners}} + end + + def output({false, port, listeners}, %{node: node_name}) do + ports = Enum.map(listeners, fn %{port: p} -> p end) |> Enum.sort() |> Enum.join(", ") + + {:error, :check_failed, + "No listener for port #{port} is active on node #{node_name}. " <> + "Found listeners that use the following ports: #{ports}"} + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Health check that exits with a non-zero code if target node does not have an active listener for given port" + + def usage, do: "check_port_listener <port>" + + def banner([port], %{node: node_name}) do + "Asking node #{node_name} if there's an active listener on port #{port} ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_protocol_listener_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_protocol_listener_command.ex new file mode 100644 index 0000000000..10c81c971e --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_protocol_listener_command.ex @@ -0,0 +1,90 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.CheckProtocolListenerCommand do + @moduledoc """ + Exits with a non-zero code if there is no active listener + for the given protocol on the target node. + + This command is meant to be used in health checks. + """ + + import RabbitMQ.CLI.Core.Listeners, + only: [listeners_on: 2, listener_maps: 1, normalize_protocol: 1] + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([proto], %{node: node_name, timeout: timeout}) do + proto = normalize_protocol(proto) + + case :rabbit_misc.rpc_call(node_name, :rabbit_networking, :active_listeners, [], timeout) do + {:error, _} = err -> + err + + {:error, _, _} = err -> + err + + xs when is_list(xs) -> + locals = listeners_on(xs, node_name) |> listener_maps + + found = + Enum.any?(locals, fn %{protocol: p} -> + to_string(proto) == to_string(p) + end) + + case found do + true -> {true, proto} + false -> {false, proto, locals} + end + + other -> + other + end + end + + def output({true, proto}, %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => "ok", "node" => node_name, "protocol" => proto}} + end + + def output({true, proto}, %{node: node_name}) do + {:ok, "A listener for protocol #{proto} is running on node #{node_name}."} + end + + def output({false, proto, listeners}, %{formatter: "json"}) do + protocols = Enum.map(listeners, fn %{protocol: p} -> p end) + + {:error, + %{ + "result" => "error", + "missing" => proto, + "protocols" => protocols, + "listeners" => listeners + }} + end + + def output({false, proto, listeners}, %{node: node_name}) do + protocols = Enum.map(listeners, fn %{protocol: p} -> p end) |> Enum.sort() |> Enum.join(", ") + + {:error, + "No listener for protocol #{proto} is active on node #{node_name}. " <> + "Found listeners for the following protocols: #{protocols}"} + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Health check that exits with a non-zero code if target node does not have an active listener for given protocol" + + def usage, do: "check_protocol_listener <protocol>" + + def banner([proto], %{node: node_name}) do + "Asking node #{node_name} if there's an active listener for protocol #{proto} ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_running_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_running_command.ex new file mode 100644 index 0000000000..690f17e1e7 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_running_command.ex @@ -0,0 +1,46 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.CheckRunningCommand do + @moduledoc """ + Exits with a non-zero code if the RabbitMQ app on the target node is not running. + + This command is meant to be used in health checks. + """ + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout}) do + # Note: we use is_booted/1 over is_running/1 to avoid + # returning a positive result when the node is still booting + :rabbit_misc.rpc_call(node_name, :rabbit, :is_booted, [node_name], timeout) + end + + def output(true, %{node: node_name} = _options) do + {:ok, "RabbitMQ on node #{node_name} is fully booted and running"} + end + + def output(false, %{node: node_name} = _options) do + {:error, + "RabbitMQ on node #{node_name} is not running or has not fully booted yet (check with is_booting)"} + end + + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Health check that exits with a non-zero code if the RabbitMQ app on the target node is not running" + + def usage, do: "check_running" + + def banner([], %{node: node_name}) do + "Checking if RabbitMQ is running on node #{node_name} ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_virtual_hosts_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_virtual_hosts_command.ex new file mode 100644 index 0000000000..b3169b522d --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/check_virtual_hosts_command.ex @@ -0,0 +1,71 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.CheckVirtualHostsCommand do + @moduledoc """ + Exits with a non-zero code if the target node reports any vhost down. + + This command is meant to be used in health checks. + """ + + import RabbitMQ.CLI.Core.Platform, only: [line_separator: 0] + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit_vhost_sup_sup, :check, [], timeout) + end + + def output([], %{formatter: "json"}) do + {:ok, %{"result" => "ok"}} + end + + def output([], %{silent: true}) do + {:ok, :check_passed} + end + + def output([], %{formatter: "erlang"}) do + {:ok, :check_passed} + end + + def output([], %{node: node_name}) do + {:ok, "Node #{node_name} reported all vhosts as running"} + end + + def output(vhosts, %{formatter: "erlang"} = _opts) when is_list(vhosts) do + {:error, :check_failed, {:down_vhosts, vhosts}} + end + + def output(vhosts, %{formatter: "json"} = _opts) when is_list(vhosts) do + {:error, :check_failed, %{"result" => "error", "down_vhosts" => vhosts}} + end + + def output(vhosts, %{silent: true} = _opts) when is_list(vhosts) do + {:error, :check_failed} + end + + def output(vhosts, %{node: node_name}) when is_list(vhosts) do + lines = Enum.join(vhosts, line_separator()) + {:error, "Some virtual hosts on node #{node_name} are down:\n#{lines}"} + end + + use RabbitMQ.CLI.DefaultOutput + + def description(), do: "Health check that checks if all vhosts are running in the target node" + + def help_section(), do: :observability_and_health_checks + + def usage, do: "check_virtual_hosts" + + def banner([], %{node: node_name}) do + "Checking if all vhosts are running on node #{node_name} ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/cipher_suites_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/cipher_suites_command.ex new file mode 100644 index 0000000000..86e8eee3a4 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/cipher_suites_command.ex @@ -0,0 +1,122 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.CipherSuitesCommand do + alias RabbitMQ.CLI.Core.Helpers + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, Map.merge(%{all: false, format: "openssl"}, Helpers.case_insensitive_format(opts))} + end + + def switches(), do: [timeout: :integer, + format: :string, + all: :boolean] + def aliases(), do: [t: :timeout] + + def validate(_, %{format: format}) + when format != "openssl" and format != "erlang" and format != "map" do + {:validation_failure, {:bad_argument, "Format should be either openssl, erlang or map"}} + end + def validate(args, _) when length(args) > 0 do + {:validation_failure, :too_many_args} + end + + def validate(_, _), do: :ok + + def run([], %{node: node_name, timeout: timeout, format: format} = opts) do + {mod, function} = case format do + "openssl" -> {:rabbit_ssl, :cipher_suites_openssl}; + "erlang" -> {:rabbit_ssl, :cipher_suites_erlang}; + "map" -> {:rabbit_ssl, :cipher_suites} + end + args = case opts do + %{all: true} -> [:all]; + %{} -> [:default] + end + :rabbit_misc.rpc_call(node_name, mod, function, args, timeout) + end + + use RabbitMQ.CLI.DefaultOutput + + def banner([], %{format: "openssl"}), do: "Listing available cipher suites in OpenSSL format" + def banner([], %{format: "erlang"}), do: "Listing available cipher suites in Erlang term format" + def banner([], %{format: "map"}), do: "Listing available cipher suites in map format" + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Lists cipher suites enabled by default. To list all available cipher suites, add the --all argument." + + def usage, do: "cipher_suites [--format <openssl | erlang | map>] [--all]" + + def usage_additional() do + [ + ["--format", "output format to use: openssl, erlang or map"], + ["--all", "list all available suites"] + ] + end + + defmodule Formatter do + alias RabbitMQ.CLI.Formatters.FormatterHelpers + + @behaviour RabbitMQ.CLI.FormatterBehaviour + + def format_output(item, %{format: "erlang"}) do + to_string(:io_lib.format("~p", [item])) + end + + def format_output(item, %{format: "map"}) do + to_string(:io_lib.format("~p", [item])) + end + + def format_output(item, %{format: "openssl"} = opts) do + RabbitMQ.CLI.Formatters.String.format_output(item, opts) + end + + def format_stream(stream, %{format: "erlang"} = opts) do + comma_separated(stream, opts) + end + + def format_stream(stream, %{format: "map"} = opts) do + comma_separated(stream, opts) + end + + def format_stream(stream, %{format: "openssl"} = opts) do + Stream.map( + stream, + FormatterHelpers.without_errors_1(fn el -> + format_output(el, opts) + end) + ) + end + + defp comma_separated(stream, opts) do + elements = + Stream.scan( + stream, + :empty, + FormatterHelpers.without_errors_2(fn element, previous -> + separator = + case previous do + :empty -> "" + _ -> "," + end + + format_element(element, separator, opts) + end) + ) + + Stream.concat([["["], elements, ["]"]]) + end + + defp format_element(val, separator, opts) do + separator <> format_output(val, opts) + end + end + + def formatter(), do: Formatter +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/command_line_arguments_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/command_line_arguments_command.ex new file mode 100644 index 0000000000..adbf14cfc3 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/command_line_arguments_command.ex @@ -0,0 +1,41 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.CommandLineArgumentsCommand do + alias RabbitMQ.CLI.Core.DocGuide + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:diagnostics] + + use RabbitMQ.CLI.Core.MergesNoDefaults + + def validate(_, %{formatter: "json"}) do + {:validation_failure, :unsupported_formatter} + end + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :init, :get_arguments, []) + end + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Erlang + + def usage, do: "command_line_arguments" + + def usage_doc_guides() do + [ + DocGuide.configuration(), + DocGuide.monitoring() + ] + end + + def help_section(), do: :configuration + + def description(), do: "Displays target node's command-line arguments and flags as reported by the runtime" + + def banner(_, %{node: node_name}), do: "Command line arguments of node #{node_name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/consume_event_stream_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/consume_event_stream_command.ex new file mode 100644 index 0000000000..e7ad171d11 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/consume_event_stream_command.ex @@ -0,0 +1,71 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2019-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.ConsumeEventStreamCommand do + @moduledoc """ + Displays standard log file location on the target node + """ + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches(), do: [duration: :integer, pattern: :string, timeout: :integer] + def aliases(), do: [d: :duration, t: :timeout] + + def merge_defaults(args, opts) do + {args, Map.merge(%{duration: :infinity, pattern: ".*", quiet: true}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout, duration: duration, pattern: pattern}) do + pid = self() + ref = make_ref() + subscribed = :rabbit_misc.rpc_call( + node_name, + :rabbit_event_consumer, :register, + [pid, ref, duration, pattern], + timeout) + case subscribed do + {:ok, ^ref} -> + Stream.unfold(:confinue, + fn(:finished) -> nil + (:confinue) -> + receive do + {^ref, data, :finished} -> + {data, :finished}; + {^ref, data, :confinue} -> + {data, :confinue} + end + end) + error -> error + end + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.JsonStream + + def printer(), do: RabbitMQ.CLI.Printers.StdIORaw + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Streams internal events from a running node. Output is jq-compatible." + + def usage, do: "consume_event_stream [--duration|-d <seconds>] [--pattern <pattern>]" + + def usage_additional() do + [ + ["<duration_in_seconds>", "duration in seconds to stream log. Defaults to infinity"], + ["<pattern>", "regular expression to pick events"] + ] + end + + def banner([], %{node: node_name, duration: :infinity}) do + "Streaming logs from node #{node_name} ..." + end + def banner([], %{node: node_name, duration: duration}) do + "Streaming logs from node #{node_name} for #{duration} seconds ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/disable_auth_attempt_source_tracking_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/disable_auth_attempt_source_tracking_command.ex new file mode 100644 index 0000000000..df182a0c97 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/disable_auth_attempt_source_tracking_command.ex @@ -0,0 +1,35 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.DisableAuthAttemptSourceTrackingCommand do + alias RabbitMQ.CLI.Core.DocGuide + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :application, :set_env, + [:rabbit, :track_auth_attempt_source, :false]) + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "disable_track_auth_attempt_source" + + def usage_doc_guides() do + [ + DocGuide.access_control(), + DocGuide.monitoring() + ] + end + + def help_section(), do: :configuration + + def description(), do: "Disables the tracking of peer IP address and username of authentication attempts" + + def banner([], _), do: "Disabling authentication attempt source tracking ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/discover_peers_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/discover_peers_command.ex new file mode 100644 index 0000000000..b23a13e370 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/discover_peers_command.ex @@ -0,0 +1,36 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.DiscoverPeersCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit_peer_discovery, :discover_cluster_nodes, [], timeout) + end + + def output({:ok, {[], _}}, _options) do + {:ok, "No peers discovered"} + end + + def output({:ok, {nodes, _}}, _options) do + {:ok, nodes} + end + + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Performs peer discovery and lists discovered nodes, if any" + + def usage, do: "discover_peers" + + def banner(_, _), do: "Discovering peers nodes ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/enable_auth_attempt_source_tracking_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/enable_auth_attempt_source_tracking_command.ex new file mode 100644 index 0000000000..832891094b --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/enable_auth_attempt_source_tracking_command.ex @@ -0,0 +1,36 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.EnableAuthAttemptSourceTrackingCommand do + alias RabbitMQ.CLI.Core.DocGuide + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :application, :set_env, + [:rabbit, :track_auth_attempt_source, :true]) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "enable_auth_attempt_source_tracking" + + def usage_doc_guides() do + [ + DocGuide.access_control(), + DocGuide.monitoring() + ] + end + + def help_section(), do: :configuration + + def description(), do: "Enables the tracking of peer IP address and username of authentication attempts" + + def banner([], _), do: "Enabling authentication attempt source tracking ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/erlang_cookie_hash_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/erlang_cookie_hash_command.ex new file mode 100644 index 0000000000..b6e3186c94 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/erlang_cookie_hash_command.ex @@ -0,0 +1,35 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.ErlangCookieHashCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_data_coercion.to_binary( + :rabbit_misc.rpc_call(node_name, :rabbit_nodes_common, :cookie_hash, [], timeout)) + end + + def output(result, %{formatter: "json"}) do + {:ok, %{"result" => "ok", "value" => result}} + end + def output(result, _options) when is_bitstring(result) do + {:ok, result} + end + + def help_section(), do: :configuration + + def description(), do: "Displays a hash of the Erlang cookie (shared secret) used by the target node" + + def usage, do: "erlang_cookie_hash" + + def banner([], %{node: node_name}) do + "Asking node #{node_name} its Erlang cookie hash..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/erlang_cookie_sources_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/erlang_cookie_sources_command.ex new file mode 100644 index 0000000000..578ba31c73 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/erlang_cookie_sources_command.ex @@ -0,0 +1,116 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.ErlangCookieSourcesCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + + import RabbitMQ.CLI.Core.ANSI + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def distribution(_), do: :none + + def run([], opts) do + switch_cookie = opts[:erlang_cookie] + home_dir = get_home_dir() + cookie_file_path = Path.join(home_dir, ".erlang.cookie") + cookie_file_stat = case File.stat(Path.join(home_dir, ".erlang.cookie")) do + {:error, :enoent} -> nil + {:ok, value} -> value + end + cookie_file_type = case cookie_file_stat do + nil -> nil + value -> value.type + end + cookie_file_access = case cookie_file_stat do + nil -> nil + value -> value.access + end + cookie_file_size = case cookie_file_stat do + nil -> nil + value -> value.size + end + + %{ + os_env_cookie_set: System.get_env("RABBITMQ_ERLANG_COOKIE") != nil, + os_env_cookie_value_length: String.length(System.get_env("RABBITMQ_ERLANG_COOKIE") || ""), + switch_cookie_set: switch_cookie != nil, + switch_cookie_value_length: String.length(to_string(switch_cookie) || ""), + effective_user: System.get_env("USER"), + home_dir: home_dir, + cookie_file_path: cookie_file_path, + cookie_file_exists: File.exists?(cookie_file_path), + cookie_file_type: cookie_file_type, + cookie_file_access: cookie_file_access, + cookie_file_size: cookie_file_size + } + end + + def banner([], %{}), do: "Listing Erlang cookie sources used by CLI tools..." + + def output(result, %{formatter: "json"}) do + {:ok, result} + end + + def output(result, _opts) do + cookie_file_lines = [ + "#{bright("Cookie File")}\n", + "Effective user: #{result[:effective_user] || "(none)"}", + "Effective home directory: #{result[:home_dir] || "(none)"}", + "Cookie file path: #{result[:cookie_file_path]}", + "Cookie file exists? #{result[:cookie_file_exists]}", + "Cookie file type: #{result[:cookie_file_type] || "(n/a)"}", + "Cookie file access: #{result[:cookie_file_access] || "(n/a)"}", + "Cookie file size: #{result[:cookie_file_size] || "(n/a)"}", + ] + + switch_lines = [ + "\n#{bright("Cookie CLI Switch")}\n", + "--erlang-cookie value set? #{result[:switch_cookie_set]}", + "--erlang-cookie value length: #{result[:switch_cookie_value_length] || 0}" + ] + + os_env_lines = [ + "\n#{bright("Env variable ")} #{bright_red("(Deprecated)")}\n", + "RABBITMQ_ERLANG_COOKIE value set? #{result[:os_env_cookie_set]}", + "RABBITMQ_ERLANG_COOKIE value length: #{result[:os_env_cookie_value_length] || 0}" + ] + + lines = cookie_file_lines ++ switch_lines ++ os_env_lines + + {:ok, lines} + end + + def help_section(), do: :configuration + + def description() do + "Display Erlang cookie source (e.g. $HOME/.erlang.cookie file) information useful for troubleshooting" + end + + def usage, do: "erlang_cookie_sources" + + def formatter(), do: RabbitMQ.CLI.Formatters.StringPerLine + + # + # Implementation + # + + @doc """ + Computes HOME directory path the same way Erlang VM/ei does, + including taking Windows-specific env variables into account. + """ + def get_home_dir() do + homedrive = System.get_env("HOMEDRIVE") + homepath = System.get_env("HOMEPATH") + + case {homedrive != nil, homepath != nil} do + {true, true} -> "#{homedrive}#{homepath}" + _ -> System.get_env("HOME") + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/erlang_version_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/erlang_version_command.ex new file mode 100644 index 0000000000..053e0d142e --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/erlang_version_command.ex @@ -0,0 +1,72 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.ErlangVersionCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches() do + [details: :boolean, offline: :boolean, timeout: :integer] + end + def aliases(), do: [t: :timeout] + + def merge_defaults(args, opts) do + {args, Map.merge(%{details: false, offline: false}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{details: details, offline: true}) do + case details do + true -> + :rabbit_data_coercion.to_binary( + :rabbit_misc.otp_system_version()) + + false -> + :rabbit_data_coercion.to_binary( + :rabbit_misc.platform_and_version()) + end + end + def run([], %{node: node_name, timeout: timeout, details: details}) do + case details do + true -> + :rabbit_data_coercion.to_binary( + :rabbit_misc.rpc_call(node_name, :rabbit_misc, :otp_system_version, [], timeout)) + + false -> + :rabbit_data_coercion.to_binary( + :rabbit_misc.rpc_call(node_name, :rabbit_misc, :platform_and_version, [], timeout)) + end + end + + def output(result, %{formatter: "json"}) do + {:ok, %{"result" => "ok", "value" => result}} + end + def output(result, _opts) when is_bitstring(result) do + {:ok, result} + end + + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Displays Erlang/OTP version on the target node" + + def usage, do: "erlang_version" + + def usage_additional() do + [ + ["--details", "when set, display additional Erlang/OTP system information"], + ["--offline", "when set, displays local Erlang/OTP version (that used by CLI tools)"] + ] + end + + def banner([], %{offline: true}) do + "CLI Erlang/OTP version ..." + end + def banner([], %{node: node_name}) do + "Asking node #{node_name} for its Erlang/OTP version..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/is_booting_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/is_booting_command.ex new file mode 100644 index 0000000000..56b2253c90 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/is_booting_command.ex @@ -0,0 +1,53 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.IsBootingCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit, :is_booting, [node_name], timeout) + end + + def output(true, %{node: node_name, formatter: "json"}) do + m = %{ + "result" => true, + "message" => "RabbitMQ on node #{node_name} is booting" + } + {:ok, m} + end + + def output(false, %{node: node_name, formatter: "json"}) do + m = %{ + "result" => false, + "message" => "RabbitMQ on node #{node_name} is fully booted (check with is_running), stopped or has not started booting yet" + } + {:ok, m} + end + def output(true, %{node: node_name}) do + {:ok, "RabbitMQ on node #{node_name} is booting"} + end + + def output(false, %{node: node_name}) do + {:ok, + "RabbitMQ on node #{node_name} is fully booted (check with is_running), stopped or has not started booting yet"} + end + + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Checks if RabbitMQ is still booting on the target node" + + def usage, do: "is_booting" + + def banner([], %{node: node_name}) do + "Asking node #{node_name} for its boot status ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/is_running_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/is_running_command.ex new file mode 100644 index 0000000000..ecf5ce9368 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/is_running_command.ex @@ -0,0 +1,45 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.IsRunningCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout}) do + # Note: we use is_booted/1 over is_running/1 to avoid + # returning a positive result when the node is still booting + :rabbit_misc.rpc_call(node_name, :rabbit, :is_booted, [node_name], timeout) + end + + def output(true, %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => true, "message" => "RabbitMQ on node #{node_name} is fully booted and running"}} + end + def output(false, %{node: node_name, formatter: "json"}) do + {:ok, + %{"result" => false, "message" => "RabbitMQ on node #{node_name} is not running or has not fully booted yet (check with is_booting)"}} + end + def output(true, %{node: node_name}) do + {:ok, "RabbitMQ on node #{node_name} is fully booted and running"} + end + def output(false, %{node: node_name}) do + {:ok, + "RabbitMQ on node #{node_name} is not running or has not fully booted yet (check with is_booting)"} + end + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Checks if RabbitMQ is fully booted and running on the target node" + + def usage, do: "is_running" + + def banner([], %{node: node_name}) do + "Asking node #{node_name} for its status ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/list_network_interfaces_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/list_network_interfaces_command.ex new file mode 100644 index 0000000000..d41409b8c4 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/list_network_interfaces_command.ex @@ -0,0 +1,77 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.ListNetworkInterfacesCommand do + @moduledoc """ + Displays all network interfaces (NICs) reported by the target node. + """ + import RabbitMQ.CLI.Core.Platform, only: [line_separator: 0] + import RabbitMQ.CLI.Core.ANSI + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches(), do: [timeout: :integer, offline: :boolean] + def aliases(), do: [t: :timeout] + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{offline: true}) do + :rabbit_net.getifaddrs() + end + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit_net, :getifaddrs, [], timeout) + end + + def output(nic_map, %{node: node_name, formatter: "json"}) when map_size(nic_map) == 0 do + {:ok, %{"result" => "ok", "node" => node_name, "interfaces" => %{}}} + end + def output(nic_map, %{node: node_name}) when map_size(nic_map) == 0 do + {:ok, "Node #{node_name} reported no network interfaces"} + end + def output(nic_map0, %{node: node_name, formatter: "json"}) do + nic_map = Enum.map(nic_map0, fn ({k, v}) -> {to_string(k), v} end) + {:ok, + %{ + "result" => "ok", + "interfaces" => Enum.into(nic_map, %{}), + "message" => "Node #{node_name} reported network interfaces" + }} + end + def output(nic_map, _) when is_map(nic_map) do + lines = nic_lines(nic_map) + + {:ok, Enum.join(lines, line_separator())} + end + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Lists network interfaces (NICs) on the target node" + + def usage, do: "list_network_interfaces" + + def banner([], %{node: node_name}) do + "Asking node #{node_name} to report its network interfaces ..." + end + + # + # Implementation + # + + defp nic_lines(nic_map) do + Enum.reduce(nic_map, [], + fn({iface, props}, acc) -> + iface_lines = Enum.reduce(props, [], + fn({prop, val}, inner_acc) -> + ["#{prop}: #{val}" | inner_acc] + end) + + header = "#{bright("Interface #{iface}")}\n" + acc ++ [header | iface_lines] ++ ["\n"] + end) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/list_node_auth_attempt_stats_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/list_node_auth_attempt_stats_command.ex new file mode 100644 index 0000000000..4793cf6c46 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/list_node_auth_attempt_stats_command.ex @@ -0,0 +1,75 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.ListNodeAuthAttemptStatsCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def scopes(), do: [:ctl, :diagnostics] + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def switches(), do: [by_source: :boolean] + + def merge_defaults(args, opts) do + {args, Map.merge(%{by_source: false}, opts)} + end + + def validate([], _), do: :ok + def validate(_, _), do: {:validation_failure, :too_many_args} + + def run([], %{node: node_name, timeout: timeout, by_source: by_source}) do + case by_source do + :true -> + :rabbit_misc.rpc_call( + node_name, :rabbit_core_metrics, :get_auth_attempts_by_source, [], timeout) + :false -> + :rabbit_misc.rpc_call( + node_name, :rabbit_core_metrics, :get_auth_attempts, [], timeout) + end + end + + def output([], %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => "ok", "node" => node_name, "attempts" => []}} + end + def output([], %{node: node_name}) do + {:ok, "Node #{node_name} reported no authentication attempt stats"} + end + def output(rows, %{node: node_name, formatter: "json"}) do + maps = Enum.map(rows, &Map.new/1) + {:ok, + %{ + "result" => "ok", + "node" => node_name, + "attempts" => maps + }} + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "list_node_auth_attempts [--by-source]" + + def usage_additional do + [ + ["--by-source", "list authentication attempts by remote address and username"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.access_control(), + DocGuide.monitoring() + ] + end + + def help_section(), do: :observability_and_health_checks + def description(), do: "Lists authentication attempts on the target node" + + def banner([], %{node: node_name}), do: "Listing authentication + attempts for node \"#{node_name}\" ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/listeners_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/listeners_command.ex new file mode 100644 index 0000000000..f54ce3775e --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/listeners_command.ex @@ -0,0 +1,92 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.ListenersCommand do + @moduledoc """ + Displays all listeners on a node. + + Returns a code of 0 unless there were connectivity and authentication + errors. This command is not meant to be used in health checks. + """ + + import RabbitMQ.CLI.Core.Listeners, + only: [listeners_on: 2, listener_lines: 1, listener_maps: 1, listener_rows: 1] + + import RabbitMQ.CLI.Core.Platform, only: [line_separator: 0] + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + # Example listener list: + # + # [{listener,rabbit@warp10,clustering,"localhost", + # {0,0,0,0,0,0,0,0}, + # 25672,[]}, + # {listener,rabbit@warp10,amqp,"localhost", + # {0,0,0,0,0,0,0,0}, + # 5672, + # [{backlog,128}, + # {nodelay,true}, + # {linger,{true,0}}, + # {exit_on_close,false}]}, + # {listener,rabbit@warp10,stomp,"localhost", + # {0,0,0,0,0,0,0,0}, + # 61613, + # [{backlog,128},{nodelay,true}]}] + case :rabbit_misc.rpc_call(node_name, :rabbit_networking, :active_listeners, [], timeout) do + {:error, _} = err -> err + {:error, _, _} = err -> err + xs when is_list(xs) -> listeners_on(xs, node_name) + other -> other + end + end + + def output([], %{formatter: fmt}) when fmt == "csv" or fmt == "erlang" do + {:ok, []} + end + + def output([], %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => "ok", "node" => node_name, "listeners" => []}} + end + + def output([], %{node: node_name}) do + {:ok, "Node #{node_name} reported no enabled listeners."} + end + + def output(listeners, %{formatter: "erlang"}) do + {:ok, listener_rows(listeners)} + end + + def output(listeners, %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => "ok", "node" => node_name, "listeners" => listener_maps(listeners)}} + end + + def output(listeners, %{formatter: "csv"}) do + {:stream, [listener_rows(listeners)]} + end + + def output(listeners, _opts) do + lines = listener_lines(listeners) + + {:ok, Enum.join(lines, line_separator())} + end + + def help_section(), do: :observability_and_health_checks + + def description(), + do: "Lists active connection listeners (bound interface, port, protocol) on the target node" + + def usage, do: "listeners" + + def banner([], %{node: node_name}) do + "Asking node #{node_name} to report its protocol listeners ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/log_location_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/log_location_command.ex new file mode 100644 index 0000000000..36ff562b41 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/log_location_command.ex @@ -0,0 +1,56 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2019-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.LogLocationCommand do + @moduledoc """ + Displays standard log file location on the target node + """ + @behaviour RabbitMQ.CLI.CommandBehaviour + + alias RabbitMQ.CLI.Core.LogFiles + + def switches, do: [all: :boolean, timeout: :integer] + def aliases, do: [a: :all, t: :timeout] + + def merge_defaults(args, opts) do + {args, Map.merge(%{all: false}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout, all: all}) do + case all do + true -> LogFiles.get_log_locations(node_name, timeout); + false -> LogFiles.get_default_log_location(node_name, timeout) + end + end + + def output({:ok, location}, %{node: node_name, formatter: "json"}) do + {:ok, %{ + "result" => "ok", + "node_name" => node_name, + "paths" => [location] + }} + end + def output(locations, %{node: node_name, formatter: "json"}) do + {:ok, %{ + "result" => "ok", + "node_name" => node_name, + "paths" => locations + }} + end + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :configuration + + def description(), do: "Shows log file location(s) on target node" + + def usage, do: "log_location [--all|-a]" + + def banner([], %{node: node_name}) do + "Log file location(s) on node #{node_name} ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/log_tail_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/log_tail_command.ex new file mode 100644 index 0000000000..9717908f60 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/log_tail_command.ex @@ -0,0 +1,50 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2019-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.LogTailCommand do + @moduledoc """ + Displays standard log file location on the target node + """ + @behaviour RabbitMQ.CLI.CommandBehaviour + + alias RabbitMQ.CLI.Core.LogFiles + + def switches, do: [number: :integer, timeout: :integer] + def aliases, do: ['N': :number, t: :timeout] + + def merge_defaults(args, opts) do + {args, Map.merge(%{number: 50}, opts)} + end + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout, number: n}) do + case LogFiles.get_default_log_location(node_name, timeout) do + {:ok, file} -> + :rabbit_misc.rpc_call(node_name, + :rabbit_log_tail, :tail_n_lines, [file, n], + timeout) + error -> error + end + end + + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Prints the last N lines of the log on the node" + + def usage, do: "log_tail [--number|-N <number>]" + + def usage_additional do + [ + ["<number>", "number of lines to print. Defaults to 50"] + ] + end + + def banner([], %{node: node_name, number: n}) do + "Last #{n} log lines on node #{node_name} ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/log_tail_stream_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/log_tail_stream_command.ex new file mode 100644 index 0000000000..5080fd0d1d --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/log_tail_stream_command.ex @@ -0,0 +1,73 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2019-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.LogTailStreamCommand do + @moduledoc """ + Displays standard log file location on the target node + """ + @behaviour RabbitMQ.CLI.CommandBehaviour + + alias RabbitMQ.CLI.Core.LogFiles + + + def switches(), do: [duration: :integer, timeout: :integer] + def aliases(), do: [d: :duration, t: :timeout] + + def merge_defaults(args, opts) do + {args, Map.merge(%{duration: :infinity}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def printer(), do: RabbitMQ.CLI.Printers.StdIORaw + + def run([], %{node: node_name, timeout: timeout, duration: duration}) do + case LogFiles.get_default_log_location(node_name, timeout) do + {:ok, file} -> + pid = self() + ref = make_ref() + subscribed = :rabbit_misc.rpc_call( + node_name, + :rabbit_log_tail, :init_tail_stream, + [file, pid, ref, duration], + timeout) + case subscribed do + {:ok, ^ref} -> + Stream.unfold(:confinue, + fn(:finished) -> nil + (:confinue) -> + receive do + {^ref, data, :finished} -> {data, :finished}; + {^ref, data, :confinue} -> {data, :confinue} + end + end) + error -> error + end + error -> error + end + end + + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Streams logs from a running node for a period of time" + + def usage, do: "log_tail_stream [--duration|-d <seconds>]" + + def usage_additional() do + [ + ["<duration_in_seconds>", "duration in seconds to stream log. Defaults to infinity"] + ] + end + + def banner([], %{node: node_name, duration: :infinity}) do + "Streaming logs from node #{node_name} ..." + end + def banner([], %{node: node_name, duration: duration}) do + "Streaming logs from node #{node_name} for #{duration} seconds ..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/maybe_stuck_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/maybe_stuck_command.ex new file mode 100644 index 0000000000..c241780f62 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/maybe_stuck_command.ex @@ -0,0 +1,29 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.MaybeStuckCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit_diagnostics, :maybe_stuck, [], timeout) + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Detects Erlang processes (\"lightweight threads\") potentially not making progress on the target node" + + def usage, do: "maybe_stuck" + + def banner(_, %{node: node_name}) do + "Asking node #{node_name} to detect potentially stuck Erlang processes..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/memory_breakdown_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/memory_breakdown_command.ex new file mode 100644 index 0000000000..356358b7d7 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/memory_breakdown_command.ex @@ -0,0 +1,103 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.MemoryBreakdownCommand do + alias RabbitMQ.CLI.InformationUnit, as: IU + import RabbitMQ.CLI.Core.Memory + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches(), do: [unit: :string, timeout: :integer] + def aliases(), do: [t: :timeout] + + def merge_defaults(args, opts) do + {args, Map.merge(%{unit: "gb"}, opts)} + end + + def validate(args, _) when length(args) > 0 do + {:validation_failure, :too_many_args} + end + + def validate(_, %{unit: unit}) do + case IU.known_unit?(unit) do + true -> + :ok + + false -> + {:validation_failure, "unit '#{unit}' is not supported. Please use one of: bytes, mb, gb"} + end + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_misc.rpc_call(node_name, :rabbit_vm, :memory, [], timeout) + end + + def output(result, %{formatter: "json"} = _opts) do + {:ok, compute_relative_values(result)} + end + + def output(result, %{formatter: "csv"} = _opts) do + flattened = + compute_relative_values(result) + |> Enum.flat_map(fn {k, %{bytes: b, percentage: p}} -> + [{"#{k}.bytes", b}, {"#{k}.percentage", p}] + end) + |> Enum.sort_by(fn {key, _val} -> key end, &>=/2) + + headers = Enum.map(flattened, fn {k, _v} -> k end) + values = Enum.map(flattened, fn {_k, v} -> v end) + + {:stream, [headers, values]} + end + + def output(result, _opts) do + {:ok, compute_relative_values(result)} + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Provides a memory usage breakdown on the target node." + + def usage, do: "memory_breakdown [--unit <unit>]" + + def usage_additional() do + [ + ["--unit <bytes | mb | gb>", "byte multiple (bytes, megabytes, gigabytes) to use"], + ["--formatter <json | csv | erlang>", "alternative formatter to use, JSON, CSV or Erlang terms"] + ] + end + + def banner([], %{node: node_name}) do + "Reporting memory breakdown on node #{node_name}..." + end + + defmodule Formatter do + alias RabbitMQ.CLI.Formatters.FormatterHelpers + alias RabbitMQ.CLI.InformationUnit, as: IU + + @behaviour RabbitMQ.CLI.FormatterBehaviour + + def format_output(output, %{unit: unit}) do + Enum.reduce(output, "", fn {key, %{bytes: bytes, percentage: percentage}}, acc -> + u = String.downcase(unit) + acc <> "#{key}: #{IU.convert(bytes, u)} #{u} (#{percentage}%)\n" + end) + end + + def format_stream(stream, options) do + Stream.map( + stream, + FormatterHelpers.without_errors_1(fn el -> + format_output(el, options) + end) + ) + end + end + + def formatter(), do: Formatter +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/observer_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/observer_command.ex new file mode 100644 index 0000000000..717e23e6b5 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/observer_command.ex @@ -0,0 +1,48 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.ObserverCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def switches(), do: [interval: :integer] + def aliases(), do: [i: :interval] + + def merge_defaults(args, opts) do + {args, Map.merge(%{interval: 5}, opts)} + end + + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, interval: interval}) do + case :observer_cli.start(node_name, [{:interval, interval * 1000}]) do + # See zhongwencool/observer_cli#54 + {:badrpc, _} = err -> err + {:error, _} = err -> err + {:error, _, _} = err -> err + :ok -> {:ok, "Disconnected from #{node_name}."} + :quit -> {:ok, "Disconnected from #{node_name}."} + other -> other + end + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Starts a CLI observer interface on the target node" + + def usage, do: "observer [--interval <seconds>]" + + def usage_additional() do + [ + ["--interval <seconds>", "Update interval to use, in seconds"] + ] + end + + def banner(_, %{node: node_name}) do + "Starting a CLI observer interface on node #{node_name}..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/os_env_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/os_env_command.ex new file mode 100644 index 0000000000..63e8c18beb --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/os_env_command.ex @@ -0,0 +1,67 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.OsEnvCommand do + @moduledoc """ + Lists RabbitMQ-specific environment variables defined on target node + """ + + import RabbitMQ.CLI.Core.Platform, only: [line_separator: 0] + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:diagnostics] + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_env, :get_used_env_vars, [], timeout) do + {:error, _} = err -> err + {:error, _, _} = err -> err + xs when is_list(xs) -> + # convert keys and values to binaries (Elixir strings) + xs + |> Enum.map(fn {k, v} -> {:rabbit_data_coercion.to_binary(k), :rabbit_data_coercion.to_binary(v)} end) + |> :maps.from_list + other -> other + end + end + + def output([], %{formatter: fmt}) when fmt == "csv" or fmt == "erlang" do + {:ok, []} + end + def output([], %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => "ok", "node" => node_name, "variables" => []}} + end + def output([], %{node: node_name}) do + {:ok, "Node #{node_name} reported no relevant environment variables."} + end + def output(vars, %{node: node_name, formatter: "json"}) do + {:ok, %{"result" => "ok", "node" => node_name, "variables" => vars}} + end + def output(vars, %{formatter: "csv"}) do + {:stream, [Enum.map(vars, fn({k, v}) -> [variable: k, value: v] end)]} + end + def output(vars, _opts) do + lines = Enum.map(vars, fn({k, v}) -> "#{k}=#{v}" end) |> Enum.join(line_separator()) + {:ok, lines} + end + + def usage() do + "os_env" + end + + def help_section(), do: :configuration + + def description(), do: "Lists RabbitMQ-specific environment variables set on target node" + + def banner(_, %{node: node_name}) do + "Listing RabbitMQ-specific environment variables defined on node #{node_name}..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/reset_node_auth_attempt_metrics_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/reset_node_auth_attempt_metrics_command.ex new file mode 100644 index 0000000000..e3b08c2ac8 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/reset_node_auth_attempt_metrics_command.ex @@ -0,0 +1,37 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.ResetNodeAuthAttemptMetricsCommand do + alias RabbitMQ.CLI.Core.DocGuide + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit_core_metrics, :reset_auth_attempt_metrics, []) + end + + def usage, do: "reset_node_auth_attempt_metrics" + + def usage_doc_guides() do + [ + DocGuide.access_control(), + DocGuide.monitoring() + ] + end + + def help_section(), do: :configuration + + def description(), do: "Resets auth attempt metrics on the target node" + + def banner([], %{node: node_name}) do + "Reset auth attempt metrics on node #{node_name} ..." + end + + use RabbitMQ.CLI.DefaultOutput +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/resolve_hostname_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/resolve_hostname_command.ex new file mode 100644 index 0000000000..349dbee513 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/resolve_hostname_command.ex @@ -0,0 +1,94 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.ResolveHostnameCommand do + @moduledoc """ + Resolves a hostname to one or more addresses of a given IP address family (IPv4 ot IPv6). + This command is not meant to compete with `dig` but rather provide a way + to perform basic resolution tests that take Erlang's inetrc file into account. + """ + + import RabbitCommon.Records + alias RabbitMQ.CLI.Core.Networking + alias RabbitMQ.CLI.Core.ExitCodes + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:diagnostics] + + def switches(), do: [address_family: :string, offline: :boolean] + def aliases(), do: [a: :address_family] + + def merge_defaults(args, opts) do + {args, Map.merge(%{address_family: "IPv4", offline: false}, opts)} + end + + def validate(args, _) when length(args) < 1, do: {:validation_failure, :not_enough_args} + def validate(args, _) when length(args) > 1, do: {:validation_failure, :too_many_args} + def validate([_], %{address_family: family}) do + case Networking.valid_address_family?(family) do + true -> :ok + false -> {:validation_failure, {:bad_argument, "unsupported IP address family #{family}. Valid values are: ipv4, ipv6"}} + end + end + def validate([_], _), do: :ok + + def run([hostname], %{address_family: family, offline: true}) do + :inet.gethostbyname(to_charlist(hostname), Networking.address_family(family)) + end + def run([hostname], %{node: node_name, address_family: family, offline: false, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :inet, :gethostbyname, + [to_charlist(hostname), Networking.address_family(family)], timeout) do + {:error, _} = err -> err + {:error, _, _} = err -> err + {:ok, result} -> {:ok, result} + other -> other + end + end + + def output({:error, :nxdomain}, %{node: node_name, formatter: "json"}) do + m = %{ + "result" => "error", + "node" => node_name, + "message" => "Hostname does not resolve (resolution failed with an nxdomain)" + } + {:error, ExitCodes.exit_dataerr(), m} + end + def output({:error, :nxdomain}, _opts) do + {:error, ExitCodes.exit_dataerr(), "Hostname does not resolve (resolution failed with an nxdomain)"} + end + def output({:ok, result}, %{node: node_name, address_family: family, formatter: "json"}) do + hostname = hostent(result, :h_name) + addresses = hostent(result, :h_addr_list) + {:ok, %{ + "result" => "ok", + "node" => node_name, + "hostname" => to_string(hostname), + "address_family" => family, + "addresses" => Networking.format_addresses(addresses) + }} + end + def output({:ok, result}, _opts) do + addresses = hostent(result, :h_addr_list) + {:ok, Enum.join(Networking.format_addresses(addresses), "\n")} + end + use RabbitMQ.CLI.DefaultOutput + + def usage() do + "resolve_hostname <hostname> [--address-family <ipv4 | ipv6>]" + end + + def help_section(), do: :configuration + + def description(), do: "Resolves a hostname to a set of addresses. Takes Erlang's inetrc file into account." + + def banner([hostname], %{offline: false, node: node_name, address_family: family}) do + "Asking node #{node_name} to resolve hostname #{hostname} to #{family} addresses..." + end + def banner([hostname], %{offline: true, address_family: family}) do + "Resolving hostname #{hostname} to #{family} addresses..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/resolver_info_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/resolver_info_command.ex new file mode 100644 index 0000000000..a4f3d8d7d3 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/resolver_info_command.ex @@ -0,0 +1,84 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.ResolverInfoCommand do + @moduledoc """ + Displays effective hostname resolver (inetrc) configuration on target node + """ + + import RabbitMQ.CLI.Core.Platform, only: [line_separator: 0] + import RabbitMQ.CLI.Core.ANSI, only: [bright: 1] + alias RabbitMQ.CLI.Core.Networking + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def scopes(), do: [:diagnostics] + + def switches(), do: [offline: :boolean] + def aliases(), do: [] + + def merge_defaults(args, opts) do + {args, Map.merge(%{offline: false}, opts)} + end + + def validate(args, _) when length(args) > 0, do: {:validation_failure, :too_many_args} + def validate([], _), do: :ok + + def run([], %{offline: true}) do + Networking.inetrc_map(:inet.get_rc()) + end + def run([], %{node: node_name, timeout: timeout, offline: false}) do + case :rabbit_misc.rpc_call(node_name, :inet, :get_rc, [], timeout) do + {:error, _} = err -> err + {:error, _, _} = err -> err + xs when is_list(xs) -> Networking.inetrc_map(xs) + other -> other + end + end + + def output(info, %{node: node_name, formatter: "json"}) do + {:ok, %{ + "result" => "ok", + "node" => node_name, + "resolver" => info + }} + end + def output(info, _opts) do + main_section = [ + "#{bright("Runtime Hostname Resolver (inetrc) Settings")}\n", + "Lookup order: #{info["lookup"]}", + "Hosts file: #{info["hosts_file"]}", + "Resolver conf file: #{info["resolv_conf"]}", + "Cache size: #{info["cache_size"]}" + ] + hosts_section = [ + "\n#{bright("inetrc File Host Entries")}\n" + ] ++ case info["hosts"] do + [] -> ["(none)"] + nil -> ["(none)"] + hs -> Enum.reduce(hs, [], fn {k, v}, acc -> ["#{k} #{Enum.join(v, ", ")}" | acc] end) + end + + lines = main_section ++ hosts_section + + {:ok, Enum.join(lines, line_separator())} + end + + def usage() do + "resolver_info" + end + + def help_section(), do: :configuration + + def description(), do: "Displays effective hostname resolver (inetrc) configuration on target node" + + def banner(_, %{node: node_name, offline: false}) do + "Asking node #{node_name} for its effective hostname resolver (inetrc) configuration..." + end + def banner(_, %{offline: true}) do + "Displaying effective hostname resolver (inetrc) configuration used by CLI tools..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/runtime_thread_stats_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/runtime_thread_stats_command.ex new file mode 100644 index 0000000000..ee5bb56566 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/runtime_thread_stats_command.ex @@ -0,0 +1,70 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.RuntimeThreadStatsCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches(), do: [sample_interval: :integer] + def aliases(), do: [i: :sample_interval] + + def merge_defaults(args, opts) do + {args, Map.merge(%{sample_interval: 5}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout, sample_interval: interval}) do + case :rabbit_misc.rpc_call( + node_name, + :rabbit_runtime, + :msacc_stats, + [interval * 1000], + timeout + ) do + {:ok, stats} -> stats + other -> other + end + end + + def output(result, %{formatter: "json"}) when is_list(result) do + {:error, "JSON formatter is not supported by this command"} + end + + def output(result, %{formatter: "csv"}) when is_list(result) do + {:error, "CSV formatter is not supported by this command"} + end + + def output(result, _options) when is_list(result) do + {:ok, result} + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Provides a breakdown of runtime thread activity stats on the target node" + + def usage, do: "runtime_thread_stats [--sample-interval <interval>]" + + def usage_additional() do + [ + ["--sample-interval <seconds>", "sampling interval to use in seconds"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.runtime_tuning() + ] + end + + def banner([], %{node: node_name, sample_interval: interval}) do + "Will collect runtime thread stats on #{node_name} for #{interval} seconds..." + end + + def formatter(), do: RabbitMQ.CLI.Formatters.Msacc +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/schema_info_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/schema_info_command.ex new file mode 100644 index 0000000000..50b750c772 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/schema_info_command.ex @@ -0,0 +1,73 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.SchemaInfoCommand do + @moduledoc """ + Lists all tables on the mnesia schema + """ + + alias RabbitMQ.CLI.Ctl.InfoKeys + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @info_keys ~w(name snmp load_order active_replicas all_nodes attributes checkpoints disc_copies + disc_only_copies external_copies frag_properties master_nodes ram_copies + storage_properties subscribers user_properties cstruct local_content + where_to_commit where_to_read name access_mode cookie load_by_force + load_node record_name size storage_type type where_to_write index arity + majority memory commit_work where_to_wlock load_reason record_validation + version wild_pattern index_info)a + + def info_keys(), do: @info_keys + + def scopes(), do: [:ctl, :diagnostics] + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def merge_defaults([], opts) do + merge_defaults( + ~w(name cookie active_replicas user_properties), + opts + ) + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{table_headers: true}, opts)} + end + + def validate(args, _) do + case InfoKeys.validate_info_keys(args, @info_keys) do + {:ok, _} -> :ok + err -> err + end + end + + def run([_ | _] = args, %{node: node_name, timeout: timeout}) do + info_keys = InfoKeys.prepare_info_keys(args) + :rabbit_misc.rpc_call(node_name, :rabbit_mnesia, :schema_info, [info_keys], timeout) + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage() do + "schema_info [--no-table-headers] [<column> ...]" + end + + def usage_additional() do + [ + ["<column>", "must be one of " <> Enum.join(Enum.sort(@info_keys), ", ")] + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Lists schema database tables and their properties" + + def banner(_, %{node: node_name}), do: "Asking node #{node_name} to report its schema..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/server_version_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/server_version_command.ex new file mode 100644 index 0000000000..9f4068e459 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/server_version_command.ex @@ -0,0 +1,37 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.ServerVersionCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout}) do + :rabbit_data_coercion.to_binary( + :rabbit_misc.rpc_call(node_name, :rabbit_misc, :version, [], timeout)) + end + + def output(result, %{formatter: "json"}) do + {:ok, %{"result" => "ok", "value" => result}} + end + def output(result, _options) when is_bitstring(result) do + {:ok, result} + end + + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Displays server version on the target node" + + def usage, do: "server_version" + + def banner([], %{node: node_name}) do + "Asking node #{node_name} for its RabbitMQ version..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/tls_versions_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/tls_versions_command.ex new file mode 100644 index 0000000000..2f81bad889 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/commands/tls_versions_command.ex @@ -0,0 +1,39 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Commands.TlsVersionsCommand do + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout} = _opts) do + :rabbit_misc.rpc_call(node_name, :ssl, :versions, [], timeout) + end + + def banner([], %{}), do: "Listing all TLS versions supported by the runtime..." + + def output(result, %{formatter: "json"}) do + vs = Map.new(result) |> Map.get(:available) + + {:ok, %{versions: vs}} + end + + def output(result, _opts) do + vs = Map.new(result) |> Map.get(:available) + {:ok, vs} + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Lists TLS versions supported (but not necessarily allowed) on the target node" + + def usage, do: "tls_versions" + + def formatter(), do: RabbitMQ.CLI.Formatters.StringPerLine +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/diagnostics_helpers.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/diagnostics_helpers.ex new file mode 100644 index 0000000000..601cc842cb --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/diagnostics/diagnostics_helpers.ex @@ -0,0 +1,38 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Diagnostics.Helpers do + def test_connection(hostname, port, timeout) do + case :gen_tcp.connect(hostname, port, [], timeout) do + {:error, _} -> :gen_tcp.connect(hostname, port, [:inet6], timeout) + r -> r + end + end + + def check_port_connectivity(port, node_name, timeout) do + regex = Regex.recompile!(~r/^(.+)@/) + hostname = Regex.replace(regex, to_string(node_name), "") |> to_charlist + try do + case test_connection(hostname, port, timeout) do + {:error, _} -> + false + + {:ok, port} -> + :ok = :gen_tcp.close(port) + true + end + + # `gen_tcp:connect/4` will throw if the port is outside of its + # expected domain + catch + :exit, _ -> false + end + end + + def check_listener_connectivity(%{port: port}, node_name, timeout) do + check_port_connectivity(port, node_name, timeout) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatter_behaviour.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatter_behaviour.ex new file mode 100644 index 0000000000..498ba114b9 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatter_behaviour.ex @@ -0,0 +1,42 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Formats returned values e.g. to human-readable text or JSON. +defmodule RabbitMQ.CLI.FormatterBehaviour do + alias RabbitMQ.CLI.Core.Helpers + + @callback format_output(any, map()) :: String.t() | [String.t()] + @callback format_stream(Enumerable.t(), map()) :: Enumerable.t() + + @optional_callbacks switches: 0, + aliases: 0 + + @callback switches() :: Keyword.t() + @callback aliases() :: Keyword.t() + + def switches(formatter) do + Helpers.apply_if_exported(formatter, :switches, [], []) + end + + def aliases(formatter) do + Helpers.apply_if_exported(formatter, :aliases, [], []) + end + + def module_name(nil) do + nil + end + def module_name(formatter) do + mod = formatter |> String.downcase |> Macro.camelize + Module.safe_concat("RabbitMQ.CLI.Formatters", mod) + end + + def machine_readable?(nil) do + false + end + def machine_readable?(formatter) do + Helpers.apply_if_exported(module_name(formatter), :machine_readable?, [], false) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/csv.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/csv.ex new file mode 100644 index 0000000000..ab9acd613f --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/csv.ex @@ -0,0 +1,127 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +alias RabbitMQ.CLI.Formatters.FormatterHelpers + +defmodule RabbitMQ.CLI.Formatters.Csv do + @behaviour RabbitMQ.CLI.FormatterBehaviour + + def format_stream(stream, _) do + ## Flatten list_consumers + Stream.flat_map( + stream, + fn + [first | _] = element -> + case FormatterHelpers.proplist?(first) or is_map(first) do + true -> element + false -> [element] + end + + other -> + [other] + end + ) + ## Add info_items names + |> Stream.transform( + :init, + FormatterHelpers.without_errors_2(fn + element, :init -> + { + case keys(element) do + nil -> [values(element)] + ks -> [ks, values(element)] + end, + :next + } + + element, :next -> + {[values(element)], :next} + end) + ) + |> CSV.encode(delimiter: "") + end + + def format_output(output, _) do + case keys(output) do + nil -> [values(output)] + ks -> [ks, values(output)] + end + |> CSV.encode() + |> Enum.join() + end + + def machine_readable?, do: true + + # + # Implementation + # + + defp keys(map) when is_map(map) do + Map.keys(map) + end + + defp keys(list) when is_list(list) do + case FormatterHelpers.proplist?(list) do + true -> Keyword.keys(list) + false -> nil + end + end + + defp keys(_other) do + nil + end + + defp values(map) when is_map(map) do + Map.values(map) + end + + defp values([]) do + [] + end + + defp values(list) when is_list(list) do + case FormatterHelpers.proplist?(list) do + true -> Keyword.values(list) + false -> list + end + end + + defp values(other) do + other + end +end + +defimpl CSV.Encode, for: PID do + def encode(pid, env \\ []) do + FormatterHelpers.format_info_item(pid) + |> to_string + |> CSV.Encode.encode(env) + end +end + +defimpl CSV.Encode, for: List do + def encode(list, env \\ []) do + FormatterHelpers.format_info_item(list) + |> to_string + |> CSV.Encode.encode(env) + end +end + +defimpl CSV.Encode, for: Tuple do + def encode(tuple, env \\ []) do + FormatterHelpers.format_info_item(tuple) + |> to_string + |> CSV.Encode.encode(env) + end +end + +defimpl CSV.Encode, for: Map do + def encode(map, env \\ []) do + FormatterHelpers.format_info_item(map) + |> to_string + |> CSV.Encode.encode(env) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/erlang.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/erlang.ex new file mode 100644 index 0000000000..0a8a78249f --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/erlang.ex @@ -0,0 +1,18 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Formatters.Erlang do + @behaviour RabbitMQ.CLI.FormatterBehaviour + + def format_output(output, _) do + :io_lib.format("~p", [output]) + |> to_string + end + + def format_stream(stream, options) do + [format_output(Enum.to_list(stream), options)] + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/formatter_helpers.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/formatter_helpers.ex new file mode 100644 index 0000000000..2ec4edc3d9 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/formatter_helpers.ex @@ -0,0 +1,182 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Formatters.FormatterHelpers do + import RabbitCommon.Records + use Bitwise + + @type error :: {:error, term()} | {:error, integer(), String.t() | [String.t()]} + + @spec without_errors_1((el -> result)) :: error() | result when el: term(), result: term() + def without_errors_1(fun) do + fn + {:error, _} = err -> err + {:error, _, _} = err -> err + other -> fun.(other) + end + end + + @spec without_errors_1((el, acc -> result)) :: error() | result + when el: term(), result: term(), acc: term() + def without_errors_2(fun) do + fn + {:error, _} = err, _acc -> err + {:error, _, _} = err, _acc -> err + other, acc -> fun.(other, acc) + end + end + + def proplist?([{_key, _value} | rest]), do: proplist?(rest) + def proplist?([]), do: true + def proplist?(_other), do: false + + + defmacro is_u8(x) do + quote do + unquote(x) >= 0 and unquote(x) <= 255 + end + end + + defmacro is_u16(x) do + quote do + unquote(x) >= 0 and unquote(x) <= 65_535 + end + end + + def format_info_item(item, escaped \\ true) + + def format_info_item(map, escaped) when is_map(map) do + [ + "\#\{", + Enum.map( + map, + fn {k, v} -> + ["#{escape(k, escaped)} => ", format_info_item(v, escaped)] + end + ) + |> Enum.join(", "), + "}" + ] + end + + # when Record.is_record(res, :resource) do + def format_info_item(resource(name: name), escaped) do + # resource(name: name) = res + escape(name, escaped) + end + + def format_info_item({n1, n2, n3, n4} = value, _escaped) + when is_u8(n1) and is_u8(n2) and is_u8(n3) and is_u8(n4) do + :rabbit_misc.ntoa(value) + end + + def format_info_item({k1, k2, k3, k4, k5, k6, k7, k8} = value, _escaped) + when is_u16(k1) and is_u16(k2) and is_u16(k3) and is_u16(k4) and + is_u16(k5) and is_u16(k6) and is_u16(k7) and is_u16(k8) do + :rabbit_misc.ntoa(value) + end + + def format_info_item(value, _escaped) when is_pid(value) do + :rabbit_misc.pid_to_string(value) + end + + def format_info_item(value, escaped) when is_binary(value) do + escape(value, escaped) + end + + def format_info_item(value, escaped) when is_atom(value) do + escape(to_charlist(value), escaped) + end + + def format_info_item( + [{key, type, _table_entry_value} | _] = value, + escaped + ) + when is_binary(key) and + is_atom(type) do + :io_lib.format( + "~1000000000000tp", + [prettify_amqp_table(value, escaped)] + ) + end + + def format_info_item([t | _] = value, escaped) + when is_tuple(t) or is_pid(t) or is_binary(t) or is_atom(t) or is_list(t) do + [ + "[", + Enum.map( + value, + fn el -> + format_info_item(el, escaped) + end + ) + |> Enum.join(", "), + "]" + ] + end + + def format_info_item({key, value}, escaped) do + ["{", :io_lib.format("~p", [key]), ", ", format_info_item(value, escaped), "}"] + end + + def format_info_item(value, _escaped) do + :io_lib.format("~1000000000000tp", [value]) + end + + defp prettify_amqp_table(table, escaped) do + for {k, t, v} <- table do + {escape(k, escaped), prettify_typed_amqp_value(t, v, escaped)} + end + end + + defp prettify_typed_amqp_value(:longstr, value, escaped) do + escape(value, escaped) + end + + defp prettify_typed_amqp_value(:table, value, escaped) do + prettify_amqp_table(value, escaped) + end + + defp prettify_typed_amqp_value(:array, value, escaped) do + for {t, v} <- value, do: prettify_typed_amqp_value(t, v, escaped) + end + + defp prettify_typed_amqp_value(_type, value, _escaped) do + value + end + + defp escape(atom, escaped) when is_atom(atom) do + escape(to_charlist(atom), escaped) + end + + defp escape(bin, escaped) when is_binary(bin) do + escape(to_charlist(bin), escaped) + end + + defp escape(l, false) when is_list(l) do + escape_char(:lists.reverse(l), []) + end + + defp escape(l, true) when is_list(l) do + l + end + + defp escape_char([?\\ | t], acc) do + escape_char(t, [?\\, ?\\ | acc]) + end + + defp escape_char([x | t], acc) when x >= 32 and x != 127 do + escape_char(t, [x | acc]) + end + + defp escape_char([x | t], acc) do + escape_char(t, [?\\, ?0 + (x >>> 6), ?0 + (x &&& 0o070 >>> 3), ?0 + (x &&& 7) | acc]) + end + + defp escape_char([], acc) do + acc + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/inspect.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/inspect.ex new file mode 100644 index 0000000000..5939007cfe --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/inspect.ex @@ -0,0 +1,40 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. +alias RabbitMQ.CLI.Formatters.FormatterHelpers + +defmodule RabbitMQ.CLI.Formatters.Inspect do + @behaviour RabbitMQ.CLI.FormatterBehaviour + + def format_output(output, _) do + case is_binary(output) do + true -> output + false -> inspect(output) + end + end + + def format_stream(stream, options) do + elements = + Stream.scan( + stream, + :empty, + FormatterHelpers.without_errors_2(fn element, previous -> + separator = + case previous do + :empty -> "" + _ -> "," + end + + format_element(element, separator, options) + end) + ) + + Stream.concat([["["], elements, ["]"]]) + end + + def format_element(val, separator, options) do + separator <> format_output(val, options) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/json.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/json.ex new file mode 100644 index 0000000000..eb55038715 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/json.ex @@ -0,0 +1,69 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Basic JSON formatter. Supports 1-level of +# collection using start/finish_collection. +# Primary purpose is to translate stream from CTL, +# so there is no need for multiple collection levels +alias RabbitMQ.CLI.Formatters.FormatterHelpers + +defmodule RabbitMQ.CLI.Formatters.Json do + @behaviour RabbitMQ.CLI.FormatterBehaviour + + def format_output(output, opts) when is_bitstring(output) do + format_output(%{"message" => output}, opts) + end + def format_output(output, _opts) do + {:ok, json} = JSON.encode(keys_to_atoms(output)) + json + end + + def format_stream(stream, options) do + ## Flatten list_consumers + elements = + Stream.flat_map( + stream, + fn + [first | _] = element -> + case FormatterHelpers.proplist?(first) or is_map(first) do + true -> element + false -> [element] + end + + other -> + [other] + end + ) + |> Stream.scan( + :empty, + FormatterHelpers.without_errors_2(fn element, previous -> + separator = + case previous do + :empty -> "" + _ -> "," + end + + format_element(element, separator, options) + end) + ) + + Stream.concat([["["], elements, ["]"]]) + end + + def keys_to_atoms(enum) do + Enum.map(enum, + fn({k, v}) when is_binary(k) or is_list(k) -> + {String.to_atom(k), v} + (other) -> other + end) + end + + def format_element(val, separator, options) do + separator <> format_output(val, options) + end + + def machine_readable?, do: true +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/json_stream.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/json_stream.ex new file mode 100644 index 0000000000..a1bea3fc11 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/json_stream.ex @@ -0,0 +1,75 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Basic JSON formatter. Supports 1-level of +# collection using start/finish_collection. +# Primary purpose is to translate stream from CTL, +# so there is no need for multiple collection levels + +defmodule RabbitMQ.CLI.Formatters.JsonStream do + @moduledoc """ + Formats a potentially infinite stream of maps, proplists, keyword lists, + and other things that are essentially a map. + + The output exclude JSON array boundaries. The output can be fed + to `jq' for pretty printing, filtering and querying. + """ + + @behaviour RabbitMQ.CLI.FormatterBehaviour + + alias RabbitMQ.CLI.Formatters.FormatterHelpers + alias RabbitMQ.CLI.Core.Platform + + def format_output("", _opts) do + # the empty string can be emitted along with a finishing marker that ends the stream + # (e.g. with commands that have a duration argument) + # we just emit the empty string as the last value for the stream in this case + "" + end + def format_output(output, _opts) do + {:ok, json} = JSON.encode(keys_to_atoms(output)) + json + end + + def format_stream(stream, options) do + elements = + Stream.flat_map( + stream, + fn + [first | _] = element -> + case FormatterHelpers.proplist?(first) or is_map(first) do + true -> element + false -> [element] + end + + other -> + [other] + end + ) + |> Stream.scan( + :empty, + FormatterHelpers.without_errors_2(fn element, _previous -> + format_element(element, options) + end) + ) + + elements + end + + def keys_to_atoms(enum) do + Enum.map(enum, + fn({k, v}) when is_binary(k) or is_list(k) -> + {String.to_atom(k), v} + (other) -> other + end) + end + + def format_element(val, options) do + format_output(val, options) <> Platform.line_separator() + end + + def machine_readable?, do: true +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/msacc.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/msacc.ex new file mode 100644 index 0000000000..992475a2d0 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/msacc.ex @@ -0,0 +1,19 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Formatters.Msacc do + @behaviour RabbitMQ.CLI.FormatterBehaviour + + def format_output(output, _) do + {:ok, io} = StringIO.open("") + :msacc.print(io, output, %{}) + StringIO.flush(io) + end + + def format_stream(stream, options) do + [format_output(Enum.to_list(stream), options)] + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/plugins.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/plugins.ex new file mode 100644 index 0000000000..54881cc32f --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/plugins.ex @@ -0,0 +1,247 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. +alias RabbitMQ.CLI.Formatters.FormatterHelpers + +defmodule RabbitMQ.CLI.Formatters.Plugins do + @behaviour RabbitMQ.CLI.FormatterBehaviour + + def format_output( + %{status: status, format: format, plugins: plugins}, + options + ) do + legend(status, format, options) ++ format_plugins(plugins, format) + end + + def format_output(%{enabled: enabled, mode: _} = output, options) do + case length(enabled) do + 0 -> + ["Plugin configuration unchanged."] + + _ -> + [ + "The following plugins have been enabled:" + | for plugin <- enabled do + " #{plugin}" + end + ] ++ + [""] ++ + applying(output, options) ++ + log_offline(output) + end + end + + def format_output(%{disabled: disabled, mode: _} = output, options) do + case length(disabled) do + 0 -> + ["Plugin configuration unchanged."] + + _ -> + [ + "The following plugins have been disabled:" + | for plugin <- disabled do + " #{plugin}" + end + ] ++ + [""] ++ + applying(output, options) ++ + log_offline(output) + end + end + + ## Do not print enabled/disabled for set command + def format_output(%{} = output, options) do + applying(output, options) + end + + def format_output([], %{node: node}) do + ["All plugins have been disabled.", "Applying plugin configuration to #{node}..."] + end + + def format_output(plugins, %{node: node}) when is_list(plugins) do + [ + "The following plugins have been configured:" + | for plugin <- plugins do + " #{plugin}" + end + ] ++ + ["Applying plugin configuration to #{node}..."] + end + + def format_output(output, _) do + :io_lib.format("~p", [output]) + |> to_string + end + + def format_stream(stream, options) do + Stream.map( + stream, + FormatterHelpers.without_errors_1(fn element -> + format_output(element, options) + end) + ) + end + + defp format_plugins(plugins, format) do + max_name_length = + Enum.reduce(plugins, 0, fn %{name: name}, len -> + max(String.length(to_string(name)), len) + end) + + for plugin <- plugins do + format_plugin(plugin, format, max_name_length) + end + |> List.flatten() + end + + defp format_plugin(%{name: name}, :minimal, _) do + to_string(name) + end + + defp format_plugin(plugin, :normal, max_name_length) do + [summary(plugin) <> inline_version(plugin, max_name_length)] + end + + defp format_plugin(plugin, :verbose, _) do + [summary(plugin) | verbose(plugin)] + end + + defp summary(%{name: name, enabled: enabled, running: running}) do + enabled_sign = + case enabled do + :implicit -> "e" + :enabled -> "E" + :not_enabled -> " " + end + + running_sign = + case running do + true -> "*" + false -> " " + end + + "[#{enabled_sign}#{running_sign}] #{name}" + end + + defp inline_version(%{name: name} = plugin, max_name_length) do + spacing = + String.duplicate( + " ", + max_name_length - + String.length(to_string(name)) + ) + + spacing <> " " <> augment_version(plugin) + end + + defp verbose(%{dependencies: dependencies, description: description} = plugin) do + prettified = to_string(:io_lib.format("~p", [dependencies])) + + [ + " Version: \t#{augment_version(plugin)}", + " Dependencies:\t#{prettified}", + " Description: \t#{description}" + ] + end + + defp augment_version(%{version: version, running_version: nil}) do + to_string(version) + end + + defp augment_version(%{version: version, running_version: version}) do + to_string(version) + end + + defp augment_version(%{version: version, running_version: running_version}) do + "#{running_version} (pending upgrade to #{version})" + end + + ## Do not print legend in minimal, quiet or silent mode + defp legend(_, :minimal, _) do + [] + end + defp legend(_, _, %{quiet: true}) do + [] + end + defp legend(_, _, %{silent: true}) do + [] + end + + defp legend(status, _, %{node: node}) do + [ + " Configured: E = explicitly enabled; e = implicitly enabled", + " | Status: #{status_message(status, node)}", + " |/" + ] + end + + defp status_message(:running, node) do + "* = running on #{node}" + end + + defp status_message(:node_down, node) do + "[failed to contact #{node} - status not shown]" + end + + defp applying(%{mode: :offline, set: set_plugins}, _) do + set_plugins_message = + case length(set_plugins) do + 0 -> "nothing to do" + len -> "set #{len} plugins" + end + + [set_plugins_message <> "."] + end + + defp applying(%{mode: :offline, enabled: enabled}, _) do + enabled_message = + case length(enabled) do + 0 -> "nothing to do" + len -> "enabled #{len} plugins" + end + + [enabled_message <> "."] + end + + defp applying(%{mode: :offline, disabled: disabled}, _) do + disabled_message = + case length(disabled) do + 0 -> "nothing to do" + len -> "disabled #{len} plugins" + end + + [disabled_message <> "."] + end + + defp applying(%{mode: :online, started: started, stopped: stopped}, _) do + stopped_message = + case length(stopped) do + 0 -> [] + len -> ["stopped #{len} plugins"] + end + + started_message = + case length(started) do + 0 -> [] + len -> ["started #{len} plugins"] + end + + change_message = + case Enum.join(started_message ++ stopped_message, " and ") do + "" -> "nothing to do" + msg -> msg + end + + [change_message <> "."] + end + + defp log_offline(%{mode: :offline}) do + ["Offline change; changes will take effect at broker restart."] + end + + defp log_offline(_) do + [] + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/pretty_table.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/pretty_table.ex new file mode 100644 index 0000000000..6b9b7ed9fd --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/pretty_table.ex @@ -0,0 +1,87 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Formatters.PrettyTable do + @behaviour RabbitMQ.CLI.FormatterBehaviour + + alias RabbitMQ.CLI.Formatters.FormatterHelpers + + require Record + import Record + + defrecord :table , extract(:table, + from_lib: "stdout_formatter/include/stdout_formatter.hrl") + defrecord :cell, extract(:cell, + from_lib: "stdout_formatter/include/stdout_formatter.hrl") + defrecord :paragraph, extract(:paragraph, + from_lib: "stdout_formatter/include/stdout_formatter.hrl") + + def format_stream(stream, _opts) do + # Flatten for list_consumers + entries_with_keys = Stream.flat_map(stream, + fn([first | _] = element) -> + case FormatterHelpers.proplist?(first) or is_map(first) do + true -> element; + false -> [element] + end + (other) -> + [other] + end) + |> Enum.to_list() + + # Use stdout_formatter library to format the table. + case entries_with_keys do + [first_entry | _] -> + col_headers = Stream.map(first_entry, + fn({key, _}) -> + cell(content: key, props: %{:title => true}) + end) + |> Enum.to_list() + rows = Stream.map(entries_with_keys, + fn(element) -> + Stream.map(element, + fn({_, value}) -> + cell(content: value, props: %{}) + end) + |> Enum.to_list() + end) + |> Enum.to_list() + ret = :stdout_formatter.to_string( + table( + rows: [col_headers | rows], + props: %{:cell_padding => {0, 1}})) + [to_string ret] + [] -> + entries_with_keys + end + end + + def format_output(output, _opts) do + format = case is_binary(output) do + true -> "~s" + false -> "~p" + end + ret = :stdout_formatter.to_string( + table( + rows: [ + [cell(content: "Output", props: %{:title => true})], + [cell( + content: paragraph(content: output, + props: %{:format => format}))]], + props: %{:cell_padding => {0, 1}})) + to_string ret + end + + def format_value(value) do + case is_binary(value) do + true -> value + false -> case is_atom(value) do + true -> to_string(value) + false -> inspect(value) + end + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/report.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/report.ex new file mode 100644 index 0000000000..4db89d611f --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/report.ex @@ -0,0 +1,52 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2017-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Formatters.Report do + alias RabbitMQ.CLI.Formatters.FormatterHelpers + alias RabbitMQ.CLI.Core.{Output, Config} + + @behaviour RabbitMQ.CLI.FormatterBehaviour + def format_output(_, _) do + raise "format_output is not implemented for report formatter" + end + + def format_stream(stream, options) do + quiet = options[:quiet] || options[:silent] || false + + Stream.flat_map( + stream, + FormatterHelpers.without_errors_1(fn + {_command, _banner, {:error, _} = err} -> + err + + {_command, _banner, {:error, _, _} = err} -> + err + + {command, banner, result} -> + case quiet do + true -> + Stream.concat([""], format_result(command, result, options)) + + false -> + Stream.concat(["" | banner_list(banner)], format_result(command, result, options)) + end + end) + ) + end + + def format_result(command, output, options) do + formatter = Config.get_formatter(command, options) + + case Output.format_output(output, formatter, options) do + :ok -> [] + {:ok, val} -> [val] + {:stream, stream} -> stream + end + end + + def banner_list([_ | _] = list), do: list + def banner_list(val), do: [val] +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/string.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/string.ex new file mode 100644 index 0000000000..6fd7f2e0e3 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/string.ex @@ -0,0 +1,26 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +## Prints values from a command as strings(if possible) +defmodule RabbitMQ.CLI.Formatters.String do + alias RabbitMQ.CLI.Core.Helpers + alias RabbitMQ.CLI.Formatters.FormatterHelpers + + @behaviour RabbitMQ.CLI.FormatterBehaviour + + def format_output(output, _) do + Helpers.string_or_inspect(output) + end + + def format_stream(stream, options) do + Stream.map( + stream, + FormatterHelpers.without_errors_1(fn el -> + format_output(el, options) + end) + ) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/string_per_line.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/string_per_line.ex new file mode 100644 index 0000000000..4761b9a555 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/string_per_line.ex @@ -0,0 +1,42 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Formatters.StringPerLine do + @doc """ + Use this to output one stream (collection) element per line, + using the string formatter. Flattens the stream. + """ + + alias RabbitMQ.CLI.Formatters.FormatterHelpers + alias RabbitMQ.CLI.Core.Helpers + import RabbitMQ.CLI.Core.Platform, only: [line_separator: 0] + + @behaviour RabbitMQ.CLI.FormatterBehaviour + + def format_output(output, _) do + Enum.map(output, fn el -> Helpers.string_or_inspect(el) end) + end + + def format_stream(stream, options) do + Stream.scan( + stream, + :empty, + FormatterHelpers.without_errors_2(fn element, previous -> + separator = + case previous do + :empty -> "" + _ -> line_separator() + end + + format_element(element, separator, options) + end) + ) + end + + def format_element(val, separator, options) do + separator <> format_output(val, options) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/table.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/table.ex new file mode 100644 index 0000000000..72d1682202 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/formatters/table.ex @@ -0,0 +1,138 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +alias RabbitMQ.CLI.Formatters.FormatterHelpers + +defmodule RabbitMQ.CLI.Formatters.Table do + @behaviour RabbitMQ.CLI.FormatterBehaviour + + def switches(), do: [table_headers: :boolean, pad_to_header: :boolean] + + def format_stream(stream, options) do + # Flatten for list_consumers + Stream.flat_map( + stream, + fn + [first | _] = element -> + case FormatterHelpers.proplist?(first) or is_map(first) do + true -> element + false -> [element] + end + + other -> + [other] + end + ) + |> Stream.transform( + :init, + FormatterHelpers.without_errors_2(fn + element, :init -> + {maybe_header(element, options), :next} + + element, :next -> + {[format_output_1(element, options)], :next} + end) + ) + end + + def format_output(output, options) do + maybe_header(output, options) + end + + defp maybe_header(output, options) do + opt_table_headers = Map.get(options, :table_headers, true) + opt_silent = Map.get(options, :silent, false) + + case {opt_silent, opt_table_headers} do + {true, _} -> + [format_output_1(output, options)] + + {false, false} -> + [format_output_1(output, options)] + + {false, true} -> + format_header(output) ++ [format_output_1(output, options)] + end + end + + defp format_output_1(output, options) when is_map(output) do + escaped = escaped?(options) + pad_to_header = pad_to_header?(options) + format_line(output, escaped, pad_to_header) + end + + defp format_output_1([], _) do + "" + end + + defp format_output_1(output, options) do + escaped = escaped?(options) + pad_to_header = pad_to_header?(options) + + case FormatterHelpers.proplist?(output) do + true -> format_line(output, escaped, pad_to_header) + false -> format_inspect(output) + end + end + + defp escaped?(_), do: true + + defp pad_to_header?(%{pad_to_header: pad}), do: pad + defp pad_to_header?(_), do: false + + defp format_line(line, escaped, pad_to_header) do + values = + Enum.map( + line, + fn {k, v} -> + line = FormatterHelpers.format_info_item(v, escaped) + + case pad_to_header do + true -> + String.pad_trailing( + to_string(line), + String.length(to_string(k)) + ) + + false -> + line + end + end + ) + + Enum.join(values, "\t") + end + + defp format_inspect(output) do + case is_binary(output) do + true -> output + false -> inspect(output) + end + end + + @spec format_header(term()) :: [String.t()] + defp format_header(output) do + keys = + case output do + map when is_map(map) -> + Map.keys(map) + + keyword when is_list(keyword) -> + case FormatterHelpers.proplist?(keyword) do + true -> Keyword.keys(keyword) + false -> [] + end + + _ -> + [] + end + + case keys do + [] -> [] + _ -> [Enum.join(keys, "\t")] + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/information_unit.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/information_unit.ex new file mode 100644 index 0000000000..ebef8de0ba --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/information_unit.ex @@ -0,0 +1,68 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.InformationUnit do + require MapSet + + @kilobyte_bytes 1000 + @megabyte_bytes @kilobyte_bytes * 1000 + @gigabyte_bytes @megabyte_bytes * 1000 + @terabyte_bytes @gigabyte_bytes * 1000 + + def known_units() do + MapSet.new([ + "bytes", + "kb", + "kilobytes", + "mb", + "megabytes", + "gb", + "gigabytes", + "tb", + "terabytes" + ]) + end + + def parse(val) do + :rabbit_resource_monitor_misc.parse_information_unit(val) + end + + def convert(bytes, "bytes") do + bytes + end + + def convert(bytes, unit) do + do_convert(bytes, String.downcase(unit)) + end + + def known_unit?(val) do + MapSet.member?(known_units(), String.downcase(val)) + end + + defp do_convert(bytes, "kb") do + Float.round(bytes / @kilobyte_bytes, 4) + end + + defp do_convert(bytes, "kilobytes"), do: do_convert(bytes, "kb") + + defp do_convert(bytes, "mb") do + Float.round(bytes / @megabyte_bytes, 4) + end + + defp do_convert(bytes, "megabytes"), do: do_convert(bytes, "mb") + + defp do_convert(bytes, "gb") do + Float.round(bytes / @gigabyte_bytes, 4) + end + + defp do_convert(bytes, "gigabytes"), do: do_convert(bytes, "gb") + + defp do_convert(bytes, "tb") do + Float.round(bytes / @terabyte_bytes, 4) + end + + defp do_convert(bytes, "terabytes"), do: do_convert(bytes, "tb") +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/directories_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/directories_command.ex new file mode 100644 index 0000000000..c3b6aecc0d --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/directories_command.ex @@ -0,0 +1,134 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Plugins.Commands.DirectoriesCommand do + alias RabbitMQ.CLI.Plugins.Helpers, as: PluginHelpers + alias RabbitMQ.CLI.Core.{DocGuide, Validators, Config} + import RabbitMQ.CLI.Core.{CodePath, Paths} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, %{offline: true} = opts) do + {args, opts} + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{online: true, offline: false}, opts)} + end + + def distribution(%{offline: true}), do: :none + def distribution(%{offline: false}), do: :cli + + def switches(), do: [online: :boolean, offline: :boolean] + + def validate(_, %{online: true, offline: true}) do + {:validation_failure, {:bad_argument, "Cannot set both online and offline"}} + end + + def validate(_, %{online: false, offline: false}) do + {:validation_failure, {:bad_argument, "Cannot set online and offline to false"}} + end + + def validate([_ | _], _) do + {:validation_failure, :too_many_args} + end + + def validate([], _) do + :ok + end + + def validate_execution_environment(args, %{offline: true} = opts) do + Validators.chain( + [ + &require_rabbit_and_plugins/2, + &PluginHelpers.enabled_plugins_file/2, + &plugins_dir/2 + ], + [args, opts] + ) + end + + def validate_execution_environment(args, %{online: true} = opts) do + Validators.node_is_running(args, opts) + end + + def run([], %{online: true, node: node_name}) do + do_run(fn key -> + :rabbit_misc.rpc_call(node_name, :rabbit_plugins, key, []) + end) + end + + def run([], %{offline: true} = opts) do + do_run(fn key -> + Config.get_option(key, opts) + end) + end + + def output({:ok, _map} = res, %{formatter: "json"}) do + res + end + + def output({:ok, map}, _opts) do + s = """ + Plugin archives directory: #{Map.get(map, :plugins_dir)} + Plugin expansion directory: #{Map.get(map, :plugins_expand_dir)} + Enabled plugins file: #{Map.get(map, :enabled_plugins_file)} + """ + + {:ok, String.trim_trailing(s)} + end + + def output({:error, err}, _opts) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_software(), err} + end + + use RabbitMQ.CLI.DefaultOutput + + def banner([], %{offline: true}) do + "Listing plugin directories inferred from local environment..." + end + + def banner([], %{online: true, node: node}) do + "Listing plugin directories used by node #{node}" + end + + def usage, do: "directories [--offline] [--online]" + + def usage_additional() do + [ + ["--offline", "do not contact target node. Try to infer directories from the environment."], + ["--online", "infer directories from target node."] + ] + end + + def usage_doc_guides() do + [ + DocGuide.plugins() + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Displays plugin directory and enabled plugin file paths" + + # + # Implementation + # + + defp do_run(fun) do + # return an error or an {:ok, map} tuple + Enum.reduce([:plugins_dir, :plugins_expand_dir, :enabled_plugins_file], {:ok, %{}}, fn + _, {:error, err} -> + {:error, err} + + key, {:ok, acc} -> + case fun.(key) do + {:error, err} -> {:error, err} + val -> {:ok, Map.put(acc, key, :rabbit_data_coercion.to_binary(val))} + end + end) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/disable_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/disable_command.ex new file mode 100644 index 0000000000..4fea2ad34e --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/disable_command.ex @@ -0,0 +1,146 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Plugins.Commands.DisableCommand do + alias RabbitMQ.CLI.Plugins.Helpers, as: PluginHelpers + alias RabbitMQ.CLI.Core.{DocGuide, Validators} + import RabbitMQ.CLI.Core.{CodePath, Paths} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def formatter(), do: RabbitMQ.CLI.Formatters.Plugins + + def merge_defaults(args, opts) do + {args, Map.merge(%{online: false, offline: false, all: false}, opts)} + end + + def distribution(%{offline: true}), do: :none + def distribution(%{offline: false}), do: :cli + + def switches(), do: [online: :boolean, offline: :boolean, all: :boolean] + + def validate([], %{all: false}) do + {:validation_failure, :not_enough_args} + end + + def validate([_ | _], %{all: true}) do + {:validation_failure, {:bad_argument, "Cannot set both --all and a list of plugins"}} + end + + def validate(_, %{online: true, offline: true}) do + {:validation_failure, {:bad_argument, "Cannot set both online and offline"}} + end + + def validate(_args, _opts) do + :ok + end + + def validate_execution_environment(args, opts) do + Validators.chain( + [ + &PluginHelpers.can_set_plugins_with_mode/2, + &require_rabbit_and_plugins/2, + &PluginHelpers.enabled_plugins_file/2, + &plugins_dir/2 + ], + [args, opts] + ) + end + + def run(plugin_names, %{all: all_flag, node: node_name} = opts) do + plugins = + case all_flag do + false -> for s <- plugin_names, do: String.to_atom(s) + true -> PluginHelpers.plugin_names(PluginHelpers.list(opts)) + end + + enabled = PluginHelpers.read_enabled(opts) + all = PluginHelpers.list(opts) + implicit = :rabbit_plugins.dependencies(false, enabled, all) + to_disable_deps = :rabbit_plugins.dependencies(true, plugins, all) + plugins_to_set = MapSet.difference(MapSet.new(enabled), MapSet.new(to_disable_deps)) + + mode = PluginHelpers.mode(opts) + + case PluginHelpers.set_enabled_plugins(MapSet.to_list(plugins_to_set), opts) do + {:ok, enabled_plugins} -> + {:stream, + Stream.concat([ + [:rabbit_plugins.strictly_plugins(enabled_plugins, all)], + RabbitMQ.CLI.Core.Helpers.defer(fn -> + :timer.sleep(5000) + + case PluginHelpers.update_enabled_plugins(enabled_plugins, mode, node_name, opts) do + %{set: new_enabled} = result -> + disabled = implicit -- new_enabled + + filter_strictly_plugins( + Map.put(result, :disabled, :rabbit_plugins.strictly_plugins(disabled, all)), + all, + [:set, :started, :stopped] + ) + + other -> + other + end + end) + ])} + + {:error, _} = err -> + err + end + end + + use RabbitMQ.CLI.Plugins.ErrorOutput + + def banner([], %{all: true, node: node_name}) do + "Disabling ALL plugins on node #{node_name}" + end + + def banner(plugins, %{node: node_name}) do + ["Disabling plugins on node #{node_name}:" | plugins] + end + + def usage, do: "disable <plugin1> [ <plugin2>] | --all [--offline] [--online]" + + def usage_additional() do + [ + ["<plugin1> [ <plugin2>]", "names of plugins to disable separated by a space"], + ["--online", "contact target node to disable the plugins. Changes are applied immediately."], + ["--offline", "update enabled plugins file directly without contacting target node. Changes will be delayed until the node is restarted."], + ["--all", "disable all currently enabled plugins"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.plugins() + ] + end + + def help_section(), do: :plugin_management + + def description(), do: "Disables one or more plugins" + + # + # Implementation + # + + defp filter_strictly_plugins(map, _all, []) do + map + end + + defp filter_strictly_plugins(map, all, [head | tail]) do + case map[head] do + nil -> + filter_strictly_plugins(map, all, tail) + + other -> + value = :rabbit_plugins.strictly_plugins(other, all) + filter_strictly_plugins(Map.put(map, head, value), all, tail) + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/enable_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/enable_command.ex new file mode 100644 index 0000000000..530a2cbb6a --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/enable_command.ex @@ -0,0 +1,156 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Plugins.Commands.EnableCommand do + alias RabbitMQ.CLI.Plugins.Helpers, as: PluginHelpers + alias RabbitMQ.CLI.Core.{DocGuide, Validators} + import RabbitMQ.CLI.Core.{CodePath, Paths} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def formatter(), do: RabbitMQ.CLI.Formatters.Plugins + + def merge_defaults(args, opts) do + {args, Map.merge(%{online: false, offline: false, all: false}, opts)} + end + + def distribution(%{offline: true}), do: :none + def distribution(%{offline: false}), do: :cli + + def switches(), do: [online: :boolean, offline: :boolean, all: :boolean] + + def validate([], %{all: false}) do + {:validation_failure, :not_enough_args} + end + + def validate([_ | _], %{all: true}) do + {:validation_failure, {:bad_argument, "Cannot set both --all and a list of plugins"}} + end + + def validate(_, %{online: true, offline: true}) do + {:validation_failure, {:bad_argument, "Cannot set both online and offline"}} + end + + def validate(_, _) do + :ok + end + + def validate_execution_environment(args, opts) do + Validators.chain( + [ + &PluginHelpers.can_set_plugins_with_mode/2, + &require_rabbit_and_plugins/2, + &PluginHelpers.enabled_plugins_file/2, + &plugins_dir/2 + ], + [args, opts] + ) + end + + def run(plugin_names, %{all: all_flag} = opts) do + plugins = + case all_flag do + false -> for s <- plugin_names, do: String.to_atom(s) + true -> PluginHelpers.plugin_names(PluginHelpers.list(opts)) + end + + case PluginHelpers.validate_plugins(plugins, opts) do + :ok -> do_run(plugins, opts) + other -> other + end + end + + use RabbitMQ.CLI.Plugins.ErrorOutput + + def banner([], %{all: true, node: node_name}) do + "Enabling ALL plugins on node #{node_name}" + end + + def banner(plugins, %{node: node_name}) do + ["Enabling plugins on node #{node_name}:" | plugins] + end + + def usage, do: "enable <plugin1> [ <plugin2>] | --all [--offline] [--online]" + + def usage_additional() do + [ + ["<plugin1> [ <plugin2>]", "names of plugins to enable separated by a space"], + ["--online", "contact target node to enable the plugins. Changes are applied immediately."], + ["--offline", "update enabled plugins file directly without contacting target node. Changes will be delayed until the node is restarted."], + ["--all", "enable all available plugins. Not recommended as some plugins may conflict or otherwise be incompatible!"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.plugins() + ] + end + + def help_section(), do: :plugin_management + + def description(), do: "Enables one or more plugins" + + # + # Implementation + # + + def do_run(plugins, %{node: node_name} = opts) do + enabled = PluginHelpers.read_enabled(opts) + all = PluginHelpers.list(opts) + implicit = :rabbit_plugins.dependencies(false, enabled, all) + enabled_implicitly = MapSet.difference(MapSet.new(implicit), MapSet.new(enabled)) + + plugins_to_set = + MapSet.union( + MapSet.new(enabled), + MapSet.difference(MapSet.new(plugins), enabled_implicitly) + ) + + mode = PluginHelpers.mode(opts) + + case PluginHelpers.set_enabled_plugins(MapSet.to_list(plugins_to_set), opts) do + {:ok, enabled_plugins} -> + {:stream, + Stream.concat([ + [:rabbit_plugins.strictly_plugins(enabled_plugins, all)], + RabbitMQ.CLI.Core.Helpers.defer(fn -> + case PluginHelpers.update_enabled_plugins(enabled_plugins, mode, node_name, opts) do + %{set: new_enabled} = result -> + enabled = new_enabled -- implicit + + filter_strictly_plugins( + Map.put(result, :enabled, :rabbit_plugins.strictly_plugins(enabled, all)), + all, + [:set, :started, :stopped] + ) + + other -> + other + end + end) + ])} + + {:error, _} = err -> + err + end + end + + defp filter_strictly_plugins(map, _all, []) do + map + end + + defp filter_strictly_plugins(map, all, [head | tail]) do + case map[head] do + nil -> + filter_strictly_plugins(map, all, tail) + + other -> + value = :rabbit_plugins.strictly_plugins(other, all) + filter_strictly_plugins(Map.put(map, head, value), all, tail) + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/is_enabled.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/is_enabled.ex new file mode 100644 index 0000000000..fa54b1eee3 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/is_enabled.ex @@ -0,0 +1,154 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Plugins.Commands.IsEnabledCommand do + alias RabbitMQ.CLI.Plugins.Helpers, as: PluginHelpers + alias RabbitMQ.CLI.Core.{DocGuide, Validators} + import RabbitMQ.CLI.Core.{CodePath, Paths} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, %{offline: true} = opts) do + {args, opts} + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{online: true, offline: false}, opts)} + end + + def distribution(%{offline: true}), do: :none + def distribution(%{offline: false}), do: :cli + + def switches(), do: [online: :boolean, offline: :boolean] + + def validate(_, %{online: true, offline: true}) do + {:validation_failure, {:bad_argument, "Cannot set both online and offline"}} + end + + def validate(_, %{online: false, offline: false}) do + {:validation_failure, {:bad_argument, "Cannot set online and offline to false"}} + end + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + + def validate([_ | _], _) do + :ok + end + + def validate_execution_environment(args, %{offline: true} = opts) do + Validators.chain( + [ + &require_rabbit_and_plugins/2, + &PluginHelpers.enabled_plugins_file/2, + &plugins_dir/2 + ], + [args, opts] + ) + end + + def validate_execution_environment(args, %{online: true} = opts) do + Validators.node_is_running(args, opts) + end + + def run(args, %{online: true, node: node_name} = opts) do + case :rabbit_misc.rpc_call(node_name, :rabbit_plugins, :active, []) do + {:error, _} = e -> + e + + plugins -> + plugins = Enum.map(plugins, &Atom.to_string/1) |> Enum.sort() + + case Enum.filter(args, fn x -> not Enum.member?(plugins, x) end) do + [] -> {:ok, positive_result_message(args, opts)} + xs -> {:error, negative_result_message(xs, opts, plugins)} + end + end + end + + def run(args, %{offline: true} = opts) do + plugins = PluginHelpers.list_names(opts) |> Enum.map(&Atom.to_string/1) |> Enum.sort() + + case Enum.filter(args, fn x -> not Enum.member?(plugins, x) end) do + [] -> {:ok, positive_result_message(args, opts)} + xs -> {:error, negative_result_message(xs, opts, plugins)} + end + end + + def output({:ok, msg}, %{formatter: "json"}) do + {:ok, %{"result" => "ok", "message" => msg}} + end + + def output({:error, msg}, %{formatter: "json"}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_unavailable(), + %{"result" => "error", "message" => msg}} + end + + def output({:error, err}, _opts) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_unavailable(), err} + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "is_enabled <plugin1> [ <plugin2>] [--offline] [--online]" + + def usage_additional() do + [ + ["<plugin1> [ <plugin2>]", "names of plugins to check separated by a space"], + ["--online", "contact target node to perform the check. Requires the node to be running and reachable."], + ["--offline", "check enabled plugins file directly without contacting target node."] + ] + end + + def usage_doc_guides() do + [ + DocGuide.plugins() + ] + end + + def banner(args, %{offline: true}) do + "Inferring if #{plugin_or_plugins(args)} from local environment..." + end + + def banner(args, %{online: true, node: node}) do + "Asking node #{node} if #{plugin_or_plugins(args)} enabled..." + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Health check that exits with a non-zero code if provided plugins are not enabled on target node" + + # + # Implementation + # + + def plugin_or_plugins(args) when length(args) == 1 do + "plugin #{PluginHelpers.comma_separated_names(args)} is" + end + + def plugin_or_plugins(args) when length(args) > 1 do + "plugins #{PluginHelpers.comma_separated_names(args)} are" + end + + defp positive_result_message(args, %{online: true, node: node_name}) do + String.capitalize("#{plugin_or_plugins(args)} enabled on node #{node_name}") + end + + defp positive_result_message(args, %{offline: true}) do + String.capitalize("#{plugin_or_plugins(args)} enabled") + end + + defp negative_result_message(missing, %{online: true, node: node_name}, plugins) do + String.capitalize("#{plugin_or_plugins(missing)} not enabled on node #{node_name}. ") <> + "Enabled plugins and dependencies: #{PluginHelpers.comma_separated_names(plugins)}" + end + + defp negative_result_message(missing, %{offline: true}, plugins) do + String.capitalize("#{plugin_or_plugins(missing)} not enabled. ") <> + "Enabled plugins and dependencies: #{PluginHelpers.comma_separated_names(plugins)}" + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/list_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/list_command.ex new file mode 100644 index 0000000000..a4e943a149 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/list_command.ex @@ -0,0 +1,188 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Plugins.Commands.ListCommand do + import RabbitCommon.Records + + alias RabbitMQ.CLI.Core.{DocGuide, Validators} + alias RabbitMQ.CLI.Plugins.Helpers, as: PluginHelpers + import RabbitMQ.CLI.Core.{CodePath, Paths} + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Plugins + + def merge_defaults([], opts), do: merge_defaults([".*"], opts) + def merge_defaults(args, opts), do: {args, Map.merge(default_opts(), opts)} + + def switches(), + do: [verbose: :boolean, minimal: :boolean, enabled: :boolean, implicitly_enabled: :boolean] + + def aliases(), do: [v: :verbose, m: :minimal, E: :enabled, e: :implicitly_enabled] + + def validate(args, _) when length(args) > 1 do + {:validation_failure, :too_many_args} + end + + def validate(_, %{verbose: true, minimal: true}) do + {:validation_failure, {:bad_argument, "Cannot set both verbose and minimal"}} + end + + def validate(_, _) do + :ok + end + + def validate_execution_environment(args, opts) do + Validators.chain( + [ + &require_rabbit_and_plugins/2, + &PluginHelpers.enabled_plugins_file/2, + &plugins_dir/2 + ], + [args, opts] + ) + end + + def run([pattern], %{node: node_name} = opts) do + %{verbose: verbose, minimal: minimal, enabled: only_enabled, implicitly_enabled: all_enabled} = + opts + + all = PluginHelpers.list(opts) + enabled = PluginHelpers.read_enabled(opts) + + missing = MapSet.difference(MapSet.new(enabled), MapSet.new(PluginHelpers.plugin_names(all))) + + case Enum.empty?(missing) do + true -> + :ok + + false -> + names = Enum.join(Enum.to_list(missing), ", ") + IO.puts("WARNING - plugins currently enabled but missing: #{names}\n") + end + + implicit = :rabbit_plugins.dependencies(false, enabled, all) + enabled_implicitly = implicit -- enabled + + {status, running} = + case remote_running_plugins(node_name) do + :error -> {:node_down, []} + {:ok, active} -> {:running, active} + end + + {:ok, re} = Regex.compile(pattern) + + format = + case {verbose, minimal} do + {true, false} -> :verbose + {false, true} -> :minimal + {false, false} -> :normal + end + + plugins = + Enum.filter( + all, + fn plugin -> + name = PluginHelpers.plugin_name(plugin) + + :rabbit_plugins.is_strictly_plugin(plugin) and + Regex.match?(re, to_string(name)) and + cond do + only_enabled -> Enum.member?(enabled, name) + all_enabled -> Enum.member?(enabled ++ enabled_implicitly, name) + true -> true + end + end + ) + + %{ + status: status, + format: format, + plugins: format_plugins(plugins, format, enabled, enabled_implicitly, running) + } + end + + def banner([pattern], _), do: "Listing plugins with pattern \"#{pattern}\" ..." + + def usage, do: "list [pattern] [--verbose] [--minimal] [--enabled] [--implicitly-enabled]" + + def usage_additional() do + [ + ["<pattern>", "only list plugins that match a regular expression pattern"], + ["--verbose", "output more information"], + ["--minimal", "only print plugin names. Most useful in compbination with --silent and --enabled."], + ["--enabled", "only list enabled plugins"], + ["--implicitly-enabled", "include plugins enabled as dependencies of other plugins"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.plugins() + ] + end + + def help_section(), do: :plugin_management + + def description(), do: "Lists plugins and their state" + + # + # Implementation + # + + defp remote_running_plugins(node) do + case :rabbit_misc.rpc_call(node, :rabbit_plugins, :running_plugins, []) do + {:badrpc, _} -> :error + active_with_version -> active_with_version + end + end + + defp format_plugins(plugins, format, enabled, enabled_implicitly, running) do + plugins + |> sort_plugins + |> Enum.map(fn plugin -> + format_plugin(plugin, format, enabled, enabled_implicitly, running) + end) + end + + defp sort_plugins(plugins) do + Enum.sort_by(plugins, &PluginHelpers.plugin_name/1) + end + + defp format_plugin(plugin, :minimal, _, _, _) do + %{name: PluginHelpers.plugin_name(plugin)} + end + + defp format_plugin(plugin, :normal, enabled, enabled_implicitly, running) do + plugin(name: name, version: version) = plugin + + enabled_mode = + case {Enum.member?(enabled, name), Enum.member?(enabled_implicitly, name)} do + {true, false} -> :enabled + {false, true} -> :implicit + {false, false} -> :not_enabled + end + + %{ + name: name, + version: version, + running_version: running[name], + enabled: enabled_mode, + running: Keyword.has_key?(running, name) + } + end + + defp format_plugin(plugin, :verbose, enabled, enabled_implicitly, running) do + normal = format_plugin(plugin, :normal, enabled, enabled_implicitly, running) + plugin(dependencies: dependencies, description: description) = plugin + Map.merge(normal, %{dependencies: dependencies, description: description}) + end + + defp default_opts() do + %{minimal: false, verbose: false, enabled: false, implicitly_enabled: false} + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/set_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/set_command.ex new file mode 100644 index 0000000000..68b442a547 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/commands/set_command.ex @@ -0,0 +1,133 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Plugins.Commands.SetCommand do + alias RabbitMQ.CLI.Plugins.Helpers, as: PluginHelpers + alias RabbitMQ.CLI.Core.{DocGuide, ExitCodes, Validators} + import RabbitMQ.CLI.Core.{CodePath, Paths} + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def formatter(), do: RabbitMQ.CLI.Formatters.Plugins + + def merge_defaults(args, opts) do + {args, Map.merge(%{online: false, offline: false}, opts)} + end + + def distribution(%{offline: true}), do: :none + def distribution(%{offline: false}), do: :cli + + def switches(), do: [online: :boolean, offline: :boolean] + + def validate(_, %{online: true, offline: true}) do + {:validation_failure, {:bad_argument, "Cannot set both online and offline"}} + end + + def validate(_, _) do + :ok + end + + def validate_execution_environment(args, opts) do + Validators.chain( + [ + &PluginHelpers.can_set_plugins_with_mode/2, + &require_rabbit_and_plugins/2, + &PluginHelpers.enabled_plugins_file/2, + &plugins_dir/2 + ], + [args, opts] + ) + end + + def run(plugin_names, opts) do + plugins = for s <- plugin_names, do: String.to_atom(s) + + case PluginHelpers.validate_plugins(plugins, opts) do + :ok -> do_run(plugins, opts) + other -> other + end + end + + def output({:error, {:plugins_not_found, missing}}, _opts) do + {:error, ExitCodes.exit_dataerr(), + "The following plugins were not found: #{Enum.join(Enum.to_list(missing), ", ")}"} + end + + use RabbitMQ.CLI.Plugins.ErrorOutput + + def banner(plugins, %{node: node_name}) do + ["Enabling plugins on node #{node_name}:" | plugins] + end + + def usage, do: "set <plugin1> [ <plugin2>] [--offline] [--online]" + + def usage_additional() do + [ + ["<plugin1> [ <plugin2>]", "names of plugins to enable separated by a space. All other plugins will be disabled."], + ["--online", "contact target node to enable the plugins. Changes are applied immediately."], + ["--offline", "update enabled plugins file directly without contacting target node. Changes will be delayed until the node is restarted."] + ] + end + + def usage_doc_guides() do + [ + DocGuide.plugins() + ] + end + + def help_section(), do: :plugin_management + + def description(), do: "Enables one or more plugins, disables the rest" + + # + # Implementation + # + + def do_run(plugins, %{node: node_name} = opts) do + all = PluginHelpers.list(opts) + mode = PluginHelpers.mode(opts) + + case PluginHelpers.set_enabled_plugins(plugins, opts) do + {:ok, enabled_plugins} -> + {:stream, + Stream.concat([ + [:rabbit_plugins.strictly_plugins(enabled_plugins, all)], + RabbitMQ.CLI.Core.Helpers.defer(fn -> + case PluginHelpers.update_enabled_plugins( + enabled_plugins, + mode, + node_name, + opts + ) do + %{set: _} = map -> + filter_strictly_plugins(map, all, [:set, :started, :stopped]) + + {:error, _} = err -> + err + end + end) + ])} + + {:error, _} = err -> + err + end + end + + defp filter_strictly_plugins(map, _all, []) do + map + end + + defp filter_strictly_plugins(map, all, [head | tail]) do + case map[head] do + nil -> + filter_strictly_plugins(map, all, tail) + + other -> + value = :rabbit_plugins.strictly_plugins(other, all) + filter_strictly_plugins(Map.put(map, head, value), all, tail) + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/error_output.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/error_output.ex new file mode 100644 index 0000000000..51c75ed99a --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/error_output.ex @@ -0,0 +1,55 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +# Default output implementation for plugin commands +defmodule RabbitMQ.CLI.Plugins.ErrorOutput do + alias RabbitMQ.CLI.Core.ExitCodes + + defmacro __using__(_) do + quote do + def output({:error, {:enabled_plugins_mismatch, cli_path, node_path}}, opts) do + {:error, ExitCodes.exit_dataerr(), + "Could not update enabled plugins file at #{cli_path}: target node #{opts[:node]} uses a different path (#{ + node_path + })"} + end + + def output({:error, {:cannot_read_enabled_plugins_file, path, :eacces}}, _opts) do + {:error, ExitCodes.exit_dataerr(), + "Could not read enabled plugins file at #{path}: the file does not exist or permission was denied (EACCES)"} + end + + def output({:error, {:cannot_read_enabled_plugins_file, path, :enoent}}, _opts) do + {:error, ExitCodes.exit_dataerr(), + "Could not read enabled plugins file at #{path}: the file does not exist (ENOENT)"} + end + + def output({:error, {:cannot_write_enabled_plugins_file, path, :eacces}}, _opts) do + {:error, ExitCodes.exit_dataerr(), + "Could not update enabled plugins file at #{path}: the file does not exist or permission was denied (EACCES)"} + end + + def output({:error, {:cannot_write_enabled_plugins_file, path, :enoent}}, _opts) do + {:error, ExitCodes.exit_dataerr(), + "Could not update enabled plugins file at #{path}: the file does not exist (ENOENT)"} + end + + def output({:error, err}, _opts) do + {:error, ExitCodes.exit_software(), err} + end + + def output({:stream, stream}, _opts) do + {:stream, stream} + end + end + + # quote + end + + # defmacro +end + +# defmodule diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/plugins_helpers.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/plugins_helpers.ex new file mode 100644 index 0000000000..bf8b4f772b --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/plugins/plugins_helpers.ex @@ -0,0 +1,232 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Plugins.Helpers do + import RabbitMQ.CLI.Core.DataCoercion + import RabbitCommon.Records + import RabbitMQ.CLI.Core.Platform, only: [path_separator: 0] + import RabbitMQ.CLI.Core.{CodePath, Paths} + alias RabbitMQ.CLI.Core.{Config, Validators} + + def mode(opts) do + %{online: online, offline: offline} = opts + + case {online, offline} do + {true, false} -> :online + {false, true} -> :offline + {false, false} -> :best_effort + end + end + + def can_set_plugins_with_mode(args, opts) do + case mode(opts) do + # can always set offline plugins list + :offline -> + :ok + + # assume online mode, fall back to offline mode in case of errors + :best_effort -> + :ok + + # a running node is required + :online -> + Validators.chain( + [&Validators.node_is_running/2, &Validators.rabbit_is_running/2], + [args, opts] + ) + end + end + + def list(opts) do + {:ok, dir} = plugins_dir(opts) + add_all_to_path(dir) + :lists.usort(:rabbit_plugins.list(to_charlist(dir))) + end + + def list_names(opts) do + list(opts) |> plugin_names + end + + def read_enabled(opts) do + case enabled_plugins_file(opts) do + {:ok, enabled} -> + :rabbit_plugins.read_enabled(to_charlist(enabled)) + + # Existence of enabled_plugins_file should be validated separately + {:error, :no_plugins_file} -> + [] + end + end + + def enabled_plugins_file(opts) do + case Config.get_option(:enabled_plugins_file, opts) do + nil -> {:error, :no_plugins_file} + file -> {:ok, file} + end + end + + def enabled_plugins_file(_, opts) do + enabled_plugins_file(opts) + end + + def set_enabled_plugins(plugins, opts) do + plugin_atoms = :lists.usort(for plugin <- plugins, do: to_atom(plugin)) + require_rabbit_and_plugins(opts) + {:ok, plugins_file} = enabled_plugins_file(opts) + write_enabled_plugins(plugin_atoms, plugins_file, opts) + end + + @spec update_enabled_plugins( + [atom()], + :online | :offline | :best_effort, + node(), + map() + ) :: map() | {:error, any()} + def update_enabled_plugins(enabled_plugins, mode, node_name, opts) do + {:ok, plugins_file} = enabled_plugins_file(opts) + + case mode do + :online -> + case update_enabled_plugins(node_name, plugins_file) do + {:ok, started, stopped} -> + %{ + mode: :online, + started: Enum.sort(started), + stopped: Enum.sort(stopped), + set: Enum.sort(enabled_plugins) + } + + {:error, _} = err -> + err + end + + :best_effort -> + case update_enabled_plugins(node_name, plugins_file) do + {:ok, started, stopped} -> + %{ + mode: :online, + started: Enum.sort(started), + stopped: Enum.sort(stopped), + set: Enum.sort(enabled_plugins) + } + + {:error, :offline} -> + %{mode: :offline, set: Enum.sort(enabled_plugins)} + + {:error, {:enabled_plugins_mismatch, _, _}} = err -> + err + end + + :offline -> + %{mode: :offline, set: Enum.sort(enabled_plugins)} + end + end + + def validate_plugins(requested_plugins, opts) do + ## Maybe check all plugins + plugins = + case opts do + %{all: true} -> plugin_names(list(opts)) + _ -> requested_plugins + end + + all = list(opts) + deps = :rabbit_plugins.dependencies(false, plugins, all) + + deps_plugins = + Enum.filter(all, fn plugin -> + name = plugin_name(plugin) + Enum.member?(deps, name) + end) + + case :rabbit_plugins.validate_plugins(deps_plugins) do + {_, []} -> :ok + {_, invalid} -> {:error, :rabbit_plugins.format_invalid_plugins(invalid)} + end + end + + def plugin_name(plugin) when is_binary(plugin) do + plugin + end + + def plugin_name(plugin) when is_atom(plugin) do + Atom.to_string(plugin) + end + + def plugin_name(plugin) do + plugin(name: name) = plugin + name + end + + def plugin_names(plugins) do + for plugin <- plugins, do: plugin_name(plugin) + end + + def comma_separated_names(plugins) do + Enum.join(plugin_names(plugins), ", ") + end + + # + # Implementation + # + + defp to_list(str) when is_binary(str) do + :erlang.binary_to_list(str) + end + + defp to_list(lst) when is_list(lst) do + lst + end + + defp to_list(atm) when is_atom(atm) do + to_list(Atom.to_string(atm)) + end + + defp write_enabled_plugins(plugins, plugins_file, opts) do + all = list(opts) + all_plugin_names = Enum.map(all, &plugin_name/1) + missing = MapSet.difference(MapSet.new(plugins), MapSet.new(all_plugin_names)) + + case Enum.empty?(missing) do + true -> + case :rabbit_file.write_term_file(to_charlist(plugins_file), [plugins]) do + :ok -> + all_enabled = :rabbit_plugins.dependencies(false, plugins, all) + {:ok, Enum.sort(all_enabled)} + + {:error, reason} -> + {:error, {:cannot_write_enabled_plugins_file, plugins_file, reason}} + end + + false -> + {:error, {:plugins_not_found, Enum.to_list(missing)}} + end + end + + defp update_enabled_plugins(node_name, plugins_file) do + case :rabbit_misc.rpc_call(node_name, :rabbit_plugins, :ensure, [to_list(plugins_file)]) do + {:badrpc, :nodedown} -> {:error, :offline} + {:error, :rabbit_not_running} -> {:error, :offline} + {:ok, start, stop} -> {:ok, start, stop} + {:error, _} = err -> err + end + end + + defp add_all_to_path(plugins_directories) do + directories = String.split(to_string(plugins_directories), path_separator()) + + Enum.map(directories, fn directory -> + with {:ok, subdirs} <- File.ls(directory) do + for subdir <- subdirs do + Path.join([directory, subdir, "ebin"]) + |> Code.append_path() + end + end + end) + + :ok + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/printer_behaviour.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/printer_behaviour.ex new file mode 100644 index 0000000000..b2bedfdaad --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/printer_behaviour.ex @@ -0,0 +1,21 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.PrinterBehaviour do + @callback init(options :: map()) :: {:ok, printer_state :: any} | {:error, error :: any} + @callback finish(printer_state :: any) :: :ok + + @callback print_output(output :: String.t() | [String.t()], printer_state :: any) :: :ok + @callback print_ok(printer_state :: any) :: :ok + + def module_name(nil) do + nil + end + def module_name(printer) do + mod = printer |> String.downcase |> Macro.camelize + String.to_atom("RabbitMQ.CLI.Printers." <> mod) + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/printers/file.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/printers/file.ex new file mode 100644 index 0000000000..ba0daaeebb --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/printers/file.ex @@ -0,0 +1,36 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Printers.File do + @behaviour RabbitMQ.CLI.PrinterBehaviour + + def init(options) do + file = options[:file] + + case File.open(file) do + {:ok, io_device} -> {:ok, %{device: io_device}} + {:error, err} -> {:error, err} + end + end + + def finish(%{device: io_device}) do + :ok = File.close(io_device) + end + + def print_output(output, %{device: io_device}) when is_list(output) do + for line <- output do + IO.puts(io_device, line) + end + end + + def print_output(output, %{device: io_device}) do + IO.puts(io_device, output) + end + + def print_ok(_) do + :ok + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/printers/std_io.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/printers/std_io.ex new file mode 100644 index 0000000000..206feff56d --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/printers/std_io.ex @@ -0,0 +1,28 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Printers.StdIO do + @behaviour RabbitMQ.CLI.PrinterBehaviour + + def init(_), do: {:ok, :ok} + def finish(_), do: :ok + + def print_output(nil, _), do: :ok + + def print_output(output, _) when is_list(output) do + for line <- output do + IO.puts(line) + end + end + + def print_output(output, _) do + IO.puts(output) + end + + def print_ok(_) do + :ok + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/printers/std_io_raw.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/printers/std_io_raw.ex new file mode 100644 index 0000000000..16846907b4 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/printers/std_io_raw.ex @@ -0,0 +1,28 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Printers.StdIORaw do + @behaviour RabbitMQ.CLI.PrinterBehaviour + + def init(_), do: {:ok, :ok} + def finish(_), do: :ok + + def print_output(nil, _), do: :ok + + def print_output(output, _) when is_list(output) do + for line <- output do + IO.write(line) + end + end + + def print_output(output, _) do + IO.write(output) + end + + def print_ok(_) do + :ok + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/add_member_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/add_member_command.ex new file mode 100644 index 0000000000..e789d00343 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/add_member_command.ex @@ -0,0 +1,70 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Queues.Commands.AddMemberCommand do + alias RabbitMQ.CLI.Core.DocGuide + import RabbitMQ.CLI.Core.DataCoercion + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @default_timeout 5_000 + + def merge_defaults(args, opts) do + timeout = + case opts[:timeout] do + nil -> @default_timeout + :infinity -> @default_timeout + other -> other + end + {args, Map.merge(%{vhost: "/", timeout: timeout}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.AcceptsTwoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([name, node] = _args, %{vhost: vhost, node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_quorum_queue, :add_member, [ + vhost, + name, + to_atom(node), + timeout + ]) do + {:error, :classic_queue_not_supported} -> + {:error, "Cannot add members to a classic queue"} + + other -> + other + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "add_member [--vhost <vhost>] <queue> <node>" + + def usage_additional do + [ + ["<queue>", "quorum queue name"], + ["<node>", "node to add a new replica on"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.quorum_queues() + ] + end + + def help_section, do: :replication + + def description, do: "Adds a quorum queue member (replica) on the given node." + + def banner([name, node], _) do + [ + "Adding a replica for queue #{name} on node #{node}..." + ] + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/check_if_node_is_mirror_sync_critical_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/check_if_node_is_mirror_sync_critical_command.ex new file mode 100644 index 0000000000..c31b83d29c --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/check_if_node_is_mirror_sync_critical_command.ex @@ -0,0 +1,105 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Queues.Commands.CheckIfNodeIsMirrorSyncCriticalCommand do + @moduledoc """ + Exits with a non-zero code if there are classic mirrored queues that don't + have any in sync mirrors online and would potentially lose data + if the target node is shut down. + + This command is meant to be used as a pre-upgrade (pre-shutdown) check. + """ + + @behaviour RabbitMQ.CLI.CommandBehaviour + + import RabbitMQ.CLI.Core.Platform, only: [line_separator: 0] + + def scopes(), do: [:diagnostics, :queues] + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, + :rabbit_nodes, :is_single_node_cluster, [], timeout) do + # if target node is the only one in the cluster, the check makes little sense + # and false positives can be misleading + true -> {:ok, :single_node_cluster} + false -> + case :rabbit_misc.rpc_call(node_name, + :rabbit_amqqueue, :list_local_mirrored_classic_without_synchronised_mirrors_for_cli, [], timeout) do + [] -> {:ok, []} + qs when is_list(qs) -> {:ok, qs} + other -> other + end + other -> other + end + end + + def output({:ok, :single_node_cluster}, %{formatter: "json"}) do + {:ok, %{ + "result" => "ok", + "message" => "Target node seems to be the only one in a single node cluster, the check does not apply" + }} + end + def output({:ok, []}, %{formatter: "json"}) do + {:ok, %{"result" => "ok"}} + end + def output({:ok, :single_node_cluster}, %{silent: true}) do + {:ok, :check_passed} + end + def output({:ok, []}, %{silent: true}) do + {:ok, :check_passed} + end + def output({:ok, :single_node_cluster}, %{node: node_name}) do + {:ok, "Node #{node_name} seems to be the only one in a single node cluster, the check does not apply"} + end + def output({:ok, []}, %{node: node_name}) do + {:ok, "Node #{node_name} reported no classic mirrored queues without online synchronised mirrors"} + end + def output({:ok, qs}, %{node: node_name, formatter: "json"}) when is_list(qs) do + {:error, :check_failed, + %{ + "result" => "error", + "queues" => qs, + "message" => "Node #{node_name} reported local classic mirrored queues without online synchronised mirrors" + }} + end + def output({:ok, qs}, %{silent: true}) when is_list(qs) do + {:error, :check_failed} + end + def output({:ok, qs}, %{node: node_name}) when is_list(qs) do + lines = queue_lines(qs, node_name) + + {:error, :check_failed, Enum.join(lines, line_separator())} + end + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description() do + "Health check that exits with a non-zero code if there are classic mirrored queues " <> + "without online synchronised mirrors (queues that would potentially lose data if the target node is shut down)" + end + + def usage, do: "check_if_node_is_mirror_sync_critical" + + def banner([], %{node: node_name}) do + "Checking if node #{node_name} is critical for data safety of any classic mirrored queues ..." + end + + # + # Implementation + # + + def queue_lines(qs, node_name) do + for q <- qs do + "#{q["readable_name"]} would lose its only synchronised replica (master) if node #{node_name} is stopped" + end + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/check_if_node_is_quorum_critical_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/check_if_node_is_quorum_critical_command.ex new file mode 100644 index 0000000000..d8f4a34c1c --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/check_if_node_is_quorum_critical_command.ex @@ -0,0 +1,118 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Queues.Commands.CheckIfNodeIsQuorumCriticalCommand do + @moduledoc """ + Exits with a non-zero code if there are quorum queues that would lose their quorum + if the target node is shut down. + + This command is meant to be used as a pre-upgrade (pre-shutdown) check. + """ + + @behaviour RabbitMQ.CLI.CommandBehaviour + + import RabbitMQ.CLI.Core.Platform, only: [line_separator: 0] + + def scopes(), do: [:diagnostics, :queues] + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([], %{node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_nodes, :is_single_node_cluster, [], timeout) do + # if target node is the only one in the cluster, the check makes little sense + # and false positives can be misleading + true -> {:ok, :single_node_cluster} + false -> + case :rabbit_misc.rpc_call(node_name, :rabbit_maintenance, :is_being_drained_local_read, [node_name]) do + # if target node is under maintenance, it has already transferred all of its quorum queue + # replicas. Don't consider it to be quorum critical. See rabbitmq/rabbitmq-server#2469 + true -> {:ok, :under_maintenance} + false -> + case :rabbit_misc.rpc_call(node_name, :rabbit_quorum_queue, :list_with_minimum_quorum_for_cli, [], timeout) do + [] -> {:ok, []} + qs when is_list(qs) -> {:ok, qs} + other -> other + end + end + other -> other + end + end + + def output({:ok, :single_node_cluster}, %{formatter: "json"}) do + {:ok, %{ + "result" => "ok", + "message" => "Target node seems to be the only one in a single node cluster, the check does not apply" + }} + end + def output({:ok, :under_maintenance}, %{formatter: "json"}) do + {:ok, %{ + "result" => "ok", + "message" => "Target node seems to be in maintenance mode, the check does not apply" + }} + end + def output({:ok, []}, %{formatter: "json"}) do + {:ok, %{"result" => "ok"}} + end + def output({:ok, :single_node_cluster}, %{silent: true}) do + {:ok, :check_passed} + end + def output({:ok, :under_maintenance}, %{silent: true}) do + {:ok, :check_passed} + end + def output({:ok, []}, %{silent: true}) do + {:ok, :check_passed} + end + def output({:ok, :single_node_cluster}, %{node: node_name}) do + {:ok, "Node #{node_name} seems to be the only one in a single node cluster, the check does not apply"} + end + def output({:ok, :under_maintenance}, %{node: node_name}) do + {:ok, "Node #{node_name} seems to be in maintenance mode, the check does not apply"} + end + def output({:ok, []}, %{node: node_name}) do + {:ok, "Node #{node_name} reported no quorum queues with minimum quorum"} + end + def output({:ok, qs}, %{node: node_name, formatter: "json"}) when is_list(qs) do + {:error, :check_failed, + %{ + "result" => "error", + "queues" => qs, + "message" => "Node #{node_name} reported local queues with minimum online quorum" + }} + end + def output({:ok, qs}, %{silent: true}) when is_list(qs) do + {:error, :check_failed} + end + def output({:ok, qs}, %{node: node_name}) when is_list(qs) do + lines = queue_lines(qs, node_name) + + {:error, :check_failed, Enum.join(lines, line_separator())} + end + use RabbitMQ.CLI.DefaultOutput + + def help_section(), do: :observability_and_health_checks + + def description() do + "Health check that exits with a non-zero code if there are queues " <> + "with minimum online quorum (queues that would lose their quorum if the target node is shut down)" + end + + def usage, do: "check_if_node_is_quorum_critical" + + def banner([], %{node: node_name}) do + "Checking if node #{node_name} is critical for quorum of any quorum queues ..." + end + + # + # Implementation + # + + def queue_lines(qs, node_name) do + for q <- qs, do: "#{q["readable_name"]} would lose quorum if node #{node_name} is stopped" + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/delete_member_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/delete_member_command.ex new file mode 100644 index 0000000000..1579bf6809 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/delete_member_command.ex @@ -0,0 +1,58 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Queues.Commands.DeleteMemberCommand do + alias RabbitMQ.CLI.Core.DocGuide + import RabbitMQ.CLI.Core.DataCoercion + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsTwoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([name, node] = _args, %{vhost: vhost, node: node_name}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_quorum_queue, :delete_member, [ + vhost, + name, + to_atom(node) + ]) do + {:error, :classic_queue_not_supported} -> + {:error, "Cannot add members to a classic queue"} + + other -> + other + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "delete_member [--vhost <vhost>] <queue> <node>" + + def usage_additional do + [ + ["<queue>", "quorum queue name"], + ["<node>", "node to remove a new replica on"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.quorum_queues() + ] + end + + def help_section, do: :replication + + def description, do: "Removes a quorum queue member (replica) on the given node." + + def banner([name, node], _) do + "Removing a replica of queue #{name} on node #{node}..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/grow_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/grow_command.ex new file mode 100644 index 0000000000..4e0ce903fe --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/grow_command.ex @@ -0,0 +1,126 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Queues.Commands.GrowCommand do + alias RabbitMQ.CLI.Core.DocGuide + import RabbitMQ.CLI.Core.DataCoercion + + @behaviour RabbitMQ.CLI.CommandBehaviour + + defp default_opts, do: %{vhost_pattern: ".*", + queue_pattern: ".*", + errors_only: false} + + def switches(), + do: [ + vhost_pattern: :string, + queue_pattern: :string, + errors_only: :boolean + ] + + def merge_defaults(args, opts) do + {args, Map.merge(default_opts(), opts)} + end + + def validate(args, _) when length(args) < 2 do + {:validation_failure, :not_enough_args} + end + + def validate(args, _) when length(args) > 2 do + {:validation_failure, :too_many_args} + end + def validate([_, s], _) do + case s do + "all" -> :ok + "even" -> :ok + _ -> + {:validation_failure, "strategy '#{s}' is not recognised."} + end + end + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([node, strategy], %{node: node_name, + vhost_pattern: vhost_pat, + queue_pattern: queue_pat, + errors_only: errors_only}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_quorum_queue, :grow, [ + to_atom(node), + vhost_pat, + queue_pat, + to_atom(strategy)]) do + {:error, _} = error -> error; + {:badrpc, _} = error -> error; + results when errors_only -> + for {{:resource, vhost, _kind, name}, {:errors, _, _} = res} <- results, + do: [{:vhost, vhost}, + {:name, name}, + {:size, format_size res}, + {:result, format_result res}] + results -> + for {{:resource, vhost, _kind, name}, res} <- results, + do: [{:vhost, vhost}, + {:name, name}, + {:size, format_size res}, + {:result, format_result res}] + end + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def usage, do: "grow <node> <all | even> [--vhost-pattern <pattern>] [--queue-pattern <pattern>]" + + def usage_additional do + [ + ["<node>", "node name to place replicas on"], + ["<all | even>", "how many matching quorum queues should have a replica added on this node: all or half (evenly numbered)?"], + ["--queue-pattern <pattern>", "regular expression to match queue names"], + ["--vhost-pattern <pattern>", "regular expression to match virtual host names"], + ["--errors-only", "only list queues which reported an error"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.quorum_queues() + ] + end + + def help_section, do: :cluster_management + + def description, do: "Grows quorum queue clusters by adding a member (replica) to all or half of matching quorum queues on the given node." + + def banner([node, strategy], _) do + "Growing #{strategy} quorum queues on #{node}..." + end + + # + # Implementation + # + + defp format_size({:ok, size}) do + size + end + defp format_size({:error, _size, :timeout}) do + # the actual size is uncertain here + "?" + end + defp format_size({:error, size, _}) do + size + end + + defp format_result({:ok, _size}) do + "ok" + end + defp format_result({:error, _size, :timeout}) do + "error: the operation timed out and may not have been completed" + end + defp format_result({:error, _size, err}) do + :io.format "error: ~W", [err, 10] + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/peek_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/peek_command.ex new file mode 100644 index 0000000000..a159c119e9 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/peek_command.ex @@ -0,0 +1,112 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Queues.Commands.PeekCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + def scopes(), do: [:queues] + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + + use RabbitMQ.CLI.Core.MergesDefaultVirtualHost + + def validate(args, _) when length(args) < 2 do + {:validation_failure, :not_enough_args} + end + def validate(args, _) when length(args) > 2 do + {:validation_failure, :too_many_args} + end + def validate([_, raw_pos], _) do + pos = case Integer.parse(raw_pos) do + {n, _} -> n + :error -> :error + _ -> :error + end + + invalid_pos = {:validation_failure, "position value must be a positive integer"} + case pos do + :error -> invalid_pos + num when num < 1 -> invalid_pos + num when num >= 1 -> :ok + end + end + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([name, pos] = _args, %{node: node_name, vhost: vhost}) do + {pos, _} = Integer.parse(pos) + case :rabbit_misc.rpc_call(node_name, :rabbit_quorum_queue, :peek, [vhost, name, pos]) do + {:error, :classic_queue_not_supported} -> + {:error, "Cannot peek into a classic queue"} + {:ok, msg} -> + {:ok, msg} + err -> + err + end + end + + def output({:error, :not_found}, %{vhost: vhost, formatter: "json"}) do + {:error, + %{ + "result" => "error", + "message" => "Target queue was not found in virtual host '#{vhost}'" + }} + end + def output({:error, :no_message_at_pos}, %{formatter: "json"}) do + {:error, + %{ + "result" => "error", + "message" => "Target queue does not have a message at that position" + }} + end + def output({:error, error}, %{formatter: "json"}) do + {:error, + %{ + "result" => "error", + "message" => "Failed to perform the operation: #{error}" + }} + end + def output({:error, :not_found}, %{vhost: vhost}) do + {:error, "Target queue was not found in virtual host '#{vhost}'"} + end + def output({:error, :no_message_at_pos}, _) do + {:error, "Target queue does not have a message at that position"} + end + def output({:ok, msg}, %{formatter: "json"}) do + {:ok, %{"result" => "ok", "message" => Enum.into(msg, %{})}} + end + def output({:ok, msg}, _) do + res = Enum.map(msg, fn {k,v} -> [{"keys", k}, {"values", v}] end) + {:stream, res} + end + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.PrettyTable + + def usage() do + "peek [--vhost <vhost>] <queue> <position>" + end + + def usage_additional do + [ + ["<queue>", "Name of the queue", + "<position>", "Position in the queue, starts at 1"] + ] + end + + def help_section(), do: :observability_and_health_checks + + def usage_doc_guides() do + [ + DocGuide.quorum_queues() + ] + end + + def description(), do: "Peeks at the given position of a quorum queue" + + def banner([name, pos], %{node: node_name}), + do: "Peeking at quorum queue #{name} at position #{pos} on node #{node_name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/quorum_status_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/quorum_status_command.ex new file mode 100644 index 0000000000..01a61b2536 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/quorum_status_command.ex @@ -0,0 +1,54 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Queues.Commands.QuorumStatusCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + def scopes(), do: [:diagnostics, :queues] + + def merge_defaults(args, opts), do: {args, Map.merge(%{vhost: "/"}, opts)} + + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([name] = _args, %{node: node_name, vhost: vhost}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_quorum_queue, :status, [vhost, name]) do + {:error, :classic_queue_not_supported} -> + {:error, "Cannot get quorum status of a classic queue"} + + other -> + other + end + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.PrettyTable + + def usage() do + "quorum_status [--vhost <vhost>] <queue>" + end + + def usage_additional do + [ + ["<queue>", "Name of the queue"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.quorum_queues() + ] + end + + def help_section(), do: :observability_and_health_checks + + def description(), do: "Displays quorum status of a quorum queue" + + def banner([name], %{node: node_name}), + do: "Status of quorum queue #{name} on node #{node_name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/rebalance_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/rebalance_command.ex new file mode 100644 index 0000000000..1416a7c570 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/rebalance_command.ex @@ -0,0 +1,84 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Queues.Commands.RebalanceCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + use RabbitMQ.CLI.DefaultOutput + + @known_types [ + "all", + "classic", + "quorum" + ] + + defp default_opts, do: %{vhost_pattern: ".*", + queue_pattern: ".*"} + + def switches(), + do: [ + vhost_pattern: :string, + queue_pattern: :string + ] + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def merge_defaults(args, opts) do + {args, Map.merge(default_opts(), opts)} + end + + def validate([], _) do + {:validation_failure, :not_enough_args} + end + def validate(args, _) when length(args) > 1 do + {:validation_failure, :too_many_args} + end + + def validate([type], _) do + case Enum.member?(@known_types, type) do + true -> + :ok + + false -> + {:error, "type #{type} is not supported. Try one of all, classic, quorum."} + end + end + + def run([type], %{node: node_name, + vhost_pattern: vhost_pat, + queue_pattern: queue_pat}) do + arg = String.to_atom(type) + :rabbit_misc.rpc_call(node_name, :rabbit_amqqueue, :rebalance, [arg, vhost_pat, queue_pat]) + end + + def formatter(), do: RabbitMQ.CLI.Formatters.PrettyTable + + def usage, do: "rebalance < all | classic | quorum > [--vhost-pattern <pattern>] [--queue-pattern <pattern>]" + + def usage_additional do + [ + ["<type>", "queue type, must be one of: all, classic, quorum"], + ["--queue-pattern <pattern>", "regular expression to match queue names"], + ["--vhost-pattern <pattern>", "regular expression to match virtual host names"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.quorum_queues() + ] + end + + def help_section, do: :cluster_management + + def description, do: "Rebalances queues." + + def banner([type], _) do + "Rebalancing #{type} queues..." + end + +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/reclaim_quorum_memory_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/reclaim_quorum_memory_command.ex new file mode 100644 index 0000000000..3452cc8741 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/reclaim_quorum_memory_command.ex @@ -0,0 +1,69 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Queues.Commands.ReclaimQuorumMemoryCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + def scopes(), do: [:diagnostics, :queues] + + use RabbitMQ.CLI.Core.MergesDefaultVirtualHost + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([name] = _args, %{node: node_name, vhost: vhost}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_quorum_queue, :reclaim_memory, [vhost, name]) do + {:error, :classic_queue_not_supported} -> + {:error, "This operation is not applicable to classic queues"} + + other -> + other + end + end + + def output({:error, :not_found}, %{vhost: vhost, formatter: "json"}) do + {:error, + %{ + "result" => "error", + "message" => "Target queue was not found in virtual host '#{vhost}'" + }} + end + def output({:error, error}, %{formatter: "json"}) do + {:error, + %{ + "result" => "error", + "message" => "Failed to perform the operation: #{error}" + }} + end + def output({:error, :not_found}, %{vhost: vhost}) do + {:error, "Target queue was not found in virtual host '#{vhost}'"} + end + use RabbitMQ.CLI.DefaultOutput + + def usage() do + "reclaim_quorum_memory [--vhost <vhost>] <quorum queue>" + end + + def usage_additional do + [ + ["<queue>", "Name of the quorum queue"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.quorum_queues(), + DocGuide.memory_use() + ] + end + + def help_section(), do: :operations + + def description(), do: "Flushes quorum queue processes WAL, performs a full sweep GC on all of its local Erlang processes" + + def banner([name], %{}), + do: "Will flush Raft WAL of quorum queue #{name} ..." +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/shrink_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/shrink_command.ex new file mode 100644 index 0000000000..1bff2b9a1c --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/queues/commands/shrink_command.ex @@ -0,0 +1,97 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Queues.Commands.ShrinkCommand do + alias RabbitMQ.CLI.Core.DocGuide + import RabbitMQ.CLI.Core.DataCoercion + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def switches() do + [errors_only: :boolean] + end + + def merge_defaults(args, opts) do + {args, Map.merge(%{errors_only: false}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsOnePositionalArgument + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([node], %{node: node_name, errors_only: errs}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_quorum_queue, :shrink_all, [to_atom(node)]) do + {:error, _} = error -> error; + {:badrpc, _} = error -> error; + results when errs -> + for {{:resource, vhost, _kind, name}, {:error, _, _} = res} <- results, + do: [{:vhost, vhost}, + {:name, name}, + {:size, format_size(res)}, + {:result, format_result(res)}] + results -> + for {{:resource, vhost, _kind, name}, res} <- results, + do: [{:vhost, vhost}, + {:name, name}, + {:size, format_size(res)}, + {:result, format_result(res)}] + end + end + + use RabbitMQ.CLI.DefaultOutput + + def formatter(), do: RabbitMQ.CLI.Formatters.Table + + def banner([node], _) do + "Shrinking quorum queues on #{node}..." + end + + def usage, do: "shrink <node> [--errors-only]" + + def usage_additional() do + [ + ["<node>", "node name to remove replicas from"], + ["--errors-only", "only list queues which reported an error"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.quorum_queues() + ] + end + + def help_section, do: :cluster_management + + def description, do: "Shrinks quorum queue clusters by removing any members (replicas) on the given node." + + # + # Implementation + # + + defp format_size({:ok, size}) do + size + end + defp format_size({:error, _size, :timeout}) do + # the actual size is uncertain here + "?" + end + defp format_size({:error, size, _}) do + size + end + + defp format_result({:ok, _size}) do + "ok" + end + defp format_result({:error, _size, :last_node}) do + "error: the last node cannot be removed" + end + defp format_result({:error, _size, :timeout}) do + "error: the operation timed out and may not have been completed" + end + defp format_result({:error, _size, err}) do + :io.format "error: ~W", [err, 10] + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/streams/commands/add_replica_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/streams/commands/add_replica_command.ex new file mode 100644 index 0000000000..8dc6da0281 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/streams/commands/add_replica_command.ex @@ -0,0 +1,64 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Streams.Commands.AddReplicaCommand do + alias RabbitMQ.CLI.Core.DocGuide + import RabbitMQ.CLI.Core.DataCoercion + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsDefaultSwitchesAndTimeout + use RabbitMQ.CLI.Core.AcceptsTwoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([name, node] = _args, %{vhost: vhost, node: node_name}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_stream_queue, :add_replica, [ + vhost, + name, + to_atom(node) + ]) do + {:error, :classic_queue_not_supported} -> + {:error, "Cannot add replicas to a classic queue"} + + {:error, :quorum_queue_not_supported} -> + {:error, "Cannot add replicas to a quorum queue"} + + other -> + other + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "add_replica [--vhost <vhost>] <queue> <node>" + + def usage_additional do + [ + ["<queue>", "stream queue name"], + ["<node>", "node to add a new replica on"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.stream_queues() + ] + end + + def help_section, do: :replication + + def description, do: "Adds a stream queue replica on the given node." + + def banner([name, node], _) do + [ + "Adding a replica for queue #{name} on node #{node}..." + ] + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/streams/commands/delete_replica_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/streams/commands/delete_replica_command.ex new file mode 100644 index 0000000000..ca15282949 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/streams/commands/delete_replica_command.ex @@ -0,0 +1,61 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Streams.Commands.DeleteReplicaCommand do + alias RabbitMQ.CLI.Core.DocGuide + import RabbitMQ.CLI.Core.DataCoercion + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts) do + {args, Map.merge(%{vhost: "/"}, opts)} + end + + use RabbitMQ.CLI.Core.AcceptsTwoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([name, node] = _args, %{vhost: vhost, node: node_name}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_stream_queue, :delete_replica, [ + vhost, + name, + to_atom(node) + ]) do + {:error, :classic_queue_not_supported} -> + {:error, "Cannot delete replicas from a classic queue"} + + {:error, :quorum_queue_not_supported} -> + {:error, "Cannot delete replicas from a quorum queue"} + + other -> + other + end + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "delete_replica [--vhost <vhost>] <queue> <node>" + + def usage_additional do + [ + ["<queue>", "stream queue name"], + ["<node>", "node to remove a replica from"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.stream_queues() + ] + end + + def help_section, do: :replication + + def description, do: "Removes a stream queue replica on the given node." + + def banner([name, node], _) do + "Removing a replica of queue #{name} on node #{node}..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/streams/commands/set_stream_retention_policy_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/streams/commands/set_stream_retention_policy_command.ex new file mode 100644 index 0000000000..ee89a1ec57 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/streams/commands/set_stream_retention_policy_command.ex @@ -0,0 +1,58 @@ +## The contents of this file are subject to the Mozilla Public License +## Version 1.1 (the "License"); you may not use this file except in +## compliance with the License. You may obtain a copy of the License +## at https://www.mozilla.org/MPL/ +## +## Software distributed under the License is distributed on an "AS IS" +## basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +## the License for the specific language governing rights and +## limitations under the License. +## +## The Original Code is RabbitMQ. +## +## The Initial Developer of the Original Code is GoPivotal, Inc. +## Copyright (c) 2007-2020 Pivotal Software, Inc. All rights reserved. + +defmodule RabbitMQ.CLI.Streams.Commands.SetStreamRetentionPolicyCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + def merge_defaults(args, opts), do: {args, Map.merge(%{vhost: "/"}, opts)} + + use RabbitMQ.CLI.Core.AcceptsTwoPositionalArguments + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + + def run([name, retention_policy], %{node: node_name, vhost: vhost}) do + :rabbit_misc.rpc_call(node_name, :rabbit_stream_queue, :set_retention_policy, [ + name, + vhost, + retention_policy + ]) + end + + use RabbitMQ.CLI.DefaultOutput + + def banner([name, retention_policy], _) do + "Setting retention policy of stream queue #{name} to #{retention_policy} ..." + end + + def usage, do: "set_stream_retention_policy [--vhost <vhost>] <name> <policy>" + + def usage_additional() do + [ + ["<name>", "stream queue name"], + ["<policy>", "retention policy"] + ] + end + + def usage_doc_guides() do + [ + DocGuide.stream_queues() + ] + end + + def help_section(), do: :policies + + def description(), do: "Sets the retention policy of a stream queue" +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/time_unit.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/time_unit.ex new file mode 100644 index 0000000000..fa08c4befe --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/time_unit.ex @@ -0,0 +1,48 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.TimeUnit do + require MapSet + + @days_seconds 86400 + @weeks_seconds @days_seconds * 7 + @months_seconds @days_seconds * (365 / 12) + @years_seconds @days_seconds * 365 + + def known_units() do + MapSet.new([ + "days", + "weeks", + "months", + "years" + ]) + end + + def convert(time, unit) do + do_convert(time, String.downcase(unit)) + end + + def known_unit?(val) do + MapSet.member?(known_units(), String.downcase(val)) + end + + defp do_convert(time, "days") do + time * @days_seconds + end + + defp do_convert(time, "weeks") do + time * @weeks_seconds + end + + defp do_convert(time, "months") do + time * @months_seconds + end + + defp do_convert(time, "years") do + time * @years_seconds + end + +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/await_online_quorum_plus_one_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/await_online_quorum_plus_one_command.ex new file mode 100644 index 0000000000..ca00ddbbb7 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/await_online_quorum_plus_one_command.ex @@ -0,0 +1,65 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Upgrade.Commands.AwaitOnlineQuorumPlusOneCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @default_timeout 120_000 + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def merge_defaults(args, opts) do + timeout = + case opts[:timeout] do + nil -> @default_timeout + :infinity -> @default_timeout + val -> val + end + + {args, Map.put(opts, :timeout, timeout)} + end + + + def run([], %{node: node_name, timeout: timeout}) do + rpc_timeout = timeout + 500 + case :rabbit_misc.rpc_call(node_name, :rabbit_upgrade_preparation, :await_online_quorum_plus_one, [timeout], rpc_timeout) do + {:error, _} = err -> err + {:error, _, _} = err -> err + {:badrpc, _} = err -> err + + true -> :ok + false -> {:error, "time is up, no quorum + 1 online replicas came online for at least some quorum queues"} + end + end + + def output({:error, msg}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => msg}} + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "await_online_quorum_plus_one" + + def usage_doc_guides() do + [ + DocGuide.quorum_queues(), + DocGuide.upgrade() + ] + end + + def help_section, do: :upgrade + + def description() do + "Waits for all quorum queues to have an above minimum online quorum. " <> + "This makes sure that no queues would lose their quorum if the target node is shut down" + end + + def banner([], %{timeout: timeout}) do + "Will wait for a quorum + 1 of nodes to be online for all quorum queues for #{round(timeout/1000)} seconds..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/await_online_synchronized_mirror_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/await_online_synchronized_mirror_command.ex new file mode 100644 index 0000000000..d6fb40bad2 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/await_online_synchronized_mirror_command.ex @@ -0,0 +1,65 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Upgrade.Commands.AwaitOnlineSynchronizedMirrorCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + @default_timeout 120_000 + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def merge_defaults(args, opts) do + timeout = + case opts[:timeout] do + nil -> @default_timeout + :infinity -> @default_timeout + val -> val + end + + {args, Map.put(opts, :timeout, timeout)} + end + + + def run([], %{node: node_name, timeout: timeout}) do + rpc_timeout = timeout + 500 + case :rabbit_misc.rpc_call(node_name, :rabbit_upgrade_preparation, :await_online_synchronised_mirrors, [timeout], rpc_timeout) do + {:error, _} = err -> err + {:error, _, _} = err -> err + {:badrpc, _} = err -> err + + true -> :ok + false -> {:error, "time is up, no synchronised mirror came online for at least some classic mirrored queues"} + end + end + + def output({:error, msg}, %{node: node_name, formatter: "json"}) do + {:error, %{"result" => "error", "node" => node_name, "message" => msg}} + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "await_online_synchronized_mirror" + + def usage_doc_guides() do + [ + DocGuide.mirroring(), + DocGuide.upgrade() + ] + end + + def help_section, do: :upgrade + + def description() do + "Waits for all classic mirrored queues hosted on the target node to have at least one synchronized mirror online. " <> + "This makes sure that if target node is shut down, there will be an up-to-date mirror to promote." + end + + def banner([], %{timeout: timeout}) do + "Will wait for a synchronised mirror be online for all classic mirrored queues for #{round(timeout/1000)} seconds..." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/drain_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/drain_command.ex new file mode 100644 index 0000000000..c6d2fc86eb --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/drain_command.ex @@ -0,0 +1,54 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Upgrade.Commands.DrainCommand do + @moduledoc """ + Puts the node in maintenance mode. Such node would not accept any + new client connections, closes the connections it previously had, + transfers leadership of locally hosted queues, and will not be considered + for primary queue replica placement. + + This command is meant to be used when automating upgrades. + """ + + @behaviour RabbitMQ.CLI.CommandBehaviour + + alias RabbitMQ.CLI.Core.DocGuide + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_maintenance, :drain, [], timeout) do + # Server does not support maintenance mode + {:badrpc, {:EXIT, {:undef, _}}} -> {:error, :unsupported} + {:badrpc, _} = err -> err + other -> other + end + end + + def output({:error, :unsupported}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_usage, "Maintenance mode is not supported by node #{node_name}"} + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "drain" + + def usage_doc_guides() do + [ + DocGuide.upgrade() + ] + end + + def help_section(), do: :upgrade + + def description(), do: "Puts the node in maintenance mode. Such nodes will not serve any client traffic or host any primary queue replicas" + + def banner(_, %{node: node_name}) do + "Will put node #{node_name} into maintenance mode. " + <> "The node will no longer serve any client traffic!" + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/post_upgrade_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/post_upgrade_command.ex new file mode 100644 index 0000000000..76453ce9f3 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/post_upgrade_command.ex @@ -0,0 +1,39 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Upgrade.Commands.PostUpgradeCommand do + alias RabbitMQ.CLI.Core.DocGuide + + @behaviour RabbitMQ.CLI.CommandBehaviour + + use RabbitMQ.CLI.Core.RequiresRabbitAppRunning + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name}) do + :rabbit_misc.rpc_call(node_name, :rabbit_amqqueue, :rebalance, [:all, ".*", ".*"]) + end + + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "post_upgrade" + + def usage_doc_guides() do + [ + DocGuide.upgrade() + ] + end + + def help_section, do: :upgrade + + def description, do: "Runs post-upgrade tasks" + + def banner([], _) do + "Executing post upgrade tasks...\n" <> + "Rebalancing queue masters..." + end + +end diff --git a/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/revive_command.ex b/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/revive_command.ex new file mode 100644 index 0000000000..a594561a55 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmq/cli/upgrade/commands/revive_command.ex @@ -0,0 +1,56 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQ.CLI.Upgrade.Commands.ReviveCommand do + @moduledoc """ + Puts the node out of maintenance and into regular operating mode. + Such nodes will again serve client traffic and be considered for + primary queue replica placement. + + A node will automatically go into regular operational mode + after a restart. + + This command is meant to be used when automating upgrades. + """ + + @behaviour RabbitMQ.CLI.CommandBehaviour + + alias RabbitMQ.CLI.Core.DocGuide + + use RabbitMQ.CLI.Core.MergesNoDefaults + use RabbitMQ.CLI.Core.AcceptsNoPositionalArguments + + def run([], %{node: node_name, timeout: timeout}) do + case :rabbit_misc.rpc_call(node_name, :rabbit_maintenance, :revive, [], timeout) do + # Server does not support maintenance mode + {:badrpc, {:EXIT, {:undef, _}}} -> {:error, :unsupported} + {:badrpc, _} = err -> err + other -> other + end + end + + def output({:error, :unsupported}, %{node: node_name}) do + {:error, RabbitMQ.CLI.Core.ExitCodes.exit_usage, "Maintenance mode is not supported by node #{node_name}"} + end + use RabbitMQ.CLI.DefaultOutput + + def usage, do: "revive" + + def usage_doc_guides() do + [ + DocGuide.upgrade() + ] + end + + def help_section(), do: :upgrade + + def description(), do: "Puts the node out of maintenance and into regular operating mode. Such nodes will again serve client traffic and host primary queue replicas" + + def banner(_, %{node: node_name}) do + "Will put node #{node_name} back into regular operating mode. " + <> "The node will again serve client traffic and host primary queue replicas." + end +end diff --git a/deps/rabbitmq_cli/lib/rabbitmqctl.ex b/deps/rabbitmq_cli/lib/rabbitmqctl.ex new file mode 100644 index 0000000000..42a0f20434 --- /dev/null +++ b/deps/rabbitmq_cli/lib/rabbitmqctl.ex @@ -0,0 +1,620 @@ +## This Source Code Form is subject to the terms of the Mozilla Public +## License, v. 2.0. If a copy of the MPL was not distributed with this +## file, You can obtain one at https://mozilla.org/MPL/2.0/. +## +## Copyright (c) 2007-2020 VMware, Inc. or its affiliates. All rights reserved. + +defmodule RabbitMQCtl do + alias RabbitMQ.CLI.Core.{ + CommandModules, + Config, + Distribution, + ExitCodes, + Helpers, + Output, + Parser + } + alias RabbitMQ.CLI.{CommandBehaviour, FormatterBehaviour} + alias RabbitMQ.CLI.Ctl.Commands.HelpCommand + + # Enable unit tests for private functions + @compile if Mix.env() == :test, do: :export_all + + @type options() :: map() + @type command_result() :: {:error, ExitCodes.exit_code(), term()} | term() + + def main(["--auto-complete" | []]) do + handle_shutdown(:ok) + end + + def main(unparsed_command) do + exec_command(unparsed_command, &process_output/3) + |> handle_shutdown + end + + def exec_command([] = unparsed_command, _) do + {_args, parsed_options, _} = Parser.parse_global(unparsed_command) + + # this invocation is considered to be invalid. curl and grep do the + # same thing. + {:error, ExitCodes.exit_usage(), Enum.join(HelpCommand.all_usage(parsed_options), "")}; + end + def exec_command(["--help"] = unparsed_command, _) do + {_args, parsed_options, _} = Parser.parse_global(unparsed_command) + + # the user asked for --help and we are displaying it to her, + # reporting a success + {:ok, ExitCodes.exit_ok(), Enum.join(HelpCommand.all_usage(parsed_options), "")}; + end + def exec_command(["--version"] = _unparsed_command, opts) do + # rewrite `--version` as `version` + exec_command(["version"], opts) + end + def exec_command(["--auto-complete" | args], opts) do + # rewrite `--auto-complete` as `autocomplete` + exec_command(["autocomplete" | args], opts) + end + def exec_command(unparsed_command, output_fun) do + {command, command_name, arguments, parsed_options, invalid} = Parser.parse(unparsed_command) + + case {command, invalid} do + {:no_command, _} -> + command_not_found_string = + case command_name do + "" -> "" + _ -> "\nCommand '#{command_name}' not found. \n" + end + + usage_string = + command_not_found_string <> + Enum.join(HelpCommand.all_usage(parsed_options), "") + + {:error, ExitCodes.exit_usage(), usage_string} + + {{:suggest, suggested}, _} -> + suggest_message = + "\nCommand '#{command_name}' not found. \n" <> + "Did you mean '#{suggested}'? \n" + + {:error, ExitCodes.exit_usage(), suggest_message} + + {_, [_ | _]} -> + argument_validation_error_output( + {:bad_option, invalid}, + command, + unparsed_command, + parsed_options + ) + + _ -> + options = parsed_options |> merge_all_defaults |> normalise_options + + try do + do_exec_parsed_command(unparsed_command, output_fun, arguments, command, options) + catch error_type, error -> + maybe_print_stacktrace(error_type, error, __STACKTRACE__, options) + format_error(error, options, command) + end + end + end + + def do_exec_parsed_command(unparsed_command, output_fun, arguments, command, options) do + case options[:help] do + true -> + {:ok, ExitCodes.exit_ok(), HelpCommand.command_usage(command, options)}; + _ -> + {arguments, options} = command.merge_defaults(arguments, options) + + maybe_with_distribution(command, options, fn -> + # rabbitmq/rabbitmq-cli#278 + case Helpers.normalise_node_option(options) do + {:error, _} = err -> + format_error(err, options, command) + {:ok, options} -> + # The code below implements a tiny decision tree that has + # to do with CLI argument and environment state validation. + case command.validate(arguments, options) do + :ok -> + # then optionally validate execution environment + case CommandBehaviour.validate_execution_environment(command, arguments, options) do + :ok -> + result = proceed_to_execution(command, arguments, options) + handle_command_output(result, command, options, output_fun) + + {:validation_failure, err} -> + environment_validation_error_output(err, command, unparsed_command, options) + + {:error, _} = err -> + format_error(err, options, command) + end + + {:validation_failure, err} -> + argument_validation_error_output(err, command, unparsed_command, options) + + {:error, _} = err -> + format_error(err, options, command) + end + end + end) + end + end + + defp proceed_to_execution(command, arguments, options) do + maybe_print_banner(command, arguments, options) + maybe_run_command(command, arguments, options) + end + + defp maybe_run_command(_, _, %{dry_run: true}) do + :ok + end + + defp maybe_run_command(command, arguments, options) do + try do + command.run(arguments, options) |> command.output(options) + catch error_type, error -> + maybe_print_stacktrace(error_type, error, __STACKTRACE__, options) + format_error(error, options, command) + end + end + + def maybe_print_stacktrace(error_type, :undef = error, stacktrace, _opts) do + do_print_stacktrace(error_type, error, stacktrace) + end + def maybe_print_stacktrace(error_type, :function_clause = error, stacktrace, _opts) do + do_print_stacktrace(error_type, error, stacktrace) + end + def maybe_print_stacktrace(error_type, :badarg = error, stacktrace, _opts) do + do_print_stacktrace(error_type, error, stacktrace) + end + def maybe_print_stacktrace(error_type, {:case_clause, _val} = error, stacktrace, _opts) do + do_print_stacktrace(error_type, error, stacktrace) + end + def maybe_print_stacktrace(error_type, error, stacktrace, %{print_stacktrace: true}) do + do_print_stacktrace(error_type, error, stacktrace) + end + def maybe_print_stacktrace(_error_type, _error, _stacktrace, %{print_stacktrace: false}) do + nil + end + def maybe_print_stacktrace(_error_type, _error, _stacktrace, _opts) do + nil + end + + defp do_print_stacktrace(error_type, error, stacktrace) do + IO.puts("Stack trace: \n") + IO.puts(Exception.format(error_type, error, stacktrace)) + end + + def handle_command_output(output, command, options, output_fun) do + case output do + {:error, _, _} = err -> + format_error(err, options, command) + + {:error, _} = err -> + format_error(err, options, command) + + _ -> + output_fun.(output, command, options) + end + end + + defp process_output(output, command, options) do + formatter = Config.get_formatter(command, options) + printer = Config.get_printer(command, options) + + output + |> Output.format_output(formatter, options) + |> Output.print_output(printer, options) + |> case do + {:error, _} = err -> format_error(err, options, command) + other -> other + end + end + + defp output_device(exit_code) do + case exit_code == ExitCodes.exit_ok() do + true -> :stdio + false -> :stderr + end + end + + defp handle_shutdown({:error, exit_code, nil}) do + exit_program(exit_code) + end + + defp handle_shutdown({_, exit_code, output}) do + device = output_device(exit_code) + + for line <- List.flatten([output]) do + IO.puts(device, Helpers.string_or_inspect(line)) + end + + exit_program(exit_code) + end + + defp handle_shutdown(_) do + exit_program(ExitCodes.exit_ok()) + end + + def merge_all_defaults(%{} = options) do + options + |> merge_defaults_node + |> merge_defaults_timeout + |> merge_defaults_longnames + end + + defp merge_defaults_node(%{} = opts) do + longnames_opt = Config.get_option(:longnames, opts) + try do + default_rabbit_nodename = Helpers.get_rabbit_hostname(longnames_opt) + Map.merge(%{node: default_rabbit_nodename}, opts) + catch _error_type, _err -> + opts + end + end + + defp merge_defaults_timeout(%{} = opts), do: Map.merge(%{timeout: :infinity}, opts) + + defp merge_defaults_longnames(%{} = opts), do: Map.merge(%{longnames: false}, opts) + + defp normalise_options(opts) do + opts |> normalise_timeout + end + + defp normalise_timeout(%{timeout: timeout} = opts) + when is_integer(timeout) do + Map.put(opts, :timeout, timeout * 1000) + end + + defp normalise_timeout(opts) do + opts + end + + # Suppress banner if --quiet option is provided + defp maybe_print_banner(_, _, %{quiet: true}) do + nil + end + + # Suppress banner if --silent option is provided + defp maybe_print_banner(_, _, %{silent: true}) do + nil + end + + defp maybe_print_banner(command, args, opts) do + # Suppress banner if a machine-readable formatter is used + formatter = Map.get(opts, :formatter) + case FormatterBehaviour.machine_readable?(formatter) do + true -> nil + false -> + case command.banner(args, opts) do + nil -> + nil + + banner -> + case banner do + list when is_list(list) -> + for line <- list, do: IO.puts(line) + + binary when is_binary(binary) -> + IO.puts(binary) + end + end + end + end + + def argument_validation_error_output(err_detail, command, unparsed_command, options) do + err = format_validation_error(err_detail) + + base_error = + "Error (argument validation): #{err}\nArguments given:\n\t#{ + unparsed_command |> Enum.join(" ") + }" + + validation_error_output(err_detail, base_error, command, options) + end + + def environment_validation_error_output(err_detail, command, unparsed_command, options) do + err = format_validation_error(err_detail) + base_error = "Error: #{err}\nArguments given:\n\t#{unparsed_command |> Enum.join(" ")}" + validation_error_output(err_detail, base_error, command, options) + end + + defp validation_error_output(err_detail, base_error, command, options) do + usage = HelpCommand.base_usage(command, options) + message = base_error <> "\n" <> usage + {:error, ExitCodes.exit_code_for({:validation_failure, err_detail}), message} + end + + defp format_validation_error(:not_enough_args), do: "not enough arguments." + defp format_validation_error({:not_enough_args, detail}), do: "not enough arguments: #{detail}" + defp format_validation_error(:too_many_args), do: "too many arguments." + defp format_validation_error({:too_many_args, detail}), do: "too many arguments: #{detail}" + defp format_validation_error(:bad_argument), do: "Bad argument." + defp format_validation_error({:bad_argument, detail}), do: "Bad argument: #{detail}" + + defp format_validation_error({:unsupported_target, details}) do + details + end + + defp format_validation_error({:bad_option, opts}) do + header = "Invalid options for this command:" + + Enum.join( + [ + header + | for {key, val} <- opts do + "#{key} : #{val}" + end + ], + "\n" + ) + end + + defp format_validation_error({:bad_info_key, keys}), + do: "Info key(s) #{Enum.join(keys, ",")} are not supported" + + defp format_validation_error(:rabbit_app_is_stopped), + do: + "this command requires the 'rabbit' app to be running on the target node. Start it with 'rabbitmqctl start_app'." + + defp format_validation_error(:rabbit_app_is_running), + do: + "this command requires the 'rabbit' app to be stopped on the target node. Stop it with 'rabbitmqctl stop_app'." + + defp format_validation_error(:node_running), + do: "this command requires the target node to be stopped." + + defp format_validation_error(:node_not_running), + do: "this command requires the target node to be running." + + defp format_validation_error(:unsupported_formatter), + do: "the requested formatter is not supported by this command" + + defp format_validation_error(err), do: inspect(err) + + defp exit_program(code) do + :net_kernel.stop() + exit({:shutdown, code}) + end + + defp format_error({:error, {:node_name, :hostname_not_allowed}}, _, _) do + {:error, ExitCodes.exit_dataerr(), + "Unsupported node name: hostname is invalid (possibly contains unsupported characters).\nIf using FQDN node names, use the -l / --longnames argument."} + end + defp format_error({:error, {:node_name, :invalid_node_name_head}}, _, _) do + {:error, ExitCodes.exit_dataerr(), + "Unsupported node name: node name head (the part before the @) is invalid. Only alphanumerics, _ and - characters are allowed.\nIf using FQDN node names, use the -l / --longnames argument"} + end + defp format_error({:error, {:node_name, err_reason} = result}, opts, module) do + op = CommandModules.module_to_command(module) + node = opts[:node] || "(failed to parse or compute default value)" + {:error, ExitCodes.exit_code_for(result), + "Error: operation #{op} failed due to invalid node name (node: #{node}, reason: #{err_reason}).\nIf using FQDN node names, use the -l / --longnames argument"} + end + + defp format_error({:error, {:badrpc_multi, :nodedown, [node | _]} = result}, opts, _) do + diagnostics = get_node_diagnostics(node) + + {:error, ExitCodes.exit_code_for(result), + badrpc_error_message_header(node, opts) <> diagnostics} + end + + defp format_error({:error, {:badrpc_multi, :timeout, [node | _]} = result}, opts, module) do + op = CommandModules.module_to_command(module) + + {:error, ExitCodes.exit_code_for(result), + "Error: operation #{op} on node #{node} timed out. Timeout value used: #{opts[:timeout]}"} + end + + defp format_error({:error, {:badrpc, :nodedown} = result}, opts, _) do + diagnostics = get_node_diagnostics(opts[:node]) + + {:error, ExitCodes.exit_code_for(result), + badrpc_error_message_header(opts[:node], opts) <> diagnostics} + end + + defp format_error({:error, {:badrpc, :timeout} = result}, opts, module) do + op = CommandModules.module_to_command(module) + + {:error, ExitCodes.exit_code_for(result), + "Error: operation #{op} on node #{opts[:node]} timed out. Timeout value used: #{ + opts[:timeout] + }"} + end + + defp format_error({:error, {:badrpc, {:timeout, to}} = result}, opts, module) do + op = CommandModules.module_to_command(module) + + {:error, ExitCodes.exit_code_for(result), + "Error: operation #{op} on node #{opts[:node]} timed out. Timeout value used: #{to}"} + end + + defp format_error({:error, {:badrpc, {:timeout, to, warning}}}, opts, module) do + op = CommandModules.module_to_command(module) + + {:error, ExitCodes.exit_code_for({:timeout, to}), + "Error: operation #{op} on node #{opts[:node]} timed out. Timeout value used: #{to}. #{ + warning + }"} + end + + defp format_error({:error, {:no_such_vhost, vhost} = result}, _opts, _) do + {:error, ExitCodes.exit_code_for(result), "Virtual host '#{vhost}' does not exist"} + end + + defp format_error({:error, {:incompatible_version, local_version, remote_version} = result}, _opts, _) do + {:error, ExitCodes.exit_code_for(result), "Detected potential version incompatibility. CLI tool version: #{local_version}, server: #{remote_version}"} + end + + defp format_error({:error, {:timeout, to} = result}, opts, module) do + op = CommandModules.module_to_command(module) + + {:error, ExitCodes.exit_code_for(result), + "Error: operation #{op} on node #{opts[:node]} timed out. Timeout value used: #{to}"} + end + + defp format_error({:error, :timeout = result}, opts, module) do + op = CommandModules.module_to_command(module) + + {:error, ExitCodes.exit_code_for(result), + "Error: operation #{op} on node #{opts[:node]} timed out. Timeout value used: #{opts[:timeout]}"} + end + + defp format_error({:error, :timeout, msg}, opts, module) do + op = CommandModules.module_to_command(module) + + {:error, ExitCodes.exit_code_for(:timeout), + "Error: operation #{op} on node #{opts[:node]} timed out: #{msg}. Timeout value used: #{opts[:timeout]}"} + end + + # Plugins + defp format_error({:error, {:enabled_plugins_mismatch, cli_path, node_path}}, opts, _module) do + {:error, ExitCodes.exit_dataerr(), + "Could not update enabled plugins file at #{cli_path}: target node #{opts[:node]} uses a different path (#{ + node_path + })"} + end + + defp format_error({:error, {:cannot_read_enabled_plugins_file, path, :eacces}}, _opts, _module) do + {:error, ExitCodes.exit_dataerr(), + "Could not read enabled plugins file at #{path}: the file does not exist or permission was denied (EACCES)"} + end + + defp format_error({:error, {:cannot_read_enabled_plugins_file, path, :enoent}}, _opts, _module) do + {:error, ExitCodes.exit_dataerr(), + "Could not read enabled plugins file at #{path}: the file does not exist (ENOENT)"} + end + + defp format_error({:error, {:cannot_write_enabled_plugins_file, path, :eacces}}, _opts, _module) do + {:error, ExitCodes.exit_dataerr(), + "Could not update enabled plugins file at #{path}: the file does not exist or permission was denied (EACCES)"} + end + + defp format_error({:error, {:cannot_write_enabled_plugins_file, path, :enoent}}, _opts, _module) do + {:error, ExitCodes.exit_dataerr(), + "Could not update enabled plugins file at #{path}: the file does not exist (ENOENT)"} + end + + # Special case health checks. This makes it easier to change + # output of all health checks at once. + defp format_error({:error, :check_failed}, %{formatter: "json"}, _) do + {:error, ExitCodes.exit_unavailable(), nil} + end + defp format_error({:error, :check_failed}, _, _) do + {:error, ExitCodes.exit_unavailable(), nil} + end + defp format_error({:error, :check_failed, err}, %{formatter: "json"}, _) when is_map(err) do + {:ok, res} = JSON.encode(err) + {:error, ExitCodes.exit_unavailable(), res} + end + defp format_error({:error, :check_failed, err}, %{formatter: "json"}, _) do + {:error, ExitCodes.exit_unavailable(), err} + end + defp format_error({:error, :check_failed, err}, _, _) do + {:error, ExitCodes.exit_unavailable(), err} + end + + defp format_error({:error, nil}, _, _) do + # the command intends to produce no output, e.g. a return code + # is sufficient + {:error, ExitCodes.exit_unavailable(), nil} + end + + # Catch all clauses + defp format_error({:error, err}, %{formatter: "json"}, _) when is_map(err) do + {:ok, res} = JSON.encode(err) + {:error, ExitCodes.exit_unavailable(), res} + end + defp format_error({:error, exit_code, err}, %{formatter: "json"}, _) when is_map(err) do + {:ok, res} = JSON.encode(err) + {:error, exit_code, res} + end + + defp format_error({:error, exit_code, err}, _, _) do + string_err = Helpers.string_or_inspect(err) + + {:error, exit_code, "Error:\n#{string_err}"} + end + + defp format_error({:error, err} = result, _, _) do + string_err = Helpers.string_or_inspect(err) + + {:error, ExitCodes.exit_code_for(result), "Error:\n#{string_err}"} + end + + defp format_error(error, _opts, _module) do + {:error, ExitCodes.exit_software(), "#{inspect(error)}\n"} + end + + defp get_node_diagnostics(nil) do + "Target node is not defined" + end + + defp get_node_diagnostics(node_name) do + to_string(:rabbit_nodes_common.diagnostics([node_name])) + end + + defp badrpc_error_message_header(node, _opts) do + """ + Error: unable to perform an operation on node '#{node}'. Please see diagnostics information and suggestions below. + + Most common reasons for this are: + + * Target node is unreachable (e.g. due to hostname resolution, TCP connection or firewall issues) + * CLI tool fails to authenticate with the server (e.g. due to CLI tool's Erlang cookie not matching that of the server) + * Target node is not running + + In addition to the diagnostics info below: + + * See the CLI, clustering and networking guides on https://rabbitmq.com/documentation.html to learn more + * Consult server logs on node #{node} + * If target node is configured to use long node names, don't forget to use --longnames with CLI tools + """ + end + + ## Tries to enable erlang distribution, which can be configured + ## via distribution callback in the command as :cli, :none or {:custom, fun()}. + ## :cli - default rabbitmqctl node name + ## :none - do not start a distribution (e.g. offline command) + ## {:fun, fun} - run a custom function to enable distribution. + ## custom mode is usefult for commands which should have specific node name. + ## Runs code if distribution is successful, or not needed. + @spec maybe_with_distribution(module(), options(), (() -> command_result())) :: command_result() + defp maybe_with_distribution(command, options, code) do + try do + maybe_with_distribution_without_catch(command, options, code) + catch error_type, error -> + maybe_print_stacktrace(error_type, error, __STACKTRACE__, options) + format_error(error, options, command) + end + end + + defp maybe_with_distribution_without_catch(command, options, code) do + distribution_type = CommandBehaviour.distribution(command, options) + + case distribution_type do + :none -> + code.() + + :cli -> + case Distribution.start(options) do + :ok -> + code.() + + {:ok, _} -> + code.() + + {:error, reason} -> + {:error, ExitCodes.exit_config(), "Distribution failed: #{inspect(reason)}"} + end + + {:fun, fun} -> + case fun.(options) do + :ok -> + code.() + + {:error, reason} -> + {:error, ExitCodes.exit_config(), "Distribution failed: #{inspect(reason)}"} + end + end + end +end |