def _run(self):
utils.get_logger().debug("Listing app ids from container '%s'" %
self._container)
self._data(
json.dumps(
LibertineContainer(self._container, self._config,
self._client).list_app_ids()))
def _get_running_apps_per_container(self):
self._invalid_apps = dict()
self._operations = Counter()
config = libertine.ContainersConfig.ContainersConfig()
for container in config.get_containers():
running_apps = config.get_running_apps(container).copy()
for app in running_apps:
try:
proc = psutil.Process(app['pid'])
if app['appExecName'] in proc.cmdline():
self._operations[container] += 1
else:
raise
except:
utils.get_logger().error(
utils._(
"Container app '{application_name}' is not valid."
).format(application_name=app['appExecName']))
if container not in self._invalid_apps:
self._invalid_apps[container] = [{
app['appExecName'], app['pid']
}]
else:
self._invalid_apps[container].append(
{app['appExecName'], app['pid']})
config.delete_running_app(container, app)
continue
def _before(self):
utils.get_logger().debug("UpdateTask::_before")
if not self._config.container_exists(self._container):
self._error("Container '%s' does not exist, skipping update" % self._container)
return False
return True
def _before(self):
utils.get_logger().debug("CreateTask::_before")
if self._config.container_exists(self._container):
self._error("Container '%s' already exists" % self._container)
return False
info = HostInfo()
if not self._distro:
self._distro = info.get_host_distro_release()
elif not info.is_distro_valid(self._distro):
self._error("Invalid distro '%s'." % self._distro)
return False
if not self._type:
self._type = info.select_container_type_by_kernel()
elif (self._type == 'lxd' and not info.has_lxd_support()) or \
(self._type == 'lxc' and not info.has_lxc_support()):
self._error("System kernel does not support %s type containers. "
"Please either use chroot or leave empty." % self._type)
return False
if not self._name:
self._name = "Ubuntu \'" + info.get_distro_codename(self._distro) + "\'"
self._config.add_new_container(self._container, self._name, self._type, self._distro)
if self._multiarch:
self._config.update_container_multiarch_support(self._container, 'enabled')
self._config.update_container_install_status(self._container, 'installing')
return True
def list_app_ids(self):
utils.get_logger().debug("List all app ids in container '%s'" % self.id)
task = ListAppIdsTask(self.id, self._config, self._monitor, self._client, self._cleanup_task)
self._tasks.append(task)
task.start()
return task.id
def list(self):
utils.get_logger().debug("dispatching list all containers")
task = ListTask(self._config, self._monitor, self._cleanup_task)
self._tasks.append(task)
task.start()
return task.id
def _cleanup_task(self, task):
utils.get_logger().debug("cleaning up tasks for container '%s'" % self.id)
if task in self._tasks:
self._tasks.remove(task)
if len(self._tasks) == 0:
self._callback(self)
def list(self):
utils.get_logger().debug("dispatching list all containers")
task = ListTask(self._config, self._monitor, self._cleanup_task)
self._tasks.append(task)
task.start()
return task.id
def _run(self):
utils.get_logger().debug("Updating container '%s'" % self._container)
container = LibertineContainer(self._container, self._config, self._client)
self._config.update_container_install_status(self._container, "updating")
if not container.update_libertine_container():
self._error("Failed to update container '%s'" % self._container)
self._config.update_container_install_status(self._container, "ready")
def _before(self):
utils.get_logger().debug("CreateTask::_before")
if self._config._get_value_by_key(self._container, 'installStatus') != 'ready':
self._error("Container '%s' does not exist" % self._container)
return False
self._config.update_container_install_status(self._container, 'removing')
return True
def _run(self):
utils.get_logger().debug("Installing package '%s'" % self._package)
container = LibertineContainer(self._container, self._config, self._client)
if container.install_package(self._package):
self._config.update_package_install_status(self._container, self._package, "installed")
self._finished()
else:
self._config.delete_package(self._container, self._package)
self._error("Package installation failed for '%s'" % self._package)
def _before(self):
utils.get_logger().debug("InstallTask::_before")
if self._config.package_exists(self._container, self._package):
self._error("Package '%s' already exists, skipping install" % self._package)
return False
else:
self._config.add_new_package(self._container, self._package)
self._config.update_package_install_status(self._container, self._package, "installing")
return True
def _before(self):
utils.get_logger().debug("CreateTask::_before")
if self._config._get_value_by_key(self._container,
'installStatus') != 'ready':
self._error("Container '%s' does not exist" % self._container)
return False
self._config.update_container_install_status(self._container,
'removing')
return True
def create(self,
container_id,
container_name='',
distro='',
container_type='',
enable_multiarch=False):
utils.get_logger().debug("create('{}', '{}', '{}', '{}', '{}')".format(
container_id, container_name, distro, container_type,
enable_multiarch))
return self._dispatcher.create(container_id, container_name, distro,
container_type, enable_multiarch)
def search(self, query):
utils.get_logger().debug("search container '%s' for package '%s'" % (self.id, query))
if utils.is_snap_environment():
raise Exception("This operation is not currently supported within the snap")
task = SearchTask(self.id, self._cache, query, self._monitor, self._cleanup_task)
self._tasks.append(task)
task.start()
return task.id
def _run(self):
utils.get_logger().debug("Destroying container '%s'" % self._container)
container = LibertineContainer(self._container, self._config, self._client)
if not container.destroy_libertine_container():
self._error("Destroying container '%s' failed" % self._container)
self._config.update_container_install_status(self._container, "ready")
return
self._config.delete_container(self._container)
self._finished()
def remove(self, package_name):
utils.get_logger().debug("Remove package '%s' from container '%s'" % (package_name, self.id))
tasks = [t for t in self._tasks if t.matches(package_name, RemoveTask) and t.running]
if len(tasks) > 0:
utils.get_logger().debug("Remove already in progress for '%s':'%s'" % (package_name, self.id))
return tasks[0].id
task = RemoveTask(package_name, self.id, self._config, self._lock, self._monitor, self._client, self._cleanup_task)
self._tasks.append(task)
task.start()
return task.id
def app_info(self, package_name):
utils.get_logger().debug("get info for package '%s' in container '%s'" % (package_name, self.id))
if utils.is_snap_environment():
raise Exception("This operation is not currently supported within the snap")
related_task_ids = [t.id for t in self._tasks if t.package == package_name and t.running]
task = AppInfoTask(self.id, self._cache, package_name, related_task_ids, self._config, self._monitor, self._cleanup_task)
self._tasks.append(task)
task.start()
return task.id
def _run(self):
utils.get_logger().debug("Installing package '%s'" % self._package)
container = LibertineContainer(self._container, self._config,
self._client)
if container.install_package(self._package):
self._config.update_package_install_status(self._container,
self._package,
"installed")
self._finished()
else:
self._config.delete_package(self._container, self._package)
self._error("Package installation failed for '%s'" % self._package)
def _before(self):
utils.get_logger().debug("RemoveTask::_before")
if self._config.get_package_install_status(
self._container, self._package) == 'installed':
self._config.update_package_install_status(self._container,
self._package,
"removing")
return True
else:
self._error("Package '%s' not installed, skipping remove" %
self._package)
return False
def _run(self):
utils.get_logger().debug("Gathering info for container '{}'".format(self._container))
container = {'id': str(self._container), 'task_ids': self._tasks}
container['status'] = self._config.get_container_install_status(self._container) or ''
container['name'] = self._config.get_container_name(self._container) or ''
container_type = self._config.get_container_type(self._container)
container['root'] = utils.get_libertine_container_rootfs_path(self._container)
container['home'] = utils.get_libertine_container_home_dir(self._container)
self._data(json.dumps(container))
def _run(self):
utils.get_logger().debug("Removing package '%s'" % self._package)
container = LibertineContainer(self._container, self._config,
self._client)
if container.remove_package(self._package):
self._config.delete_package(self._container, self._package)
self._finished()
else:
self._config.update_package_install_status(self._container,
self._package,
'installed')
self._error("Package removal failed for '%s'" % self._package)
def container_info(self, container_id):
utils.get_logger().debug("dispatching get info for container '%s'" % container_id)
related_task_ids = []
container = self._find_container(container_id)
if container is not None:
related_task_ids = container.tasks
task = ContainerInfoTask(container_id, related_task_ids, self._config, self._monitor, self._cleanup_task)
self._tasks.append(task)
task.start()
return task.id
def _before(self):
utils.get_logger().debug("InstallTask::_before")
if self._config.package_exists(self._container, self._package):
self._error("Package '%s' already exists, skipping install" %
self._package)
return False
else:
self._config.add_new_package(self._container, self._package)
self._config.update_package_install_status(self._container,
self._package,
"installing")
return True
def _find_or_create_container(self, container_id):
utils.get_logger().debug("finding or creating container '%s'" % container_id)
container = self._find_container(container_id)
if container is not None:
utils.get_logger().debug("using existing container '%s'" % container_id)
return container
container = Container(container_id, self._config, self._monitor, self._client, self._cleanup_container)
self._containers.append(container)
return container
def destroy(self):
utils.get_logger().debug("Destroy container with ID '%s'" % self.id)
tasks = [t for t in self._tasks if t.matches(self.id, DestroyTask) and t.running]
if len(tasks) > 0:
utils.get_logger().debug("Destroy already in progress for '%s'" % self.id)
return tasks[0].id
task = DestroyTask(self.id, self._config, self._lock, self._monitor, self._client, self._cleanup_task)
self._tasks.append(task)
task.start()
return task.id
def _run(self):
utils.get_logger().debug("Destroying container '%s'" % self._container)
container = LibertineContainer(self._container, self._config,
self._client)
if not container.destroy_libertine_container():
self._error("Destroying container '%s' failed" % self._container)
self._config.update_container_install_status(
self._container, "ready")
return
self._config.delete_container(self._container)
self._finished()
def create(self, container_name, distro, container_type, enable_multiarch):
utils.get_logger().debug("Create container with ID '%s'" % self.id)
tasks = [t for t in self._tasks if t.matches(self.id, CreateTask) and t.running]
if len(tasks) > 0:
utils.get_logger().debug("Create already in progress for '%s'" % self.id)
return tasks[0].id
task = CreateTask(self.id, container_name, distro, container_type, enable_multiarch,
self._config, self._lock, self._monitor, self._client, self._cleanup_task)
self._tasks.append(task)
task.start()
return task.id
def container_info(self, container_id):
utils.get_logger().debug("dispatching get info for container '%s'" %
container_id)
related_task_ids = []
container = self._find_container(container_id)
if container is not None:
related_task_ids = container.tasks
task = ContainerInfoTask(container_id, related_task_ids, self._config,
self._monitor, self._cleanup_task)
self._tasks.append(task)
task.start()
return task.id
def __init__(self, container_id, config, monitor, client, callback):
self._id = container_id
self._config = config
self._monitor = monitor
self._client = client
self._callback = callback
self._lock = Lock()
self._tasks = []
if utils.is_snap_environment():
utils.get_logger().warning(utils._("Using AptCache not currently supported in snap environment"))
self._cache = None
else:
self._cache = apt.AptCache(self.id)
def _load(self):
with self._lock:
if self._cache is None:
try:
utils.get_logger().debug(
"Trying aptcache for container %s" % self._container)
container_path = utils.get_libertine_container_rootfs_path(
self._container)
if not container_path or not path.exists(container_path):
raise PermissionError
self._cache = apt.Cache(rootdir=container_path)
except PermissionError:
utils.get_logger().debug("Trying system aptcache")
self._cache = apt.Cache()
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):
self._config.delete_container(self._container)
self._error("Creating container '%s' failed" % self._container)
else:
self._config.update_container_install_status(self._container, "ready")
self._finished()
except RuntimeError as e:
self._config.delete_container(self._container)
self._error(str(e))
def _find_or_create_container(self, container_id):
utils.get_logger().debug("finding or creating container '%s'" %
container_id)
container = self._find_container(container_id)
if container is not None:
utils.get_logger().debug("using existing container '%s'" %
container_id)
return container
container = Container(container_id, self._config, self._monitor,
self._client, self._cleanup_container)
self._containers.append(container)
return container
def _get_running_apps_per_container(self):
self._invalid_apps = dict()
self._operations = Counter()
config = libertine.ContainersConfig.ContainersConfig()
for container in config.get_containers():
running_apps = config.get_running_apps(container).copy()
for app in running_apps:
try:
proc = psutil.Process(app['pid'])
if app['appExecName'] in proc.cmdline():
self._operations[container] += 1
else:
raise
except:
utils.get_logger().error(utils._("Container app '{application_name}' is not valid.").format(application_name=app['appExecName']))
if container not in self._invalid_apps:
self._invalid_apps[container] = [{app['appExecName'], app['pid']}]
else:
self._invalid_apps[container].append({app['appExecName'], app['pid']})
config.delete_running_app(container, app)
continue
def start(self, container):
utils.get_logger().debug("start({})".format(container))
return self._client.container_operation_start(container)
def finished(self, container, app_name, pid):
utils.get_logger().debug("finished({})".format(container))
return self._client.container_operation_finished(
container, app_name, pid)
def stopped(self, container):
utils.get_logger().debug("stopped({})".format(container))
return self._client.container_stopped(container)
def error(self, message):
utils.get_logger().error("emit error(%s)" % message)
self._error = message
self._finished = True
def start(self, container):
utils.get_logger().debug("start({})".format(container))
return self._client.container_operation_start(container)
def finished(self, container, app_name, pid):
utils.get_logger().debug("finished({})".format(container))
return self._client.container_operation_finished(container, app_name, pid)
def finished(self, path):
utils.get_logger().debug("emit finished('%s')" % path)
self._finished = True
def progress(self, received, total):
utils.get_logger().debug("emit progress(%d, %d)" % (received, total))
def stopped(self, container):
utils.get_logger().debug("stopped({})".format(container))
return self._client.container_stopped(container)
def processing(self, path):
utils.get_logger().debug("emit processing('%s')" % path)
def list_app_ids(self, container_id):
utils.get_logger().debug("dispatching list apps ids in container '%s'" % container_id)
return self._find_or_create_container(container_id).list_app_ids()
def _run(self):
utils.get_logger().debug("Listing app ids from container '%s'" % self._container)
self._data(json.dumps(LibertineContainer(self._container, self._config, self._client).list_app_ids()))
def error(self, message):
utils.get_logger().error("emit error(%s)" % message)
self._error = message
self._finished = True
