Merge #1227

1227: WIP: [primary] Auto-mount home in primary on launch r=Saviq a=ricab

Fixes #1224.

Co-authored-by: Ricardo Abreu <[email protected]>

Author: 2 people

include/multipass/constants.h

@@ -28,6 +28,7 @@ constexpr auto min_cpu_cores = "1";
 constexpr auto default_memory_size = "1G";
 constexpr auto default_disk_size = "5G";
 constexpr auto default_cpu_cores = min_cpu_cores;
+constexpr auto home_automount_dir = "Home";
 constexpr auto driver_env_var = "MULTIPASS_VM_DRIVER";
 constexpr auto petenv_key = "client.primary-name";     // This will eventually be moved to some dynamic settings schema
 constexpr auto driver_key = "local.driver";            // idem

src/client/cli/cmd/launch.cpp

@@ -22,11 +22,13 @@
 #include <multipass/cli/argparser.h>
 #include <multipass/cli/client_platform.h>
 #include <multipass/constants.h>
+#include <multipass/settings.h>
 
 #include <multipass/format.h>
 
 #include <yaml-cpp/yaml.h>
 
+#include <QDir>
 #include <QTimeZone>
 
 #include <regex>
@@ -47,15 +49,26 @@ const std::regex show{"s|show", std::regex::icase | std::regex::optimize};
 
 mp::ReturnCode cmd::Launch::run(mp::ArgParser* parser)
 {
-    auto ret = parse_args(parser);
-    if (ret != ParseCode::Ok)
+    petenv_name = Settings::instance().get(petenv_key);
+    if (auto ret = parse_args(parser); ret != ParseCode::Ok)
     {
         return parser->returnCodeFrom(ret);
     }
 
     request.set_time_zone(QTimeZone::systemTimeZoneId().toStdString());
 
-    return request_launch();
+    auto ret = request_launch();
+    if (ret == ReturnCode::Ok && request.instance_name() == petenv_name.toStdString())
+    {
+        const auto mount_source = QDir::toNativeSeparators(QDir::homePath());
+        const auto mount_target = QString{"%1:%2"}.arg(petenv_name, mp::home_automount_dir);
+
+        ret = run_cmd({"multipass", "mount", mount_source, mount_target}, parser, cout, cerr);
+        if (ret == ReturnCode::Ok)
+            cout << fmt::format("Mounted '{}' into '{}'\n", mount_source, mount_target);
+    }
+
+    return ret;
 }
 
 std::string cmd::Launch::name() const
@@ -102,7 +115,12 @@ mp::ParseCode cmd::Launch::parse_args(mp::ArgParser* parser)
                                            "in bytes, or with K, M, G suffix.\nMinimum: {}, default: {}.",
                                            min_memory_size, default_memory_size)),
         "mem", QString::fromUtf8(default_memory_size)); // In MB's
-    QCommandLineOption nameOption({"n", "name"}, "Name for the instance", "name");
+    QCommandLineOption nameOption(
+        {"n", "name"},
+        QString{"Name for the instance. If it is '%1' (the configured primary instance name), the user's home "
+                "directory is mounted inside the newly launched instance, in '%2'."}
+            .arg(petenv_name, mp::home_automount_dir),
+        "name");
     QCommandLineOption cloudInitOption("cloud-init", "Path to a user-data cloud-init configuration, or '-' for stdin",
                                        "file");
     parser->addOptions({cpusOption, diskOption, memOption, nameOption, cloudInitOption});

src/client/cli/cmd/launch.h

@@ -20,6 +20,8 @@
 
 #include <multipass/cli/command.h>
 
+#include <QString>
+
 namespace multipass
 {
 namespace cmd
@@ -39,6 +41,7 @@ class Launch final : public Command
     ReturnCode request_launch();
 
     LaunchRequest request;
+    QString petenv_name;
 };
 } // namespace cmd
 } // namespace multipass

src/client/cli/cmd/shell.cpp

@@ -106,8 +106,9 @@ mp::ParseCode cmd::Shell::parse_args(mp::ArgParser* parser)
 {
     parser->addPositionalArgument(
         "name",
-        QString{"Name of the instance to open a shell on. If omitted, '%1' will be assumed. If "
-                "the instance is not running, an attempt is made to start it."}
+        QString{
+            "Name of the instance to open a shell on. If omitted, '%1' (the configured primary instance name) will be "
+            "assumed. If the instance is not running, an attempt is made to start it (see `start` for more info)."}
             .arg(petenv_name),
         "[<name>]");
 

src/client/cli/cmd/start.cpp

@@ -134,8 +134,10 @@ mp::ParseCode cmd::Start::parse_args(mp::ArgParser* parser)
 {
     parser->addPositionalArgument(
         "name",
-        QString{"Names of instances to start. If omitted, and without the --all option, '%1' will be assumed."}.arg(
-            petenv_name),
+        QString{"Names of instances to start. If omitted, and without the --all option, '%1' (the configured primary "
+                "instance name) will be assumed. If '%1' does not exist but is included in a successful start command "
+                "(either implicitly or explicitly), it is launched automatically (see `launch` for more info)."}
+            .arg(petenv_name),
         "[<name> ...]");
 
     QCommandLineOption all_option(all_option_name, "Start all instances");

tests/test_cli_client.cpp

@@ -15,6 +15,7 @@
  *
  */
 
+#include "mock_environment_helpers.h"
 #include "mock_settings.h"
 #include "mock_stdcin.h"
 #include "path.h"
@@ -35,6 +36,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include <QtCore/QTemporaryDir>
 #include <sstream>
 
 namespace mp = multipass;
@@ -136,6 +138,20 @@ struct Client : public Test
         return ret;
     }
 
+    auto make_automount_matcher(const QTemporaryDir& fake_home) const
+    {
+        const auto automount_source_matcher =
+            Property(&mp::MountRequest::source_path, StrEq(fake_home.path().toStdString()));
+
+        const auto target_instance_matcher = Property(&mp::TargetPathInfo::instance_name, StrEq(petenv_name()));
+        const auto target_path_matcher = Property(&mp::TargetPathInfo::target_path, StrEq(mp::home_automount_dir));
+        const auto target_info_matcher = AllOf(target_instance_matcher, target_path_matcher);
+        const auto automount_target_matcher =
+            Property(&mp::MountRequest::target_paths, AllOf(Contains(target_info_matcher), SizeIs(1)));
+
+        return AllOf(automount_source_matcher, automount_target_matcher);
+    }
+
     auto make_launch_instance_matcher(const std::string& instance_name)
     {
         return Property(&mp::LaunchRequest::instance_name, StrEq(instance_name));
@@ -349,6 +365,8 @@ TEST_F(Client, shell_cmd_launches_petenv_if_absent)
     const auto petenv_launch_matcher = Property(&mp::LaunchRequest::instance_name, StrEq(petenv_name()));
     const grpc::Status ok{}, notfound{grpc::StatusCode::NOT_FOUND, "msg"};
 
+    EXPECT_CALL(mock_daemon, mount).WillRepeatedly(Return(ok)); // 0 or more times
+
     InSequence seq;
     EXPECT_CALL(mock_daemon, ssh_info(_, petenv_ssh_info_matcher, _)).WillOnce(Return(notfound));
     EXPECT_CALL(mock_daemon, launch(_, petenv_launch_matcher, _)).WillOnce(Return(ok));
@@ -357,6 +375,31 @@ TEST_F(Client, shell_cmd_launches_petenv_if_absent)
     EXPECT_THAT(send_command({"shell", petenv_name()}), Eq(mp::ReturnCode::Ok));
 }
 
+TEST_F(Client, shell_cmd_automounts_when_launching_petenv)
+{
+    const grpc::Status ok{}, notfound{grpc::StatusCode::NOT_FOUND, "msg"};
+
+    InSequence seq;
+    EXPECT_CALL(mock_daemon, ssh_info(_, _, _)).WillOnce(Return(notfound));
+    EXPECT_CALL(mock_daemon, launch(_, _, _)).WillOnce(Return(ok));
+    EXPECT_CALL(mock_daemon, mount(_, _, _)).WillOnce(Return(ok));
+    EXPECT_CALL(mock_daemon, ssh_info(_, _, _)).WillOnce(Return(ok));
+    EXPECT_THAT(send_command({"shell", petenv_name()}), Eq(mp::ReturnCode::Ok));
+}
+
+TEST_F(Client, shell_cmd_fails_when_automounting_in_petenv_fails)
+{
+    const auto ok = grpc::Status{};
+    const auto notfound = grpc::Status{grpc::StatusCode::NOT_FOUND, "msg"};
+    const auto mount_failure = grpc::Status{grpc::StatusCode::INVALID_ARGUMENT, "msg"};
+
+    InSequence seq;
+    EXPECT_CALL(mock_daemon, ssh_info(_, _, _)).WillOnce(Return(notfound));
+    EXPECT_CALL(mock_daemon, launch(_, _, _)).WillOnce(Return(ok));
+    EXPECT_CALL(mock_daemon, mount(_, _, _)).WillOnce(Return(mount_failure));
+    EXPECT_THAT(send_command({"shell", petenv_name()}), Eq(mp::ReturnCode::CommandFail));
+}
+
 TEST_F(Client, shell_cmd_starts_instance_if_stopped_or_suspended)
 {
     const auto instance = "ordinary";
@@ -512,6 +555,39 @@ TEST_F(Client, launch_cmd_cloudinit_option_reads_stdin_ok)
     EXPECT_THAT(send_command({"launch", "--cloud-init", "-"}, trash_stream, trash_stream, ss), Eq(mp::ReturnCode::Ok));
 }
 
+#ifndef WIN32 // TODO make home mocking work for windows
+TEST_F(Client, launch_cmd_automounts_home_in_petenv)
+{
+    const auto fake_home = QTemporaryDir{}; // the client checks the mount source exists
+    const auto env_scope = mpt::SetEnvScope{"HOME", fake_home.path().toUtf8()};
+    const auto home_automount_matcher = make_automount_matcher(fake_home);
+    const auto petenv_launch_matcher = make_launch_instance_matcher(petenv_name());
+    const auto ok = grpc::Status{};
+
+    InSequence seq;
+    EXPECT_CALL(mock_daemon, launch(_, petenv_launch_matcher, _)).WillOnce(Return(ok));
+    EXPECT_CALL(mock_daemon, mount(_, home_automount_matcher, _)).WillOnce(Return(ok));
+    EXPECT_THAT(send_command({"launch", "--name", petenv_name()}), Eq(mp::ReturnCode::Ok));
+}
+#endif
+
+TEST_F(Client, launch_cmd_fails_when_automounting_in_petenv_fails)
+{
+    const grpc::Status ok{}, mount_failure{grpc::StatusCode::INVALID_ARGUMENT, "msg"};
+
+    InSequence seq;
+    EXPECT_CALL(mock_daemon, launch(_, _, _)).WillOnce(Return(ok));
+    EXPECT_CALL(mock_daemon, mount(_, _, _)).WillOnce(Return(mount_failure));
+    EXPECT_THAT(send_command({"launch", "--name", petenv_name()}), Eq(mp::ReturnCode::CommandFail));
+}
+
+TEST_F(Client, launch_cmd_does_not_automount_in_normal_instances)
+{
+    EXPECT_CALL(mock_daemon, launch(_, _, _));
+    EXPECT_CALL(mock_daemon, mount(_, _, _)).Times(0); // because we may want to move from a Strict mock in the future
+    EXPECT_THAT(send_command({"launch"}), Eq(mp::ReturnCode::Ok));
+}
+
 // purge cli tests
 TEST_F(Client, purge_cmd_ok_no_args)
 {
@@ -845,13 +921,40 @@ TEST_F(Client, start_cmd_launches_petenv_if_absent)
     const auto petenv_launch_matcher = make_launch_instance_matcher(petenv_name());
     const grpc::Status ok{}, aborted = aborted_start_status({petenv_name()});
 
+    EXPECT_CALL(mock_daemon, mount).WillRepeatedly(Return(ok)); // 0 or more times
+
     InSequence seq;
     EXPECT_CALL(mock_daemon, start(_, petenv_start_matcher, _)).WillOnce(Return(aborted));
     EXPECT_CALL(mock_daemon, launch(_, petenv_launch_matcher, _)).WillOnce(Return(ok));
     EXPECT_CALL(mock_daemon, start(_, petenv_start_matcher, _)).WillOnce(Return(ok));
     EXPECT_THAT(send_command({"start", petenv_name()}), Eq(mp::ReturnCode::Ok));
 }
 
+TEST_F(Client, start_cmd_automounts_when_launching_petenv)
+{
+    const grpc::Status ok{}, aborted = aborted_start_status({petenv_name()});
+
+    InSequence seq;
+    EXPECT_CALL(mock_daemon, start(_, _, _)).WillOnce(Return(aborted));
+    EXPECT_CALL(mock_daemon, launch(_, _, _)).WillOnce(Return(ok));
+    EXPECT_CALL(mock_daemon, mount(_, _, _)).WillOnce(Return(ok));
+    EXPECT_CALL(mock_daemon, start(_, _, _)).WillOnce(Return(ok));
+    EXPECT_THAT(send_command({"start", petenv_name()}), Eq(mp::ReturnCode::Ok));
+}
+
+TEST_F(Client, start_cmd_fails_when_automounting_in_petenv_fails)
+{
+    const auto ok = grpc::Status{};
+    const auto aborted = aborted_start_status({petenv_name()});
+    const auto mount_failure = grpc::Status{grpc::StatusCode::INVALID_ARGUMENT, "msg"};
+
+    InSequence seq;
+    EXPECT_CALL(mock_daemon, start(_, _, _)).WillOnce(Return(aborted));
+    EXPECT_CALL(mock_daemon, launch(_, _, _)).WillOnce(Return(ok));
+    EXPECT_CALL(mock_daemon, mount(_, _, _)).WillOnce(Return(mount_failure));
+    EXPECT_THAT(send_command({"start", petenv_name()}), Eq(mp::ReturnCode::CommandFail));
+}
+
 TEST_F(Client, start_cmd_launches_petenv_if_absent_among_others_present)
 {
     std::vector<std::string> instances{"a", "b", petenv_name(), "c"}, cmd = concat({"start"}, instances);
@@ -860,6 +963,8 @@ TEST_F(Client, start_cmd_launches_petenv_if_absent_among_others_present)
     const auto petenv_launch_matcher = make_launch_instance_matcher(petenv_name());
     const grpc::Status ok{}, aborted = aborted_start_status({petenv_name()});
 
+    EXPECT_CALL(mock_daemon, mount).WillRepeatedly(Return(ok)); // 0 or more times
+
     InSequence seq;
     EXPECT_CALL(mock_daemon, start(_, instance_start_matcher, _)).WillOnce(Return(aborted));
     EXPECT_CALL(mock_daemon, launch(_, petenv_launch_matcher, _)).WillOnce(Return(ok));