Availability Zones

include/multipass/availability_zone.h

@@ -0,0 +1,45 @@
+/*
+ * 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_AVAILABILITY_ZONE_H
+#define MULTIPASS_AVAILABILITY_ZONE_H
+
+#include "disabled_copy_move.h"
+#include "virtual_machine.h"
+
+#include <memory>
+
+namespace multipass
+{
+class AvailabilityZone : private DisabledCopyMove
+{
+public:
+    using UPtr = std::unique_ptr<AvailabilityZone>;
+    using ShPtr = std::shared_ptr<AvailabilityZone>;
+
+    virtual ~AvailabilityZone() = default;
+
+    [[nodiscard]] virtual const std::string& get_name() const = 0;
+    [[nodiscard]] virtual const std::string& get_subnet() const = 0;
+    [[nodiscard]] virtual bool is_available() const = 0;
+    virtual void set_available(bool new_available) = 0;
+    virtual void add_vm(VirtualMachine& vm) = 0;
+    virtual void remove_vm(VirtualMachine& vm) = 0;
+};
+} // namespace multipass
+
+#endif // MULTIPASS_AVAILABILITY_ZONE_H

include/multipass/availability_zone_manager.h

@@ -0,0 +1,49 @@
+/*
+ * 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_AVAILABILITY_ZONE_MANAGER_H
+#define MULTIPASS_AVAILABILITY_ZONE_MANAGER_H
+
+#include "availability_zone.h"
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace multipass
+{
+class AvailabilityZoneManager : private DisabledCopyMove
+{
+public:
+    using UPtr = std::unique_ptr<AvailabilityZoneManager>;
+    using ShPtr = std::shared_ptr<AvailabilityZoneManager>;
+
+    virtual ~AvailabilityZoneManager() = default;
+
+    virtual AvailabilityZone& get_zone(const std::string& name) = 0;
+    virtual std::vector<std::reference_wrapper<const AvailabilityZone>> get_zones() = 0;
+    // this returns a computed zone name, using an algorithm e.g. round-robin
+    // not to be confused with [get_default_zone_name]
+    virtual std::string get_automatic_zone_name() = 0;
+    // this always returns the same zone name, to be given to VMs that were not assigned to a zone
+    // in the past not to be confused with [get_automatic_zone]
+    virtual std::string get_default_zone_name() const = 0;
+};
+} // namespace multipass
+
+#endif // MULTIPASS_AVAILABILITY_ZONE_MANAGER_H

include/multipass/base_availability_zone.h

@@ -0,0 +1,63 @@
+/*
+ * 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_BASE_AVAILABILITY_ZONE_H
+#define MULTIPASS_BASE_AVAILABILITY_ZONE_H
+
+#include "availability_zone.h"
+
+#include <filesystem>
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace multipass
+{
+class BaseAvailabilityZone : public AvailabilityZone
+{
+public:
+    BaseAvailabilityZone(const std::string& name, const std::filesystem::path& az_directory);
+
+    const std::string& get_name() const override;
+    const std::string& get_subnet() const override;
+    bool is_available() const override;
+    void set_available(bool new_available) override;
+    void add_vm(VirtualMachine& vm) override;
+    void remove_vm(VirtualMachine& vm) override;
+
+private:
+    void serialize() const;
+
+    // we store all the data in one struct so that it can be created from one function call in the
+    // initializer list
+    struct data
+    {
+        const std::string name{};
+        const std::filesystem::path file_path{};
+        const std::string subnet{};
+        bool available{};
+        std::vector<std::reference_wrapper<VirtualMachine>> vms{};
+        // we don't have designated initializers, so mutex remains last so it doesn't need to be
+        // manually initialized
+        mutable std::recursive_mutex mutex{};
+    } m;
+
+    static data read_from_file(const std::string& name, const std::filesystem::path& file_path);
+};
+} // namespace multipass
+
+#endif // MULTIPASS_BASE_AVAILABILITY_ZONE_H

include/multipass/base_availability_zone_manager.h

@@ -0,0 +1,81 @@
+/*
+ * 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_BASE_AVAILABILITY_ZONE_MANAGER_H
+#define MULTIPASS_BASE_AVAILABILITY_ZONE_MANAGER_H
+
+#include "availability_zone_manager.h"
+
+#include <multipass/constants.h>
+
+#include <array>
+#include <filesystem>
+#include <mutex>
+#include <shared_mutex>
+
+namespace multipass
+{
+class BaseAvailabilityZoneManager final : public AvailabilityZoneManager
+{
+public:
+    explicit BaseAvailabilityZoneManager(const std::filesystem::path& data_dir);
+
+    AvailabilityZone& get_zone(const std::string& name) override;
+    std::vector<std::reference_wrapper<const AvailabilityZone>> get_zones() override;
+    std::string get_automatic_zone_name() override;
+    std::string get_default_zone_name() const override;
+
+private:
+    void serialize() const;
+
+    class ZoneCollection
+    {
+    public:
+        static constexpr size_t size = default_zone_names.size();
+        using ZoneArray = std::array<AvailabilityZone::UPtr, size>;
+        static_assert(size > 0);
+
+        const ZoneArray zones{};
+
+        ZoneCollection(ZoneArray&& zones, std::string last_used);
+        [[nodiscard]] std::string next_available();
+        [[nodiscard]] std::string last_used() const;
+
+    private:
+        ZoneArray::const_iterator automatic_zone;
+        mutable std::shared_mutex mutex{};
+    };
+
+    // we store all the data in one struct so that it can be created from one function call in the
+    // initializer list
+    struct data
+    {
+        const std::filesystem::path file_path{};
+        ZoneCollection zone_collection;
+        // we don't have designated initializers, so mutex remains last so it doesn't need to be
+        // manually initialized
+        mutable std::recursive_mutex mutex{};
+    } m;
+
+    [[nodiscard]] const ZoneCollection::ZoneArray& zones() const;
+
+    static data read_from_file(const std::filesystem::path& file_path,
+                               const std::filesystem::path& zones_directory);
+};
+} // namespace multipass
+
+#endif // MULTIPASS_BASE_AVAILABILITY_ZONE_MANAGER_H

include/multipass/cli/command.h

@@ -77,7 +77,7 @@ class Command : private DisabledCopyMove
 
         using Arg0Type =
             typename multipass::callable_traits<SuccessCallable>::template arg<0>::type;
-        using ReplyType = typename std::remove_reference<Arg0Type>::type;
+        using ReplyType = std::decay_t<Arg0Type>;
         ReplyType reply;
         auto handle_failure = adapt_failure_handler(on_failure, reply);
 
@@ -146,7 +146,7 @@ class Command : private DisabledCopyMove
     {
         using Arg0Type =
             typename multipass::callable_traits<SuccessCallable>::template arg<0>::type;
-        using ReplyType = typename std::remove_reference<Arg0Type>::type;
+        using ReplyType = std::decay_t<Arg0Type>;
         return dispatch(rpc_func,
                         request,
                         on_success,
@@ -176,8 +176,12 @@ class Command : private DisabledCopyMove
         using FailureCallableArg0Type =
             std::remove_reference_t<typename FailureCallableTraits::template arg<0>::type>;
 
-        static_assert(std::is_same<typename SuccessCallableTraits::return_type, ReturnCode>::value);
-        static_assert(std::is_same<typename FailureCallableTraits::return_type, ReturnCode>::value);
+        static_assert(
+            std::is_same_v<std::remove_const_t<typename SuccessCallableTraits::return_type>,
+                           ReturnCode>);
+        static_assert(
+            std::is_same_v<std::remove_const_t<typename FailureCallableTraits::return_type>,
+                           ReturnCode>);
 
         static_assert(SuccessCallableTraits::num_args == 1);
         static_assert(std::is_base_of_v<google::protobuf::Message, SuccessCallableArg0Type>,
@@ -192,7 +196,7 @@ class Command : private DisabledCopyMove
             static_assert(std::is_same_v<SuccessCallableArg0Type, FailureCallableArg1Type>,
                           "`on_success` and `on_failure` should handle the same reply types");
         }
-        static_assert(std::is_same<FailureCallableArg0Type, grpc::Status>::value);
+        static_assert(std::is_same_v<std::remove_const_t<FailureCallableArg0Type>, grpc::Status>);
     }
 
     template <typename FailureCallable, typename Reply>

include/multipass/cli/csv_formatter.h

@@ -30,5 +30,6 @@ class CSVFormatter final : public Formatter
     std::string format(const FindReply& list) const override;
     std::string format(const VersionReply& list, const std::string& client_version) const override;
     std::string format(const AliasDict& aliases) const override;
+    std::string format(const ZonesReply& reply) const override;
 };
 } // namespace multipass

include/multipass/cli/formatter.h

@@ -40,6 +40,7 @@ class Formatter : private DisabledCopyMove
     virtual std::string format(const VersionReply& reply,
                                const std::string& client_version) const = 0;
     virtual std::string format(const AliasDict& aliases) const = 0;
+    virtual std::string format(const ZonesReply& reply) const = 0;
 
 protected:
     Formatter() = default;

include/multipass/cli/json_formatter.h

@@ -30,5 +30,6 @@ class JsonFormatter final : public Formatter
     std::string format(const FindReply& list) const override;
     std::string format(const VersionReply& list, const std::string& client_version) const override;
     std::string format(const AliasDict& aliases) const override;
+    std::string format(const ZonesReply& reply) const override;
 };
 } // namespace multipass

include/multipass/cli/table_formatter.h

@@ -30,5 +30,6 @@ class TableFormatter final : public Formatter
     std::string format(const FindReply& list) const override;
     std::string format(const VersionReply& list, const std::string& client_version) const override;
     std::string format(const AliasDict& aliases) const override;
+    std::string format(const ZonesReply& reply) const override;
 };
 } // namespace multipass

include/multipass/cli/yaml_formatter.h

@@ -30,5 +30,6 @@ class YamlFormatter final : public Formatter
     std::string format(const FindReply& list) const override;
     std::string format(const VersionReply& list, const std::string& client_version) const override;
     std::string format(const AliasDict& aliases) const override;
+    std::string format(const ZonesReply& reply) const override;
 };
 } // namespace multipass

include/multipass/constants.h

@@ -71,4 +71,5 @@ constexpr auto petenv_default = "primary";
 constexpr auto timeout_exit_code = 5;
 constexpr auto authenticated_certs_dir = "authenticated-certs";
 constexpr auto home_in_instance = "/home/ubuntu";
+constexpr auto default_zone_names = {"zone1", "zone2", "zone3"};
 } // namespace multipass

include/multipass/exceptions/availability_zone_exceptions.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_AVAILABILITY_ZONE_EXCEPTIONS_H
+#define MULTIPASS_AVAILABILITY_ZONE_EXCEPTIONS_H
+
+#include "formatted_exception_base.h"
+
+namespace multipass
+{
+struct AvailabilityZoneNotFound final : FormattedExceptionBase<>
+{
+    explicit AvailabilityZoneNotFound(const std::string& name)
+        : FormattedExceptionBase{"no AZ with name {:?} found", name}
+    {
+    }
+};
+
+struct NoAvailabilityZoneAvailable final : std::runtime_error
+{
+    NoAvailabilityZoneAvailable() : std::runtime_error{"no AZ is available"}
+    {
+    }
+};
+} // namespace multipass
+
+#endif // MULTIPASS_AVAILABILITY_ZONE_EXCEPTIONS_H

include/multipass/json_utils.h

@@ -25,6 +25,7 @@
 #include <QJsonObject>
 #include <QString>
 
+#include <filesystem>
 #include <optional>
 #include <string>
 #include <vector>
@@ -41,6 +42,7 @@ class JsonUtils : public Singleton<JsonUtils>
 
     virtual void write_json(const QJsonObject& root,
                             QString file_name) const; // transactional; creates parent dirs
+    virtual QJsonObject read_object_from_file(const std::filesystem::path& file_path) const;
     virtual std::string json_to_string(const QJsonObject& root) const;
     virtual QJsonValue update_cloud_init_instance_id(const QJsonValue& id,
                                                      const std::string& src_vm_name,