Availability Zones

feature-flags.cmake

@@ -16,3 +16,8 @@ include(src/cmake/feature-flag.cmake)
 
 # Multipass backend integrating with Apple Virtualization framework
 feature_flag(APPLEVZ_ENABLED "AppleVZ backend" APPLE)
+
+feature_flag(AVAILABILITY_ZONES_ENABLED "Availability zone support")
+if(AVAILABILITY_ZONES_ENABLED)
+  add_compile_definitions(AVAILABILITY_ZONES_FEATURE)
+endif()

include/multipass/availability_zone.h

@@ -0,0 +1,46 @@
+/*
+ * 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 "subnet.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 Subnet& 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,51 @@
+/*
+ * 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>;
+
+    using Zones = std::vector<std::reference_wrapper<const AvailabilityZone>>;
+
+    virtual ~AvailabilityZoneManager() = default;
+
+    virtual AvailabilityZone& get_zone(const std::string& name) = 0;
+    virtual Zones 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,75 @@
+/*
+ * 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>
+
+#include <boost/json.hpp>
+
+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 Subnet& 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:
+    mutable std::recursive_mutex mutex;
+    const std::filesystem::path file_path;
+    const std::string name;
+    std::vector<std::reference_wrapper<VirtualMachine>> vms;
+
+    // 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 Subnet subnet;
+        bool available;
+    } m;
+
+    static Data load_file(const std::string& name, const std::filesystem::path& file_path);
+    void save_file() const;
+
+    friend void tag_invoke(const boost::json::value_from_tag&,
+                           boost::json::value& json,
+                           const Data& zone);
+    friend Data tag_invoke(const boost::json::value_to_tag<Data>&, const boost::json::value& json);
+};
+
+void tag_invoke(const boost::json::value_from_tag&,
+                boost::json::value& json,
+                const BaseAvailabilityZone::Data& zone);
+BaseAvailabilityZone::Data tag_invoke(const boost::json::value_to_tag<BaseAvailabilityZone::Data>&,
+                                      const boost::json::value& json);
+
+} // namespace multipass
+
+#endif // MULTIPASS_BASE_AVAILABILITY_ZONE_H

include/multipass/base_availability_zone_manager.h

@@ -0,0 +1,72 @@
+/*
+ * 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:
+    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{};
+    };
+
+    mutable std::recursive_mutex mutex;
+    const std::filesystem::path file_path;
+    ZoneCollection zone_collection;
+
+    [[nodiscard]] const ZoneCollection::ZoneArray& zones() const;
+
+    static std::string load_file(const std::filesystem::path& file_path);
+    void save_file() const;
+};
+} // 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,
@@ -177,9 +177,11 @@ class Command : private DisabledCopyMove
             std::remove_reference_t<typename FailureCallableTraits::template arg<0>::type>;
 
         static_assert(
-            std::is_same<typename SuccessCallableTraits::return_type, ReturnCodeVariant>::value);
+            std::is_same_v<std::remove_const_t<typename SuccessCallableTraits::return_type>,
+                           ReturnCodeVariant>);
         static_assert(
-            std::is_same<typename FailureCallableTraits::return_type, ReturnCodeVariant>::value);
+            std::is_same_v<std::remove_const_t<typename FailureCallableTraits::return_type>,
+                           ReturnCodeVariant>);
 
         static_assert(SuccessCallableTraits::num_args == 1);
         static_assert(std::is_base_of_v<google::protobuf::Message, SuccessCallableArg0Type>,
@@ -194,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

@@ -75,4 +75,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/ip_address.h

@@ -34,12 +34,8 @@ struct IPAddress
     [[nodiscard]] std::string as_string() const;
     [[nodiscard]] uint32_t as_uint32() const;
 
-    bool operator==(const IPAddress& other) const;
-    bool operator!=(const IPAddress& other) const;
-    bool operator<(const IPAddress& other) const;
-    bool operator<=(const IPAddress& other) const;
-    bool operator>(const IPAddress& other) const;
-    bool operator>=(const IPAddress& other) const;
+    std::strong_ordering operator<=>(const IPAddress& other) const;
+    bool operator==(const IPAddress& other) const = default;
     IPAddress operator+(int value) const;
 
     std::array<uint8_t, 4> octets;