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 _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 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 _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 _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 __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 _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 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 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()))