258 lines
9.2 KiB
Python
258 lines
9.2 KiB
Python
#!/usr/bin/env python3
|
|
|
|
|
|
# jp: a SAT command line tool
|
|
# Copyright (C) 2009-2021 Jérôme Poisson (goffi@goffi.org)
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from . import base
|
|
from sat.core.i18n import _
|
|
from sat.tools.common.ansi import ANSI as A
|
|
from sat.tools.common import date_utils, data_format
|
|
from sat_frontends.jp.constants import Const as C
|
|
from sat_frontends.jp import common
|
|
|
|
__commands__ = ["Info"]
|
|
|
|
|
|
class Disco(base.CommandBase):
|
|
|
|
def __init__(self, host):
|
|
extra_outputs = {'default': self.default_output}
|
|
super(Disco, self).__init__(
|
|
host, 'disco', use_output='complex', extra_outputs=extra_outputs,
|
|
help=_('service discovery'))
|
|
|
|
def add_parser_options(self):
|
|
self.parser.add_argument("jid", help=_("entity to discover"))
|
|
self.parser.add_argument(
|
|
"-t", "--type", type=str, choices=('infos', 'items', 'both'), default='both',
|
|
help=_("type of data to discover"))
|
|
self.parser.add_argument("-n", "--node", default='', help=_("node to use"))
|
|
self.parser.add_argument(
|
|
"-C", "--no-cache", dest='use_cache', action="store_false",
|
|
help=_("ignore cache"))
|
|
|
|
def default_output(self, data):
|
|
features = data.get('features', [])
|
|
identities = data.get('identities', [])
|
|
extensions = data.get('extensions', {})
|
|
items = data.get('items', [])
|
|
|
|
identities_table = common.Table(self.host,
|
|
identities,
|
|
headers=(_('category'),
|
|
_('type'),
|
|
_('name')),
|
|
use_buffer=True)
|
|
|
|
extensions_tpl = []
|
|
extensions_types = list(extensions.keys())
|
|
extensions_types.sort()
|
|
for type_ in extensions_types:
|
|
fields = []
|
|
for field in extensions[type_]:
|
|
field_lines = []
|
|
data, values = field
|
|
data_keys = list(data.keys())
|
|
data_keys.sort()
|
|
for key in data_keys:
|
|
field_lines.append(A.color('\t', C.A_SUBHEADER, key, A.RESET, ': ',
|
|
data[key]))
|
|
if len(values) == 1:
|
|
field_lines.append(A.color('\t', C.A_SUBHEADER, "value", A.RESET,
|
|
': ', values[0] or (A.BOLD + "UNSET")))
|
|
elif len(values) > 1:
|
|
field_lines.append(A.color('\t', C.A_SUBHEADER, "values", A.RESET,
|
|
': '))
|
|
|
|
for value in values:
|
|
field_lines.append(A.color('\t - ', A.BOLD, value))
|
|
fields.append('\n'.join(field_lines))
|
|
extensions_tpl.append('{type_}\n{fields}'.format(
|
|
type_=type_,
|
|
fields='\n\n'.join(fields)))
|
|
|
|
items_table = common.Table(
|
|
self.host,
|
|
items,
|
|
headers=(
|
|
_('entity'),
|
|
_('node'),
|
|
_('name')),
|
|
use_buffer=True)
|
|
|
|
template = []
|
|
if features:
|
|
template.append(A.color(C.A_HEADER, _("Features")) + "\n\n{features}")
|
|
if identities:
|
|
template.append(A.color(C.A_HEADER, _("Identities")) + "\n\n{identities}")
|
|
if extensions:
|
|
template.append(A.color(C.A_HEADER, _("Extensions")) + "\n\n{extensions}")
|
|
if items:
|
|
template.append(A.color(C.A_HEADER, _("Items")) + "\n\n{items}")
|
|
|
|
print("\n\n".join(template).format(
|
|
features = '\n'.join(features),
|
|
identities = identities_table.display().string,
|
|
extensions = '\n'.join(extensions_tpl),
|
|
items = items_table.display().string,
|
|
))
|
|
|
|
async def start(self):
|
|
infos_requested = self.args.type in ('infos', 'both')
|
|
items_requested = self.args.type in ('items', 'both')
|
|
jids = await self.host.check_jids([self.args.jid])
|
|
jid = jids[0]
|
|
|
|
# infos
|
|
if not infos_requested:
|
|
infos = None
|
|
else:
|
|
try:
|
|
infos = await self.host.bridge.discoInfos(
|
|
jid,
|
|
node=self.args.node,
|
|
use_cache=self.args.use_cache,
|
|
profile_key=self.host.profile
|
|
)
|
|
except Exception as e:
|
|
self.disp(_(f"error while doing discovery: {e}"), error=True)
|
|
self.host.quit(C.EXIT_BRIDGE_ERRBACK)
|
|
|
|
# items
|
|
if not items_requested:
|
|
items = None
|
|
else:
|
|
try:
|
|
items = await self.host.bridge.discoItems(
|
|
jid,
|
|
node=self.args.node,
|
|
use_cache=self.args.use_cache,
|
|
profile_key=self.host.profile
|
|
)
|
|
except Exception as e:
|
|
self.disp(_(f"error while doing discovery: {e}"), error=True)
|
|
self.host.quit(C.EXIT_BRIDGE_ERRBACK)
|
|
|
|
# output
|
|
data = {}
|
|
|
|
if infos_requested:
|
|
features, identities, extensions = infos
|
|
features.sort()
|
|
identities.sort(key=lambda identity: identity[2])
|
|
data.update({
|
|
'features': features,
|
|
'identities': identities,
|
|
'extensions': extensions})
|
|
|
|
if items_requested:
|
|
items.sort(key=lambda item: item[2])
|
|
data['items'] = items
|
|
|
|
await self.output(data)
|
|
self.host.quit()
|
|
|
|
class Version(base.CommandBase):
|
|
|
|
def __init__(self, host):
|
|
super(Version, self).__init__(host, 'version', help=_('software version'))
|
|
|
|
def add_parser_options(self):
|
|
self.parser.add_argument("jid", type=str, help=_("Entity to request"))
|
|
|
|
async def start(self):
|
|
jids = await self.host.check_jids([self.args.jid])
|
|
jid = jids[0]
|
|
try:
|
|
data = await self.host.bridge.getSoftwareVersion(jid, self.host.profile)
|
|
except Exception as e:
|
|
self.disp(_(f"error while trying to get version: {e}"), error=True)
|
|
self.host.quit(C.EXIT_BRIDGE_ERRBACK)
|
|
else:
|
|
infos = []
|
|
name, version, os = data
|
|
if name:
|
|
infos.append(_(f"Software name: {name}"))
|
|
if version:
|
|
infos.append(_(f"Software version: {version}"))
|
|
if os:
|
|
infos.append(_(f"Operating System: {os}"))
|
|
|
|
print("\n".join(infos))
|
|
self.host.quit()
|
|
|
|
|
|
class Session(base.CommandBase):
|
|
|
|
def __init__(self, host):
|
|
extra_outputs = {'default': self.default_output}
|
|
super(Session, self).__init__(
|
|
host, 'session', use_output='dict', extra_outputs=extra_outputs,
|
|
help=_('running session'))
|
|
|
|
def add_parser_options(self):
|
|
pass
|
|
|
|
async def default_output(self, data):
|
|
started = data['started']
|
|
data['started'] = '{short} (UTC, {relative})'.format(
|
|
short=date_utils.date_fmt(started),
|
|
relative=date_utils.date_fmt(started, 'relative'))
|
|
await self.host.output(C.OUTPUT_DICT, 'simple', {}, data)
|
|
|
|
async def start(self):
|
|
try:
|
|
data = await self.host.bridge.sessionInfosGet(self.host.profile)
|
|
except Exception as e:
|
|
self.disp(_(f'Error getting session infos: {e}'), error=True)
|
|
self.host.quit(C.EXIT_BRIDGE_ERRBACK)
|
|
else:
|
|
await self.output(data)
|
|
self.host.quit()
|
|
|
|
|
|
class Devices(base.CommandBase):
|
|
|
|
def __init__(self, host):
|
|
super(Devices, self).__init__(
|
|
host, 'devices', use_output=C.OUTPUT_LIST_DICT,
|
|
help=_('devices of an entity'))
|
|
|
|
def add_parser_options(self):
|
|
self.parser.add_argument(
|
|
"jid", type=str, nargs='?', default='', help=_("Entity to request"))
|
|
|
|
async def start(self):
|
|
try:
|
|
data = await self.host.bridge.devicesInfosGet(
|
|
self.args.jid, self.host.profile)
|
|
except Exception as e:
|
|
self.disp(_(f'Error getting devices infos: {e}'), error=True)
|
|
self.host.quit(C.EXIT_BRIDGE_ERRBACK)
|
|
else:
|
|
data = data_format.deserialise(data, type_check=list)
|
|
await self.output(data)
|
|
self.host.quit()
|
|
|
|
|
|
class Info(base.CommandBase):
|
|
subcommands = (Disco, Version, Session, Devices)
|
|
|
|
def __init__(self, host):
|
|
super(Info, self).__init__(
|
|
host, 'info', use_profile=False,
|
|
help=_('Get various pieces of information on entities'))
|