[snapshots] Delete snapshot cli and daemon placeholder

src/client/cli/cmd/common_cli.cpp

@@ -76,6 +76,25 @@
     return instance_names;
 }
 
+std::vector<mp::InstanceSnapshotPair> cmd::add_instance_and_snapshot_names(const mp::ArgParser* parser)
+{
+    std::vector<mp::InstanceSnapshotPair> instance_snapshot_names;
+    instance_snapshot_names.reserve(parser->positionalArguments().count());
+
+    for (const auto& arg : parser->positionalArguments())
+    {
+        mp::InstanceSnapshotPair inst_snap_name;
+        auto index = arg.indexOf('.');
+        inst_snap_name.set_instance_name(arg.left(index).toStdString());
+        if (index >= 0)
+            inst_snap_name.set_snapshot_name(arg.right(arg.length() - index - 1).toStdString());
+
+        instance_snapshot_names.push_back(inst_snap_name);
+    }
+
+    return instance_snapshot_names;
+}
+
 mp::ParseCode cmd::handle_format_option(const mp::ArgParser* parser, mp::Formatter** chosen_formatter,
                                         std::ostream& cerr)
 {

src/client/cli/cmd/common_cli.h

@@ -43,6 +43,7 @@ const QString format_option_name{"format"};
 ParseCode check_for_name_and_all_option_conflict(const ArgParser* parser, std::ostream& cerr, bool allow_empty = false);
 InstanceNames add_instance_names(const ArgParser* parser);
 InstanceNames add_instance_names(const ArgParser* parser, const std::string& default_name);
+std::vector<InstanceSnapshotPair> add_instance_and_snapshot_names(const ArgParser* parser);
 ParseCode handle_format_option(const ArgParser* parser, Formatter** chosen_formatter, std::ostream& cerr);
 std::string instance_action_message_for(const InstanceNames& instance_names, const std::string& action_name);
 ReturnCode run_cmd(const QStringList& args, const ArgParser* parser, std::ostream& cout, std::ostream& cerr);

src/client/cli/cmd/delete.cpp

@@ -75,24 +75,25 @@
 
 QString cmd::Delete::short_help() const
 {
-    return QStringLiteral("Delete instances");
+    return QStringLiteral("Delete instances and snapshots");
 }
 
 QString cmd::Delete::description() const
 {
-    return QStringLiteral("Delete instances, to be purged with the \"purge\" command,\n"
-                          "or recovered with the \"recover\" command.");
+    return QStringLiteral(
+        "Delete instances and snapshots. Instances can be purged immediately or later on,"
+        "with the \"purge\" command. Until they are purged, instances can be recovered"
+        "with the \"recover\" command. Snapshots cannot be recovered after deletion and must be purged at once.");
 }
 
 mp::ParseCode cmd::Delete::parse_args(mp::ArgParser* parser)
 {
-    parser->addPositionalArgument("name", "Names of instances to delete", "<name> [<name> ...]");
+    parser->addPositionalArgument("name", "Names of instances and snapshots to delete",
+                                  "<instance>[.snapshot] [<instance>[.snapshot] ...]");
 
-    QCommandLineOption all_option(all_option_name, "Delete all instances");
-    parser->addOption(all_option);
-
-    QCommandLineOption purge_option({"p", "purge"}, "Purge instances immediately");
-    parser->addOption(purge_option);
+    QCommandLineOption all_option(all_option_name, "Delete all instances and snapshots");
+    QCommandLineOption purge_option({"p", "purge"}, "Purge specified instances and snapshots immediately");
+    parser->addOptions({all_option, purge_option});
 
     auto status = parser->commandParse(this);
     if (status != ParseCode::Ok)
@@ -102,11 +103,18 @@
     if (parse_code != ParseCode::Ok)
         return parse_code;
 
-    request.mutable_instance_names()->CopyFrom(add_instance_names(parser));
-
-    if (parser->isSet(purge_option))
+    request.set_purge(parser->isSet(purge_option));
+    for (const auto& item : add_instance_and_snapshot_names(parser))
     {
-        request.set_purge(true);
+        if (item.has_snapshot_name() && !request.purge())
+        {
+            cerr << "Snapshots can only be purged (after deletion, they cannot be recovered). Please use the `--purge` "
+                    "flag if that is what you want.\n";
+            return mp::ParseCode::CommandLineError;
+        }
+
+        request.add_instances_snapshots()->CopyFrom(item);
     }
+
     return status;
 }

src/client/cli/cmd/info.cpp

@@ -24,29 +24,6 @@
 namespace mp = multipass;
 namespace cmd = multipass::cmd;
 
-namespace
-{
-// TODO@snapshots move this to common_cli once required by other commands
-std::vector<mp::InstanceSnapshotPair> add_instance_and_snapshot_names(const mp::ArgParser* parser)
-{
-    std::vector<mp::InstanceSnapshotPair> instance_snapshot_names;
-    instance_snapshot_names.reserve(parser->positionalArguments().count());
-
-    for (const auto& arg : parser->positionalArguments())
-    {
-        mp::InstanceSnapshotPair inst_snap_name;
-        auto index = arg.indexOf('.');
-        inst_snap_name.set_instance_name(arg.left(index).toStdString());
-        if (index >= 0)
-            inst_snap_name.set_snapshot_name(arg.right(arg.length() - index - 1).toStdString());
-
-        instance_snapshot_names.push_back(inst_snap_name);
-    }
-
-    return instance_snapshot_names;
-}
-} // namespace
-
 mp::ReturnCode cmd::Info::run(mp::ArgParser* parser)
 {
     auto ret = parse_args(parser);

src/daemon/daemon.cpp

@@ -1160,6 +1160,23 @@
     return true;
 }
 
+template <typename Instances>
+std::unordered_map<std::string, std::unordered_set<std::string>> map_snapshots_to_instances(const Instances& instances)
+{
+    std::unordered_map<std::string, std::unordered_set<std::string>> instance_snapshots_map;
+
+    for (const auto& it : instances)
+    {
+        if (it.snapshot_name().empty())
+            instance_snapshots_map[it.instance_name()];
+        else if (const auto& entry = instance_snapshots_map.find(it.instance_name());
+                 entry == instance_snapshots_map.end() || !entry->second.empty())
+            instance_snapshots_map[it.instance_name()].insert(it.snapshot_name());
+    }
+
+    return instance_snapshots_map;
+}
+
 void add_aliases(google::protobuf::RepeatedPtrField<mp::FindReply_ImageInfo>* container, const std::string& remote_name,
                  const mp::VMImageInfo& info, const std::string& default_remote)
 {
@@ -1695,11 +1712,11 @@
         {
             mp::SSHSession session{vm.ssh_hostname(), vm.ssh_port(), vm_specs.ssh_username, *config->ssh_key_provider};
 
             instance_info->set_load(mpu::run_in_ssh_session(session, "cat /proc/loadavg | cut -d ' ' -f1-3"));
             instance_info->set_memory_usage(
                 mpu::run_in_ssh_session(session, "free -b | grep 'Mem:' | awk '{printf $3}'"));
             info->set_memory_total(mpu::run_in_ssh_session(session, "free -b | grep 'Mem:' | awk '{printf $2}'"));
             instance_info->set_disk_usage(
                 mpu::run_in_ssh_session(session, "df -t ext4 -t vfat --total -B1 --output=used | tail -n 1"));
             info->set_disk_total(
                 mpu::run_in_ssh_session(session, "df -t ext4 -t vfat --total -B1 --output=size | tail -n 1"));
@@ -1709,60 +1726,60 @@
             auto all_ipv4 = vm.get_all_ipv4(*config->ssh_key_provider);
 
             if (is_ipv4_valid(management_ip))
                 instance_info->add_ipv4(management_ip);
             else if (all_ipv4.empty())
                 instance_info->add_ipv4("N/A");
 
             for (const auto& extra_ipv4 : all_ipv4)
                 if (extra_ipv4 != management_ip)
                     instance_info->add_ipv4(extra_ipv4);
 
             auto current_release =
                 mpu::run_in_ssh_session(session, "cat /etc/os-release | grep 'PRETTY_NAME' | cut -d \\\" -f2");
             instance_info->set_current_release(!current_release.empty() ? current_release : original_release);
         }
         return grpc::Status::OK;
     };
 
     std::unordered_map<std::string, std::unordered_set<std::string>> instance_snapshots_map;
     auto fetch_snapshot_overview = [&](VirtualMachine& vm) {
         fmt::memory_buffer errors;
         const auto& name = vm.vm_name;
 
         auto get_snapshot_info = [&](std::shared_ptr<const Snapshot> snapshot) {
             auto overview = response.mutable_snapshot_overview()->add_overview();
             auto fundamentals = overview->mutable_fundamentals();
 
             overview->set_instance_name(name);
             fundamentals->set_snapshot_name(snapshot->get_name());
             fundamentals->set_parent(snapshot->get_parent_name());
             fundamentals->set_comment(snapshot->get_comment());
             // TODO@snapshots populate snapshot creation time once available
         };
 
         if (const auto& it = instance_snapshots_map.find(name);
             it == instance_snapshots_map.end() || it->second.empty())
         {
             for (const auto& snapshot : vm.view_snapshots())
                 get_snapshot_info(snapshot);
         }
         else
         {
             for (const auto& snapshot : it->second)
             {
                 try
                 {
                     get_snapshot_info(vm.get_snapshot(snapshot));
                 }
                 catch (const std::out_of_range&)
                 {
                     add_fmt_to(errors, "snapshot \"{}\" does not exist", snapshot);
                 }
             }
         }
 
         return grpc_status_for(errors);
     };
 
     auto [instance_selection, status] =
         select_instances_and_react(operative_instances, deleted_instances, request->instances_snapshots(),
@@ -1770,14 +1787,7 @@
 
     if (status.ok())
     {
-        for (const auto& it : request->instances_snapshots())
-        {
-            if (it.snapshot_name().empty())
-                instance_snapshots_map[it.instance_name()];
-            else if (const auto& entry = instance_snapshots_map.find(it.instance_name());
-                     entry == instance_snapshots_map.end() || !entry->second.empty())
-                instance_snapshots_map[it.instance_name()].insert(it.snapshot_name());
-        }
+        instance_snapshots_map = map_snapshots_to_instances(request->instances_snapshots());
 
         // TODO@snapshots change cmd logic to include detailed snapshot info output
         auto cmd =
@@ -2245,12 +2255,13 @@
     DeleteReply response;
 
     auto [instance_selection, status] =
-        select_instances_and_react(operative_instances, deleted_instances, request->instance_names().instance_name(),
+        select_instances_and_react(operative_instances, deleted_instances, request->instances_snapshots(),
                                    InstanceGroup::All, require_existing_instances_reaction);
 
     if (status.ok())
     {
         const bool purge = request->purge();
+        auto instance_snapshots_map = map_snapshots_to_instances(request->instances_snapshots());
 
         for (const auto& vm_it : instance_selection.operative_selection)
         {
@@ -2266,6 +2277,24 @@
 
             if (purge)
             {
+                // TODO@snapshots call method to delete snapshots
+                /*
+                if (const auto& it = instance_snapshots_map.find(name);
+                    it == instance_snapshots_map.end() || it.second.empty())
+                {
+                    // Delete instance and snapshots
+                    // release_resources(name);
+                    // response.add_purged_instances(name);
+                }
+                else
+                {
+                    for (const auto& snapshot_name : instance_snapshots_map[name])
+                    {
+                        // Delete snapshot
+                    }
+                }
+                */
+
                 release_resources(name);
                 response.add_purged_instances(name);
             }
@@ -2491,111 +2520,111 @@
     status_promise->set_value(grpc::Status(grpc::StatusCode::INTERNAL, e.what(), ""));
 }
 
 void mp::Daemon::snapshot(const mp::SnapshotRequest* request,
                           grpc::ServerReaderWriterInterface<SnapshotReply, SnapshotRequest>* server,
                           std::promise<grpc::Status>* status_promise)
 try
 {
     mpl::ClientLogger<SnapshotReply, SnapshotRequest> logger{mpl::level_from(request->verbosity_level()),
                                                              *config->logger, server};
 
     const auto& instance_name = request->instance();
     auto [instance_trail, status] = find_instance_and_react(operative_instances, deleted_instances, instance_name,
                                                             require_operative_instances_reaction);
 
     if (status.ok())
     {
         assert(instance_trail.index() == 0);
         auto* vm_ptr = std::get<0>(instance_trail)->second.get();
         assert(vm_ptr);
 
         using St = VirtualMachine::State;
         if (auto state = vm_ptr->current_state(); state != St::off && state != St::stopped)
             return status_promise->set_value(
                 grpc::Status{grpc::INVALID_ARGUMENT, "Multipass can only take snapshots of stopped instances."});
 
         auto snapshot_name = request->snapshot();
         if (!snapshot_name.empty() && !mp::utils::valid_hostname(snapshot_name))
             return status_promise->set_value(
                 grpc::Status{grpc::INVALID_ARGUMENT, fmt::format(R"(Invalid snapshot name: "{}".)", snapshot_name)});
 
         const auto spec_it = vm_instance_specs.find(instance_name);
         assert(spec_it != vm_instance_specs.end() && "missing instance specs");
 
         SnapshotReply reply;
 
         {
             const auto snapshot = vm_ptr->take_snapshot(instance_directory(instance_name, *config), spec_it->second,
                                                         snapshot_name, request->comment());
 
             reply.set_snapshot(snapshot->get_name());
         }
 
         server->Write(reply);
     }
 
     status_promise->set_value(status);
 }
 catch (const SnapshotNameTaken& e)
 {
     status_promise->set_value(grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, e.what(), ""));
 }
 catch (const std::exception& e)
 {
     status_promise->set_value(grpc::Status(grpc::StatusCode::INTERNAL, e.what(), ""));
 }
 
 void mp::Daemon::restore(const mp::RestoreRequest* request,
                          grpc::ServerReaderWriterInterface<RestoreReply, RestoreRequest>* server,
                          std::promise<grpc::Status>* status_promise)
 try
 {
     mpl::ClientLogger<RestoreReply, RestoreRequest> logger{mpl::level_from(request->verbosity_level()), *config->logger,
                                                            server};
 
     RestoreReply reply;
     const auto& instance_name = request->instance();
     auto [instance_trail, status] = find_instance_and_react(operative_instances, deleted_instances, instance_name,
                                                             require_operative_instances_reaction);
 
     if (status.ok())
     {
         assert(instance_trail.index() == 0);
         auto* vm_ptr = std::get<0>(instance_trail)->second.get();
         assert(vm_ptr);
 
         using St = VirtualMachine::State;
         if (auto state = vm_ptr->current_state(); state != St::off && state != St::stopped)
             return status_promise->set_value(
                 grpc::Status{grpc::INVALID_ARGUMENT, "Multipass can only restore snapshots of stopped instances."});
 
         auto spec_it = vm_instance_specs.find(instance_name);
         assert(spec_it != vm_instance_specs.end() && "missing instance specs");
 
         const auto& vm_dir = instance_directory(instance_name, *config);
         if (!request->destructive())
         {
             reply_msg(server, fmt::format("Taking snapshot before restoring {}", instance_name));
 
             const auto snapshot = vm_ptr->take_snapshot(vm_dir, spec_it->second, "",
                                                         fmt::format("Before restoring {}", request->snapshot()));
 
             reply_msg(server, fmt::format("Snapshot taken: {}.{}", instance_name, snapshot->get_name()),
                       /* sticky = */ true);
         }
 
         reply_msg(server, "Restoring snapshot");
         vm_ptr->restore_snapshot(vm_dir, request->snapshot(), spec_it->second);
         persist_instances();
 
         server->Write(reply);
     }
 
     status_promise->set_value(status);
 }
 catch (const std::exception& e)
 {
     status_promise->set_value(grpc::Status(grpc::StatusCode::INTERNAL, e.what(), ""));
 }
 
 void mp::Daemon::on_shutdown()
@@ -3099,9 +3128,9 @@
 {
     for (auto& [_, mount] : mounts[name])
     {
         if (!mount->is_mount_managed_by_backend())
         {
             mount->deactivate(/*force=*/true);
         }
     }
 }
@@ -3280,15 +3309,15 @@
 }
 
 template <typename Reply, typename Request>
 void mp::Daemon::reply_msg(grpc::ServerReaderWriterInterface<Reply, Request>* server, std::string&& msg, bool sticky)
 {
     Reply reply{};
     if (sticky)
         reply.set_reply_message(fmt::format("{}\n", std::forward<decltype(msg)>(msg)));
     else
         reply.set_reply_message(std::forward<decltype(msg)>(msg));
 
     server->Write(reply);
 }
 
 grpc::Status mp::Daemon::migrate_from_hyperkit(grpc::ServerReaderWriterInterface<SetReply, SetRequest>* server)
@@ -3361,26 +3390,26 @@
     for (const auto& [vm_name, vm_specs] : vm_instance_specs)
     {
         if (deleted_instances.find(vm_name) != deleted_instances.cend())
             reply_msg(server, fmt::format("Cannot migrate {}: instance is deleted", vm_name), /* sticky = */ true);
         else if (auto st = operative_instances[vm_name]->current_state();
                  st != VirtualMachine::State::off && st != VirtualMachine::State::stopped)
             reply_msg(server, fmt::format("Cannot migrate {}: instance needs to be stopped", vm_name),
                       /* sticky = */ true);
         else if (auto key = QString::fromStdString(vm_name);
                  qemu_instances_json.contains(key) || qemu_instance_images_json.contains(key))
             reply_msg(server, fmt::format("Cannot migrate {}: name already taken by a qemu instance", vm_name),
                       /* sticky = */ true);
         else if (const auto vm_image = fetch_image_for(vm_name, config->factory->fetch_type(), *config->vault);
                  vm_image.original_release.find("16.04") != std::string::npos &&
                  !vm_image.image_path.contains("uefi", Qt::CaseInsensitive))
             reply_msg(server,
                       fmt::format("Cannot migrate {}: old Xenial instances (launched before 1.11) cannot be migrated :/"
                                   " consider extracting your data manually.",
                                   vm_name),
                       /* sticky = */ true);
         else
         {
             reply_msg(server, fmt::format("Migrating instance from hyperkit to qemu: {}", vm_name));
 
             // Copy instance image to qemu vault
             const auto target_directory = fmt::format("{}/{}", qemu_instances_dir, vm_name);
@@ -3521,6 +3550,6 @@
                                       fmt::join(instances_migrated, separator), hint_delete);
     }
 
     reply_msg(server, std::move(outcome_summary), /* sticky = */ true);
     return ret;
 }

src/rpc/multipass.proto

@@ -424,7 +424,7 @@ message RestartReply {
 }
 
 message DeleteRequest {
-    InstanceNames instance_names = 1;
+    repeated InstanceSnapshotPair instances_snapshots = 1;
     bool purge = 2;
     int32 verbosity_level = 3;
 }