[cli] add enable/disable-zones commands

src/client/cli/client.cpp

@@ -21,6 +21,8 @@
 #include "cmd/authenticate.h"
 #include "cmd/clone.h"
 #include "cmd/delete.h"
+#include "cmd/disable_zones.h"
+#include "cmd/enable_zones.h"
 #include "cmd/exec.h"
 #include "cmd/find.h"
 #include "cmd/get.h"
@@ -87,6 +89,8 @@ mp::Client::Client(ClientConfig& config)
     add_command<cmd::Authenticate>();
     add_command<cmd::Launch>(aliases);
     add_command<cmd::Purge>(aliases);
+    add_command<cmd::DisableZones>();
+    add_command<cmd::EnableZones>();
     add_command<cmd::Exec>(aliases);
     add_command<cmd::Find>();
     add_command<cmd::Get>();

src/client/cli/cmd/CMakeLists.txt

@@ -21,6 +21,8 @@ add_library(commands STATIC
   common_cli.cpp
   create_alias.cpp
   delete.cpp
+  disable_zones.cpp
+  enable_zones.cpp
   exec.cpp
   find.cpp
   get.cpp

src/client/cli/cmd/disable_zones.cpp

@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "disable_zones.h"
+
+#include "animated_spinner.h"
+#include "common_callbacks.h"
+#include "common_cli.h"
+#include "multipass/cli/argparser.h"
+#include "multipass/cli/client_common.h"
+
+#include <QCommandLineOption>
+
+namespace multipass::cmd
+{
+ReturnCode DisableZones::run(ArgParser* parser)
+{
+    if (const auto ret = parse_args(parser); ret != ParseCode::Ok)
+        return parser->returnCodeFrom(ret);
+
+    if (ask_for_confirmation)
+    {
+        if (!term->is_live())
+            throw std::runtime_error{"Unable to query client for confirmation. Use '--force' to forcefully make "
+                                     "unavailable all instances in the specified zones."};
+
+        if (!confirm())
+            return ReturnCode::CommandFail;
+    }
+
+    AnimatedSpinner spinner{cout};
+    const auto use_all_zones = request.zones().empty();
+    const auto message =
+        use_all_zones ? "Disabling all zones" : fmt::format("Disabling {}", fmt::join(request.zones(), ", "));
+    spinner.start(message);
+
+    const auto on_success = [&](const ZonesStateReply&) {
+        spinner.stop();
+        const auto output_message = use_all_zones ? "All zones disabled"
+                                                  : fmt::format("Zone{} disabled: {}",
+                                                                request.zones_size() == 1 ? "" : "s",
+                                                                fmt::join(request.zones(), ", "));
+        cout << output_message << std::endl;
+        return Ok;
+    };
+
+    const auto on_failure = [this, &spinner](const grpc::Status& status) {
+        spinner.stop();
+        return standard_failure_handler_for(name(), cerr, status);
+    };
+
+    const auto streaming_callback = make_logging_spinner_callback<ZonesStateRequest, ZonesStateReply>(spinner, cerr);
+
+    return dispatch(&RpcMethod::zones_state, request, on_success, on_failure, streaming_callback);
+}
+
+std::string DisableZones::name() const
+{
+    return "disable-zones";
+}
+
+QString DisableZones::short_help() const
+{
+    return QStringLiteral("Make zones unavailable");
+}
+
+QString DisableZones::description() const
+{
+    return QStringLiteral("Makes the given availability zones unavailable. Instances therein are "
+                          "forcefully switched off and remain unavailable until their zone is re-enabled "
+                          "(simulating a loss of availability on a cloud provider).");
+}
+
+ParseCode DisableZones::parse_args(ArgParser* parser)
+{
+    parser->addPositionalArgument("zone", "Name of the zones to make unavailable", "<zone> [<zone> ...]");
+
+    QCommandLineOption all_option(all_option_name, "Disable all zones");
+    QCommandLineOption forceOption{"force", "Do not ask for confirmation"};
+    parser->addOptions({all_option, forceOption});
+
+    if (const auto status = parser->commandParse(this); status != ParseCode::Ok)
+        return status;
+
+    if (const auto status = check_for_name_and_all_option_conflict(parser, cerr); status != ParseCode::Ok)
+        return status;
+
+    request.set_available(false);
+    request.set_verbosity_level(parser->verbosityLevel());
+
+    if (!parser->isSet(all_option_name))
+    {
+        for (const auto& zone_name : parser->positionalArguments())
+            request.add_zones(zone_name.toStdString());
+    }
+
+    ask_for_confirmation = !parser->isSet(forceOption);
+
+    return ParseCode::Ok;
+}
+
+bool DisableZones::confirm() const
+{
+    // joins zones by comma with an 'and' for the last one e.g. 'zone1, zone2 and zone3'
+    const auto format_zones = [this] {
+        if (request.zones().empty())
+            return std::string("all zones");
+        if (request.zones_size() == 1)
+            return request.zones(0);
+
+        const auto last_zone = request.zones_size() - 1;
+        return fmt::format("{} and {}",
+                           fmt::join(request.zones().begin(), request.zones().begin() + last_zone, ", "),
+                           request.zones(last_zone));
+    };
+    const auto message = "This operation will forcefully stop the VMs in " + format_zones() +
+                         ". Are you sure you want to continue? (Yes/no)";
+
+    const PlainPrompter prompter{term};
+    auto answer = prompter.prompt(message);
+    while (!answer.empty() && !std::regex_match(answer, client::yes_answer) &&
+           !std::regex_match(answer, client::no_answer))
+        answer = prompter.prompt("Please answer (Yes/No)");
+
+    return answer.empty() || std::regex_match(answer, client::yes_answer);
+}
+} // namespace multipass::cmd

src/client/cli/cmd/disable_zones.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MULTIPASS_DISABLE_ZONES_H
+#define MULTIPASS_DISABLE_ZONES_H
+
+#include <multipass/cli/command.h>
+
+namespace multipass::cmd
+{
+class DisableZones : public Command
+{
+public:
+    using Command::Command;
+    ReturnCode run(ArgParser* parser) override;
+    std::string name() const override;
+    QString short_help() const override;
+    QString description() const override;
+
+private:
+    bool ask_for_confirmation = true;
+    ZonesStateRequest request{};
+    ParseCode parse_args(ArgParser* parser);
+    bool confirm() const;
+};
+} // namespace multipass::cmd
+#endif // MULTIPASS_DISABLE_ZONES_H

src/client/cli/cmd/enable_zones.cpp

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "enable_zones.h"
+
+#include "animated_spinner.h"
+#include "common_callbacks.h"
+#include "common_cli.h"
+#include "multipass/cli/argparser.h"
+#include "multipass/cli/client_common.h"
+
+#include <QCommandLineOption>
+
+namespace multipass::cmd
+{
+ReturnCode EnableZones::run(ArgParser* parser)
+{
+    if (const auto ret = parse_args(parser); ret != ParseCode::Ok)
+        return parser->returnCodeFrom(ret);
+
+    AnimatedSpinner spinner{cout};
+    const auto use_all_zones = request.zones().empty();
+    const auto message =
+        use_all_zones ? "Enabling all zones" : fmt::format("Enabling {}", fmt::join(request.zones(), ", "));
+    spinner.start(message);
+
+    const auto on_success = [&](const ZonesStateReply&) {
+        spinner.stop();
+        const auto output_message = use_all_zones ? "All zones enabled"
+                                                  : fmt::format("Zone{} enabled: {}",
+                                                                request.zones_size() == 1 ? "" : "s",
+                                                                fmt::join(request.zones(), ", "));
+        cout << output_message << std::endl;
+        return Ok;
+    };
+
+    const auto on_failure = [this, &spinner](const grpc::Status& status) {
+        spinner.stop();
+        return standard_failure_handler_for(name(), cerr, status);
+    };
+
+    const auto streaming_callback = make_logging_spinner_callback<ZonesStateRequest, ZonesStateReply>(spinner, cerr);
+
+    return dispatch(&RpcMethod::zones_state, request, on_success, on_failure, streaming_callback);
+}
+
+std::string EnableZones::name() const
+{
+    return "enable-zones";
+}
+
+QString EnableZones::short_help() const
+{
+    return QStringLiteral("Make zones available");
+}
+
+QString EnableZones::description() const
+{
+    return QStringLiteral("Makes the given availability zones available. Instances therein are started if they were "
+                          "running when their zone was last disabled.");
+}
+
+ParseCode EnableZones::parse_args(ArgParser* parser)
+{
+    parser->addPositionalArgument("zone", "Name of the zones to make available", "<zone> [<zone> ...]");
+
+    QCommandLineOption all_option(all_option_name, "Enable all zones");
+    parser->addOption(all_option);
+
+    if (const auto status = parser->commandParse(this); status != ParseCode::Ok)
+        return status;
+
+    if (const auto status = check_for_name_and_all_option_conflict(parser, cerr); status != ParseCode::Ok)
+        return status;
+
+    request.set_available(true);
+    request.set_verbosity_level(parser->verbosityLevel());
+
+    if (!parser->isSet(all_option_name))
+    {
+        for (const auto& zone_name : parser->positionalArguments())
+            request.add_zones(zone_name.toStdString());
+    }
+
+    return ParseCode::Ok;
+}
+} // namespace multipass::cmd

src/client/cli/cmd/enable_zones.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MULTIPASS_ENABLE_ZONES_H
+#define MULTIPASS_ENABLE_ZONES_H
+
+#include <multipass/cli/command.h>
+
+namespace multipass::cmd
+{
+class EnableZones : public Command
+{
+public:
+    using Command::Command;
+    ReturnCode run(ArgParser* parser) override;
+    std::string name() const override;
+    QString short_help() const override;
+    QString description() const override;
+
+private:
+    ZonesStateRequest request{};
+    ParseCode parse_args(ArgParser* parser);
+};
+} // namespace multipass::cmd
+#endif // MULTIPASS_ENABLE_ZONES_H