Merge lp:~larryprice/libertine/libertined-input into lp:libertine

[Larry Price]

Allow sending input data to libertined during certain container operations.

Allow sending input data to libertined during certain container operations.

[Libertine CI Bot (libertine-ci-bot)]

PASSED: Continuous integration, rev:464
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/505/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/libertine/job/build/910
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=amd64,release=xenial+overlay,testname=default/746
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=amd64,release=zesty,testname=default/746
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=i386,release=xenial+overlay,testname=default/746
    SUCCESS: https://jenkins.canonical.com/libertine/job/test-0-autopkgtest/label=i386,release=zesty,testname=default/746
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-0-fetch/921
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=xenial+overlay/910
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=xenial+overlay/910/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=zesty/910
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=zesty/910/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=xenial+overlay/910
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=xenial+overlay/910/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=zesty/910
        deb: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=zesty/910/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/505/rebuild

review: Approve (continuous-integration)

[lp:~larryprice/libertine/libertined-input]

465. By Larry Price on 2017-04-07

merge

[Libertine CI Bot (libertine-ci-bot)]

FAILED: Continuous integration, rev:465
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/515/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/libertine/job/build/926/console
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-0-fetch/937
    FAILURE: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=xenial+overlay/926/console
    FAILURE: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=zesty/926/console
    FAILURE: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=xenial+overlay/926/console
    FAILURE: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=zesty/926/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/515/rebuild

review: Needs Fixing (continuous-integration)

[lp:~larryprice/libertine/libertined-input]

466. By Larry Price on 2017-04-07

chmod

[Libertine CI Bot (libertine-ci-bot)]

FAILED: Continuous integration, rev:466
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/516/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/libertine/job/build/927/console
    SUCCESS: https://jenkins.canonical.com/libertine/job/build-0-fetch/938
    FAILURE: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=xenial+overlay/927/console
    FAILURE: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=amd64,release=zesty/927/console
    FAILURE: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=xenial+overlay/927/console
    FAILURE: https://jenkins.canonical.com/libertine/job/build-2-binpkg/arch=i386,release=zesty/927/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/libertine/job/lp-libertine-ci/516/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

466. By Larry Price on 2017-04-07

chmod

465. By Larry Price on 2017-04-07

merge

464. By Larry Price on 2017-04-03

fixing up merge and tests

463. By Larry Price on 2017-04-03

merge

462. By Larry Price on 2017-03-31

create with password separate

461. By Larry Price on 2017-03-31

chroot and lxc

460. By Larry Price on 2017-03-30

INPUT! At least for lxd on install/remove...

459. By Larry Price on 2017-03-20

minor changes

458. By Larry Price on 2017-03-20

well these are good ideas but don't work for lxc

457. By Larry Price on 2017-03-20

at some point everything broke?

=== modified file 'python/libertine/ChrootContainer.py'
--- python/libertine/ChrootContainer.py	2017-03-23 19:23:20 +0000
+++ python/libertine/ChrootContainer.py	2017-04-07 17:23:06 +0000
@@ -47,8 +47,8 @@
     A concrete container type implemented using a plain old chroot.
     """
 
-    def __init__(self, container_id, config, service):
-        super().__init__(container_id, 'chroot', config, service)
+    def __init__(self, container_id, config, service, stdin):
+        super().__init__(container_id, 'chroot', config, service, stdin)
         # FIXME: Disabling seccomp is a temporary measure until we fully understand why we need
         #        it or figure out when we need it.
         os.environ['PROOT_NO_SECCOMP'] = '1'
@@ -60,13 +60,13 @@
         command_prefix = "{} fakeroot chroot {}".format(
                     self._build_fakechroot_command(), self.root_path)
         args = shlex.split(command_prefix + ' ' + command_string)
-        cmd = subprocess.Popen(args)
-        return cmd.wait()
+
+        return self._run_with_stdin(args) or subprocess.Popen(args).wait()
 
     def destroy_libertine_container(self, force):
         return self._delete_rootfs()
 
-    def create_libertine_container(self, password=None, multiarch=False):
+    def create_libertine_container(self, multiarch=False):
         # Create the actual chroot
         command_line = "{} fakeroot debootstrap --verbose --variant=fakechroot {} {}".format(
                     self._build_fakechroot_command(), self.installed_release, self.root_path)
@@ -231,6 +231,9 @@
     def finish_application(self, app):
         app.wait()
 
+    def set_password(self, password):
+        pass # No passwords in chroot containers
+
     def _run_ldconfig(self):
         utils.get_logger().info(utils._("Refreshing the container's dynamic linker run-time bindings..."))
 

=== modified file 'python/libertine/Libertine.py'
--- python/libertine/Libertine.py	2017-04-07 17:23:05 +0000
+++ python/libertine/Libertine.py	2017-04-07 17:23:06 +0000
@@ -16,6 +16,8 @@
 import contextlib
 import os
 import shutil
+import subprocess
+import time
 
 from . import utils, ContainerControlClient
 from libertine.ContainersConfig import ContainersConfig
@@ -79,11 +81,12 @@
 
     :param container_id: The machine-readable container name.
     """
-    def __init__(self, container_id, container_type, config, service):
+    def __init__(self, container_id, container_type, config, service, stdin):
         self.container_type = container_type
         self.container_id = container_id
         self._config = config
         self._service = service
+        self._stdin = stdin
         self._app_name = ''
         self._pid = 0
         self.root_path = utils.get_libertine_container_rootfs_path(self.container_id)
@@ -145,7 +148,7 @@
         for language_pack in [p.format(self.language) for p in base_language_packs]:
             self.install_package(language_pack, update_cache=False)
 
-    def create_libertine_container(self, password=None, multiarch=False):
+    def create_libertine_container(self, multiarch=False):
         self.install_base_language_packs()
 
     def destroy_libertine_container(self, force):
@@ -204,6 +207,20 @@
         """
         pass
 
+    def _run_with_stdin(self, command):
+        if self._stdin:
+            p = subprocess.Popen(command, stdin=subprocess.PIPE)
+            while p.poll() is None:
+                if not self._stdin.empty():
+                    p.stdin.write(self._stdin.get())
+                    p.stdin.flush()
+
+                time.sleep(.1)
+
+            return p.returncode
+
+        return None
+
     def update_apt_cache(self):
         """
         Updates the apt cache in the container.
@@ -270,6 +287,11 @@
             return False
         return self.run_in_container(_apt_command_prefix() + "autoremove --purge") == 0
 
+    def set_password(self, password):
+        if password:
+            import crypt
+            return self.run_in_container("usermod -p {password} {username}".format(username=os.environ['USER'], password=crypt.crypt(password)))
+
     def configure_multiarch(self, should_enable):
         """
         Enables or disables multiarch repositories.
@@ -335,10 +357,10 @@
     """
     A concrete mock container type.  Used for unit testing.
     """
-    def __init__(self, container_id, config, service):
-        super().__init__(container_id, 'mock', config, service)
+    def __init__(self, container_id, config, service, stdin):
+        super().__init__(container_id, 'mock', config, service, stdin)
 
-    def create_libertine_container(self, password=None, multiarch=False):
+    def create_libertine_container(self, multiarch=False):
         return True
 
     def destroy_libertine_container(self, force):
@@ -389,7 +411,7 @@
     A sandbox for DEB-packaged X11-based applications.
     """
 
-    def __init__(self, container_id, containers_config=None, service=None):
+    def __init__(self, container_id, containers_config=None, service=None, stdin=None):
         """
         Initializes the container object.
 
@@ -404,15 +426,15 @@
 
         if container_type == "lxc":
             from  libertine.LxcContainer import LibertineLXC
-            self.container = LibertineLXC(container_id, self.containers_config, service)
+            self.container = LibertineLXC(container_id, self.containers_config, service, stdin)
         elif container_type == "lxd":
             from libertine.LxdContainer import LibertineLXD
-            self.container = LibertineLXD(container_id, self.containers_config, service)
+            self.container = LibertineLXD(container_id, self.containers_config, service, stdin)
         elif container_type == "chroot":
             from  libertine.ChrootContainer import LibertineChroot
-            self.container = LibertineChroot(container_id, self.containers_config, service)
+            self.container = LibertineChroot(container_id, self.containers_config, service, stdin)
         elif container_type == "mock":
-            self.container = LibertineMock(container_id, self.containers_config, service)
+            self.container = LibertineMock(container_id, self.containers_config, service, stdin)
         else:
             raise RuntimeError(utils._("Unsupported container type '{container_type}'").format(container_type))
 
@@ -438,14 +460,14 @@
         """
         return self.container.destroy_libertine_container(force)
 
-    def create_libertine_container(self, password=None, multiarch=False):
+    def create_libertine_container(self, multiarch=False):
         """
         Creates the container.
         """
         self.container.architecture = HostInfo().get_host_architecture()
         self.container.installed_release = self.containers_config.get_container_distro(self.container_id)
 
-        return self.container.create_libertine_container(password, multiarch)
+        return self.container.create_libertine_container(multiarch)
 
     def update_libertine_container(self, new_locale=None):
         """
@@ -589,3 +611,10 @@
                 return self.container.configure_remove_archive(archive)
         except RuntimeError as e:
             return handle_runtime_error(e)
+
+    def set_password(self, password):
+        try:
+            with ContainerRunning(self.container):
+                return self.container.set_password(password)
+        except RuntimeError as e:
+            return handle_runtime_error(e)

=== modified file 'python/libertine/LxcContainer.py'
--- python/libertine/LxcContainer.py	2017-03-23 19:23:20 +0000
+++ python/libertine/LxcContainer.py	2017-04-07 17:23:06 +0000
@@ -157,8 +157,8 @@
     A concrete container type implemented using an LXC container.
     """
 
-    def __init__(self, container_id, config, service):
-        super().__init__(container_id, 'lxc', config, service)
+    def __init__(self, container_id, config, service, stdin):
+        super().__init__(container_id, 'lxc', config, service, stdin)
         self.container = lxc_container(container_id)
         self.host_info = HostInfo.HostInfo()
         self._freeze_on_stop = config.get_freeze_on_stop(self.container_id)
@@ -255,8 +255,10 @@
         return lxc_stop(self.container, self._freeze_on_stop)
 
     def run_in_container(self, command_string):
-        cmd_args = shlex.split(command_string)
-        return self.container.attach_wait(lxc.attach_run_command, cmd_args)
+        popen_args = shlex.split("lxc-attach -P {root_path} -n {container_id} -- {command}"
+                                .format(root_path=utils.get_libertine_containers_dir_path(),
+                                        container_id=self.container_id, command=command_string))
+        return self._run_with_stdin(popen_args) or self.container.attach_wait(lxc.attach_run_command, shlex.split(command_string))
 
     def update_packages(self, update_locale=False):
         if self.timezone_needs_update():
@@ -282,10 +284,7 @@
         self.container.destroy()
         return True
 
-    def create_libertine_container(self, password=None, multiarch=False):
-        if password is None:
-            return False
-
+    def create_libertine_container(self, multiarch=False):
         username = os.environ['USER']
         user_id = os.getuid()
         group_id = os.getgid()
@@ -336,8 +335,7 @@
         self.update_locale()
 
         self.run_in_container("userdel -r ubuntu")
-        self.run_in_container("useradd -u {} -p {} -G sudo {}".format(
-                str(user_id), crypt.crypt(password), str(username)))
+        self.run_in_container("useradd -u {} -G sudo {}".format(str(user_id), str(username)))
 
         if multiarch and self.architecture == 'amd64':
             utils.get_logger().info(utils._("Adding i386 multiarch support..."))

=== modified file 'python/libertine/LxdContainer.py'
--- python/libertine/LxdContainer.py	2017-04-07 17:23:05 +0000
+++ python/libertine/LxdContainer.py	2017-04-07 17:23:06 +0000
@@ -387,8 +387,8 @@
 
 
 class LibertineLXD(Libertine.BaseContainer):
-    def __init__(self, name, config, service):
-        super().__init__(name, 'lxd', config, service)
+    def __init__(self, name, config, service, stdin):
+        super().__init__(name, 'lxd', config, service, stdin)
         self._host_info = HostInfo.HostInfo()
         self._container = None
         self._freeze_on_stop = config.get_freeze_on_stop(self.container_id)
@@ -504,7 +504,8 @@
         return _lxc_args(self.container_id, command, environ)
 
     def run_in_container(self, command):
-        return subprocess.Popen(self._lxc_args(command, os.environ.copy())).wait()
+        args = self._lxc_args(command, os.environ.copy())
+        return self._run_with_stdin(args) or subprocess.Popen(args).wait()
 
     def start_container(self, home=env_home_path()):
         if not self._try_get_container():

=== modified file 'python/libertine/service/download.py'
--- python/libertine/service/download.py	2017-04-07 17:23:05 +0000
+++ python/libertine/service/download.py	2017-04-07 17:23:06 +0000
@@ -22,10 +22,11 @@
 
 
 class Download(dbus.service.Object):
-    def __init__(self, connection, id):
+    def __init__(self, connection, id, input_queue):
         self._finished = multiprocessing.Event()
         self._result = multiprocessing.SimpleQueue()
         self._error = multiprocessing.SimpleQueue()
+        self._input = input_queue
         dbus.service.Object.__init__(self, conn=connection, object_path=(constants.DOWNLOAD_OBJECT % id))
 
     @property
@@ -53,6 +54,9 @@
     def data(self, message):
         self._result.put(message)
 
+    def input(self, message):
+        self._input.put(message.encode('utf-8'))
+
     # Signals to satisfy the download interface
 
     @dbus.service.signal(constants.DOWNLOAD_INTERFACE, signature='o')

=== modified file 'python/libertine/service/operations_monitor.py'
--- python/libertine/service/operations_monitor.py	2017-04-07 17:23:05 +0000
+++ python/libertine/service/operations_monitor.py	2017-04-07 17:23:06 +0000
@@ -27,8 +27,8 @@
         self._operations = []
         dbus.service.Object.__init__(self, conn=connection, object_path=constants.OPERATIONS_MONITOR_OBJECT)
 
-    def new_operation(self):
-        self._operations.append(download.Download(self.connection, str(uuid.uuid4().fields[-1])))
+    def new_operation(self, input_queue):
+        self._operations.append(download.Download(self.connection, str(uuid.uuid4().fields[-1]), input_queue))
         return self._operations[-1].id
 
     def remove_from_connection(self, path):

=== modified file 'python/libertine/service/task_dispatcher_base.py'
--- python/libertine/service/task_dispatcher_base.py	2017-04-07 17:23:05 +0000
+++ python/libertine/service/task_dispatcher_base.py	2017-04-07 17:23:06 +0000
@@ -33,7 +33,7 @@
     def _cleanup(self):
         for task in [task for task in self._tasks if task.should_delete]:
             utils.get_logger().debug("Cleaning up task '{}'".format(task.id))
-            task.thread.join()
+            task.join()
             self._monitor.remove_from_connection(task.id)
             self._tasks.remove(task)
 

=== modified file 'python/libertine/service/tasks/base_task.py'
--- python/libertine/service/tasks/base_task.py	2017-04-07 17:23:05 +0000
+++ python/libertine/service/tasks/base_task.py	2017-04-07 17:23:06 +0000
@@ -33,8 +33,11 @@
         self._lock = lock
         self._container = container_id
         self._config = config
+        self._monitor = monitor
+
         self._finished_at = multiprocessing.SimpleQueue()
-        self._monitor = monitor
+        self._stdin = multiprocessing.SimpleQueue()
+        self._thread = None
         self._operation_id = None
         self._delete_at = None
 
@@ -69,14 +72,17 @@
 
         return False
 
+    def join(self):
+        self._thread.join()
+
     def _finish(self):
         self._finished_at.put(time.time())
 
     def start(self):
-        self._operation_id = self._monitor.new_operation()
-        self.thread = multiprocessing.Process(target=self.run)
-        self.thread.start()
-        return self.thread
+        self._operation_id = self._monitor.new_operation(self._stdin)
+        self._thread = multiprocessing.Process(target=self.run)
+        self._thread.start()
+        return self._thread
 
     def watch_file(self, finished, path):
         with open(path, 'rb') as thefile:
@@ -99,6 +105,7 @@
         with output_redirector.OutputRedirector(self._operation_id.split("/")[-1]) as redirector:
             end_watch = multiprocessing.Event()
             multiprocessing.Process(target=self.watch_file, args=(end_watch, redirector.path)).start()
+
             if self._lock is not None:
                 with self._lock:
                     self._refresh_database(False)

=== modified file 'python/libertine/service/tasks/create_task.py'
--- python/libertine/service/tasks/create_task.py	2017-04-07 17:23:05 +0000
+++ python/libertine/service/tasks/create_task.py	2017-04-07 17:23:06 +0000
@@ -32,11 +32,10 @@
 
     def _run(self):
         utils.get_logger().debug("Creating container '%s'" % self._container)
-
         try:
             container = LibertineContainer(self._container, self._config, self._client)
 
-            if not container.create_libertine_container(password='', multiarch=self._multiarch):
+            if not container.create_libertine_container(multiarch=self._multiarch):
                 self._config.delete_container(self._container)
                 self._error("Creating container '%s' failed" % self._container)
             else:

=== modified file 'python/libertine/service/tasks/install_task.py'
--- python/libertine/service/tasks/install_task.py	2017-04-07 17:23:05 +0000
+++ python/libertine/service/tasks/install_task.py	2017-04-07 17:23:06 +0000
@@ -36,7 +36,7 @@
 
     def _run(self):
         utils.get_logger().debug("Installing package '%s'" % self._package)
-        container = LibertineContainer(self._container, self._config, self._client)
+        container = LibertineContainer(self._container, self._config, self._client, self._stdin)
         if container.install_package(self._package, update_cache=self._update_cache, no_dialog=True):
             self._config.update_package_install_status(self._container, self._package_name, "installed")
             utils.refresh_libertine_scope()

=== modified file 'python/libertine/service/tasks/remove_task.py'
--- python/libertine/service/tasks/remove_task.py	2017-04-07 17:23:05 +0000
+++ python/libertine/service/tasks/remove_task.py	2017-04-07 17:23:06 +0000
@@ -31,7 +31,7 @@
 
     def _run(self):
         utils.get_logger().debug("Removing package '%s'" % self._package)
-        container = LibertineContainer(self._container, self._config, self._client)
+        container = LibertineContainer(self._container, self._config, self._client, self._stdin)
         if container.remove_package(self._package, no_dialog=True):
             self._config.delete_package(self._container, self._package)
             utils.refresh_libertine_scope()

=== modified file 'python/libertine/service/tasks/update_task.py'
--- python/libertine/service/tasks/update_task.py	2017-04-07 17:23:05 +0000
+++ python/libertine/service/tasks/update_task.py	2017-04-07 17:23:06 +0000
@@ -32,7 +32,7 @@
 
     def _run(self):
         utils.get_logger().debug("Updating container '%s'" % self._container)
-        container = LibertineContainer(self._container, self._config, self._client)
+        container = LibertineContainer(self._container, self._config, self._client, self._stdin)
         self._config.update_container_install_status(self._container, "updating")
 
         new_locale = self._get_updated_locale()

=== modified file 'tests/unit/service/test_operations_monitor.py'
--- tests/unit/service/test_operations_monitor.py	2017-03-07 20:45:30 +0000
+++ tests/unit/service/test_operations_monitor.py	2017-04-07 17:23:06 +0000
@@ -20,6 +20,7 @@
 class TestOperationsMonitor(TestCase):
     def setUp(self):
         self._connection = unittest.mock.Mock()
+        self._stdin = unittest.mock.Mock()
 
     def test_new_operation_returns_some_id(self):
         with unittest.mock.patch('dbus.service.Object'):
@@ -27,7 +28,7 @@
             monitor._connection = self._connection
 
             with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
-                self.assertIsNotNone(monitor.new_operation())
+                self.assertIsNotNone(monitor.new_operation(self._stdin))
 
     def test_remove_connection(self):
         with unittest.mock.patch('dbus.service.Object'):
@@ -35,7 +36,7 @@
             monitor._connection = self._connection
 
             with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
-                monitor.remove_from_connection(monitor.new_operation())
+                monitor.remove_from_connection(monitor.new_operation(self._stdin))
                 MockDownload.return_value.remove_from_connection.assert_called_once_with()
 
     def test_returns_done_for_operation(self):
@@ -45,10 +46,10 @@
 
             with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
                 MockDownload.return_value.done = True
-                self.assertTrue(monitor.done(monitor.new_operation()))
+                self.assertTrue(monitor.done(monitor.new_operation(self._stdin)))
 
                 MockDownload.return_value.done = False
-                self.assertFalse(monitor.done(monitor.new_operation()))
+                self.assertFalse(monitor.done(monitor.new_operation(self._stdin)))
 
                 # non-existent operation
                 self.assertFalse(monitor.done("123456"))
@@ -60,10 +61,10 @@
 
             with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
                 MockDownload.return_value.done = True
-                self.assertFalse(monitor.running(monitor.new_operation()))
+                self.assertFalse(monitor.running(monitor.new_operation(self._stdin)))
 
                 MockDownload.return_value.done = False
-                self.assertTrue(monitor.running(monitor.new_operation()))
+                self.assertTrue(monitor.running(monitor.new_operation(self._stdin)))
 
                 # non-existent operation
                 self.assertFalse(monitor.running("123456"))
@@ -75,7 +76,7 @@
 
             with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
                 MockDownload.return_value.result = "pokemongus"
-                self.assertEqual("pokemongus", monitor.result(monitor.new_operation()))
+                self.assertEqual("pokemongus", monitor.result(monitor.new_operation(self._stdin)))
 
                 # non-existent operation
                 self.assertEqual("", monitor.result("123456"))
@@ -87,7 +88,7 @@
 
             with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
                 MockDownload.return_value.last_error = "pokemongus"
-                self.assertEqual("pokemongus", monitor.last_error(monitor.new_operation()))
+                self.assertEqual("pokemongus", monitor.last_error(monitor.new_operation(self._stdin)))
 
                 # non-existent operation
                 self.assertEqual("", monitor.last_error("123456"))
@@ -99,7 +100,7 @@
             monitor._locations = []
 
             with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
-                path = monitor.new_operation()
+                path = monitor.new_operation(self._stdin)
                 monitor.finished(path)
                 MockDownload.return_value.finished.assert_called_once_with(path)
 
@@ -115,7 +116,7 @@
             monitor._locations = []
 
             with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
-                path = monitor.new_operation()
+                path = monitor.new_operation(self._stdin)
                 monitor.error(path, "something messed up")
                 MockDownload.return_value.error.assert_called_once_with("something messed up")
 
@@ -131,7 +132,7 @@
             monitor._locations = []
 
             with unittest.mock.patch('libertine.service.operations_monitor.download.Download') as MockDownload:
-                path = monitor.new_operation()
+                path = monitor.new_operation(self._stdin)
                 monitor.data(path, "some of that gud data")
                 MockDownload.return_value.data.assert_called_once_with("some of that gud data")
 

=== modified file 'tools/libertine-container-manager'
--- tools/libertine-container-manager	2017-03-23 19:23:20 +0000
+++ tools/libertine-container-manager	2017-04-07 17:23:06 +0000
@@ -34,7 +34,6 @@
         self.containers_config = ContainersConfig()
         self.host_info = HostInfo()
 
-
     def _container(self, container_id):
         try:
             return LibertineContainer(container_id, self.containers_config)
@@ -53,7 +52,25 @@
             return host_locale
 
     def create(self, args):
+        if not args.type:
+            container_type = self.host_info.select_container_type_by_kernel()
+        else:
+            if (args.type == 'lxc' and not self.host_info.has_lxc_support()) or \
+               (args.type == 'lxd' and not self.host_info.has_lxd_support()):
+                libertine.utils.get_logger().error(utils._("System kernel does not support {type} type containers. "
+                                                           "Please either use chroot or omit the -t option.").format(type=args.type))
+                sys.exit(1)
+            container_type = args.type
+
         password = None
+        if container_type == "lxc" or container_type == "lxd":
+            if args.password:
+                password = args.password
+            elif sys.stdin.isatty():
+                print(utils._("Enter password for your user in the Libertine container or leave blank for no password:"))
+                password = getpass.getpass()
+            else:
+                password = sys.stdin.readline().rstrip()
 
         if args.distro and not self.host_info.is_distro_valid(args.distro, args.force):
             utils.get_logger().error(utils._("Invalid distro {distro}").format(distro=args.distro))
@@ -67,16 +84,6 @@
                                                  "form ([a-z0-9][a-z0-9+.-]+).").format(container_id=args.id))
             sys.exit(1)
 
-        if not args.type:
-            container_type = self.host_info.select_container_type_by_kernel()
-        else:
-            if (args.type == 'lxc' and not self.host_info.has_lxc_support()) or \
-               (args.type == 'lxd' and not self.host_info.has_lxd_support()):
-                utils.get_logger().error(utils._("System kernel does not support {container_type} type containers. "
-                                                   "Please either use chroot or omit the -t option.").format(container_type=args.type))
-                sys.exit(1)
-            container_type = args.type
-
         if not args.distro:
             args.distro = self.host_info.get_host_distro_release()
         elif container_type == "chroot":
@@ -91,15 +98,6 @@
         if not args.name:
             args.name = "Ubuntu \'" + (self.host_info.get_distro_codename(args.distro) or args.distro) + "\'"
 
-        if container_type == "lxc" or container_type == "lxd":
-            if args.password:
-                password = args.password
-            elif sys.stdin.isatty():
-                print(utils._("Enter password for your user in the Libertine container or leave blank for no password:"))
-                password = getpass.getpass()
-            else:
-                password = sys.stdin.readline().rstrip()
-
         self.containers_config.add_new_container(args.id, args.name, container_type, args.distro)
 
         multiarch = 'disabled'
@@ -125,6 +123,8 @@
             self.containers_config.delete_container(args.id)
             sys.exit(1)
 
+        container.set_password(password)
+
         self.containers_config.update_container_install_status(args.id, "ready")
 
         utils.refresh_libertine_scope()