def install(self, pkg: SnapApplication, root_password: str,
watcher: ProcessWatcher) -> bool:
res, output = ProcessHandler(watcher).handle_simple(
snap.install_and_stream(pkg.name, pkg.confinement, root_password))
if 'error:' in output:
res = False
if 'not available on stable' in output:
channels = RE_AVAILABLE_CHANNELS.findall(output)
if channels:
opts = [
InputOption(label=c[0], value=c[1]) for c in channels
]
channel_select = SingleSelectComponent(
type_=SelectViewType.RADIO,
label='',
options=opts,
default_option=opts[0])
body = '<p>{}.</p>'.format(
self.i18n['snap.install.available_channels.message'].
format(bold(self.i18n['stable']), bold(pkg.name)))
body += '<p>{}:</p>'.format(
self.i18n['snap.install.available_channels.help'])
if watcher.request_confirmation(
title=self.
i18n['snap.install.available_channels.title'],
body=body,
components=[channel_select],
confirmation_label=self.i18n['continue'],
deny_label=self.i18n['cancel']):
self.logger.info(
"Installing '{}' with the custom command '{}'".
format(pkg.name, channel_select.value))
res = ProcessHandler(watcher).handle(
SystemProcess(
new_root_subprocess(
channel_select.value.value.split(' '),
root_password=root_password)))
if res:
pkg.has_apps_field = snap.has_apps_field(
pkg.name, self.ubuntu_distro)
return res
else:
self.logger.error(
"Could not find available channels in the installation output: {}"
.format(output))
else:
pkg.has_apps_field = snap.has_apps_field(pkg.name,
self.ubuntu_distro)
return res
def _fill_categories(self, app: SnapApplication):
categories = self.categories.get(app.name.lower())
if categories:
app.categories = categories
if not app.is_application():
categories = app.categories
if categories is None:
categories = []
app.categories = categories
if 'runtime' not in categories:
categories.append('runtime')
def map_json(self, app_json: dict, installed: bool, disk_loader: DiskCacheLoader, internet: bool = True) -> SnapApplication:
app = SnapApplication(publisher=app_json.get('publisher'),
rev=app_json.get('rev'),
notes=app_json.get('notes'),
app_type=app_json.get('type'),
id=app_json.get('name'),
name=app_json.get('name'),
version=app_json.get('version'),
latest_version=app_json.get('version'),
description=app_json.get('description', app_json.get('summary')))
if app.publisher:
app.publisher = app.publisher.replace('*', '')
app.installed = installed
api_data = self.api_cache.get(app_json['name'])
expired_data = api_data and api_data.get('expires_at') and api_data['expires_at'] <= datetime.utcnow()
if (not api_data or expired_data) and app.is_application():
if disk_loader and app.installed:
disk_loader.fill(app)
if internet:
SnapAsyncDataLoader(app=app, api_cache=self.api_cache, manager=self, context=self.context).start()
else:
app.fill_cached_data(api_data)
return app
def _map_to_app(self,
app_json: dict,
installed: bool,
disk_loader: Optional[DiskCacheLoader] = None,
is_application: bool = False) -> SnapApplication:
app = SnapApplication(
id=app_json.get('id'),
name=app_json.get('name'),
license=app_json.get('license'),
version=app_json.get('version'),
latest_version=app_json.get('version'),
description=app_json.get('description', app_json.get('summary')),
installed=installed,
rev=app_json.get('revision'),
publisher=app_json['publisher'].get(
'display-name', app_json['publisher'].get('username')),
verified_publisher=app_json['publisher'].get(
'validation') == 'verified',
icon_url=app_json.get('icon'),
screenshots={
m['url']
for m in app_json.get('media', []) if m['type'] == 'screenshot'
},
download_size=app_json.get('download-size'),
channel=app_json.get('channel'),
confinement=app_json.get('confinement'),
app_type=app_json.get('type'),
app=is_application,
installed_size=app_json.get('installed-size'),
extra_actions=self.custom_actions)
if disk_loader and app.installed:
disk_loader.fill(app)
self._fill_categories(app)
app.status = PackageStatus.READY
return app
def map_json(self,
app_json: dict,
installed: bool,
disk_loader: DiskCacheLoader,
internet: bool = True) -> SnapApplication:
app = SnapApplication(
publisher=app_json.get('publisher'),
rev=app_json.get('rev'),
notes=app_json.get('notes'),
has_apps_field=app_json.get('apps_field', False),
id=app_json.get('name'),
name=app_json.get('name'),
version=app_json.get('version'),
latest_version=app_json.get('version'),
description=app_json.get('description', app_json.get('summary')),
verified_publisher=app_json.get('developer_validation',
'') == 'verified')
if app.publisher and app.publisher.endswith('*'):
app.verified_publisher = True
app.publisher = app.publisher.replace('*', '')
categories = self.categories.get(app.name.lower())
if categories:
app.categories = categories
app.installed = installed
if not app.is_application():
categories = app.categories
if categories is None:
categories = []
app.categories = categories
if 'runtime' not in categories:
categories.append('runtime')
api_data = self.api_cache.get(app_json['name'])
expired_data = api_data and api_data.get(
'expires_at') and api_data['expires_at'] <= datetime.utcnow()
if (not api_data or expired_data) and app.is_application():
if disk_loader and app.installed:
disk_loader.fill(app)
if internet:
SnapAsyncDataLoader(app=app,
api_cache=self.api_cache,
manager=self,
context=self.context).start()
else:
app.fill_cached_data(api_data)
return app
def install(self, pkg: SnapApplication, root_password: str,
disk_loader: DiskCacheLoader,
watcher: ProcessWatcher) -> TransactionResult:
info_path = self.get_info_path()
if not info_path:
self.logger.warning(
'Information directory was not found. It will not be possible to determine if the installed application can be launched'
)
# retrieving all installed so it will be possible to know the additional installed runtimes after the operation succeeds
installed_names = snap.list_installed_names()
res, output = ProcessHandler(watcher).handle_simple(
snap.install_and_stream(pkg.name, pkg.confinement, root_password))
if 'error:' in output:
res = False
if 'not available on stable' in output:
channels = RE_AVAILABLE_CHANNELS.findall(output)
if channels:
opts = [
InputOption(label=c[0], value=c[1]) for c in channels
]
channel_select = SingleSelectComponent(
type_=SelectViewType.RADIO,
label='',
options=opts,
default_option=opts[0])
body = '<p>{}.</p>'.format(
self.i18n['snap.install.available_channels.message'].
format(bold(self.i18n['stable']), bold(pkg.name)))
body += '<p>{}:</p>'.format(
self.i18n['snap.install.available_channels.help'])
if watcher.request_confirmation(
title=self.
i18n['snap.install.available_channels.title'],
body=body,
components=[channel_select],
confirmation_label=self.i18n['continue'],
deny_label=self.i18n['cancel']):
self.logger.info(
"Installing '{}' with the custom command '{}'".
format(pkg.name, channel_select.value))
res = ProcessHandler(watcher).handle(
SystemProcess(
new_root_subprocess(
channel_select.value.value.split(' '),
root_password=root_password)))
if res and info_path:
pkg.has_apps_field = snap.has_apps_field(
pkg.name, info_path)
return self._gen_installation_response(
success=res,
pkg=pkg,
installed=installed_names,
disk_loader=disk_loader)
else:
self.logger.error(
"Could not find available channels in the installation output: {}"
.format(output))
else:
if info_path:
pkg.has_apps_field = snap.has_apps_field(pkg.name, info_path)
return self._gen_installation_response(success=res,
pkg=pkg,
installed=installed_names,
disk_loader=disk_loader)
def get_screenshots(self, pkg: SnapApplication) -> List[str]:
return pkg.screenshots if pkg.has_screenshots() else []
def install(self, pkg: SnapApplication, root_password: str,
disk_loader: DiskCacheLoader,
watcher: ProcessWatcher) -> TransactionResult:
# retrieving all installed so it will be possible to know the additional installed runtimes after the operation succeeds
if not snap.is_installed():
watcher.print("'snap' seems not to be installed")
return TransactionResult.fail()
if not snapd.is_running():
watcher.print("'snapd' seems not to be running")
return TransactionResult.fail()
installed_names = {
s['name']
for s in SnapdClient(self.logger).list_all_snaps()
}
client = SnapdClient(self.logger)
snap_config = read_config()
try:
channel = self._request_channel_installation(
pkg=pkg,
snap_config=snap_config,
snapd_client=client,
watcher=watcher)
pkg.channel = channel
except:
watcher.print('Aborted by user')
return TransactionResult.fail()
res, output = ProcessHandler(watcher).handle_simple(
snap.install_and_stream(app_name=pkg.name,
confinement=pkg.confinement,
root_password=root_password,
channel=channel))
if 'error:' in output:
res = False
if 'not available on stable' in output:
channels = RE_AVAILABLE_CHANNELS.findall(output)
if channels:
opts = [
InputOption(label=c[0], value=c[1]) for c in channels
]
channel_select = SingleSelectComponent(
type_=SelectViewType.RADIO,
label='',
options=opts,
default_option=opts[0])
body = '<p>{}.</p>'.format(
self.i18n['snap.install.available_channels.message'].
format(bold(self.i18n['stable']), bold(pkg.name)))
body += '<p>{}:</p>'.format(
self.i18n['snap.install.available_channels.help'])
if watcher.request_confirmation(
title=self.
i18n['snap.install.available_channels.title'],
body=body,
components=[channel_select],
confirmation_label=self.i18n['continue'],
deny_label=self.i18n['cancel']):
self.logger.info(
"Installing '{}' with the custom command '{}'".
format(pkg.name, channel_select.value))
res = ProcessHandler(watcher).handle(
SystemProcess(
new_root_subprocess(
channel_select.value.value.split(' '),
root_password=root_password)))
return self._gen_installation_response(
success=res,
pkg=pkg,
installed=installed_names,
disk_loader=disk_loader)
else:
self.logger.error(
"Could not find available channels in the installation output: {}"
.format(output))
return self._gen_installation_response(success=res,
pkg=pkg,
installed=installed_names,
disk_loader=disk_loader)