def run(self, context, args, kwargs, opargs):
volume = self.parent.entity
result = list(iterate_vdevs(volume['topology']))
return Table(result, [
Table.Column('Name', 'path'),
Table.Column('Status', 'status')
])
def run(self, context, args, kwargs, opargs):
vols = context.connection.call_sync('volumes.find')
return Table(vols, [
Table.Column('ID', 'id'),
Table.Column('Volume name', 'name'),
Table.Column('Status', 'status')
])
def run(self, context, args, kwargs, opargs):
volume = context.call_sync('zfs.pool.get_boot_pool')
result = list(iterate_vdevs(volume['groups']))
return Table(result, [
Table.Column('Name', 'path'),
Table.Column('Status', 'status')
])
def run(self, context, args, kwargs, opargs, filtering=None):
cols = []
params = []
options = {}
if filtering:
for k, v in filtering['params'].items():
if k == 'limit':
options['limit'] = int(v)
continue
if k == 'sort':
for sortkey in v:
prop = self.parent.get_mapping(sortkey)
options.setdefault('sort', []).append(prop.get)
continue
if not self.parent.has_property(k):
raise CommandException('Unknown field {0}'.format(k))
params = list(self.__map_filter_properties(
filtering['filter']))
for col in filter(lambda x: x.list, self.parent.property_mappings):
cols.append(Table.Column(col.descr, col.get, col.type))
return Table(self.parent.query(params, options), cols)
def run(self, context, args, kwargs, opargs):
media = context.connection.call_sync('volumes.find_media')
return Table(media, [
Table.Column('Path', 'path'),
Table.Column('Label', 'label'),
Table.Column('Size', 'size'),
Table.Column('Filesystem type', 'fstype')
])
def run(self, context, args, kwargs, opargs, input=None):
field = args[0]
if isinstance(input, Table):
input.data = map(lambda x: {'result': x.get(field)}, input.data)
input.columns = [Table.Column('Result', 'result')]
return input
def run(self, context, args, kwargs, opargs):
items = context.call_sync('sessions.query', *parse_query_args(args, kwargs))
return Table(items, [
Table.Column('Session ID', 'id', ValueType.NUMBER),
Table.Column('IP address', 'address', ValueType.STRING),
Table.Column('User name', 'username', ValueType.STRING),
Table.Column('Started at', 'started-at', ValueType.TIME),
Table.Column('Ended at', 'ended-at', ValueType.TIME)
])
def run(self, context, args, kwargs, opargs):
self.context = context
tasks = context.connection.call_sync('task.query')
return Table(tasks, [
Table.Column('ID', 'id'),
Table.Column('Started at', 'started_at', ValueType.TIME),
Table.Column('Finished at', 'finished_at', ValueType.TIME),
Table.Column('Description', self.describe_task),
Table.Column('State', self.describe_state)
])
def run(self, context, args, kwargs, opargs):
items = context.call_sync('event.query', *parse_query_args(args, kwargs))
return Table(items, [
Table.Column('Event name', lambda t: events.translate(context, t['name'], t['args'])),
Table.Column('Time', 'timestamp', ValueType.TIME)
])
def run(self, context, args, kwargs, opargs):
display_props = False
if "properties" in args:
display_props = True
obj = context.ml.get_relative_object(context.ml.path[-1], args)
bases = map(lambda x: x.__name__, obj.__class__.__bases__)
if display_props:
if hasattr(obj, 'property_mappings'):
prop_dict_list = []
for prop in obj.property_mappings:
prop_dict = {
'propname': prop.name,
'propdescr': prop.descr
}
prop_dict_list.append(prop_dict)
return Table(prop_dict_list, [
Table.Column('Property', 'propname', ValueType.STRING),
Table.Column('Description', 'propdescr', ValueType.STRING)
])
else:
output_msg(
"The current namespace does not have any properties.")
return
if 'Command' in bases and obj.__doc__:
if hasattr(obj, 'parent'):
if obj.__class__.__name__ in obj.parent.localdoc:
output_msg(
textwrap.dedent(
obj.parent.localdoc[obj.__class__.__name__]))
else:
output_msg(inspect.getdoc(obj))
else:
output_msg(inspect.getdoc(obj))
if 'PipeCommand' in bases and obj.__doc__:
output_msg(inspect.getdoc(obj))
if any(i in ['Namespace', 'EntityNamespace'] for i in bases):
# First listing the Current Namespace's commands
cmd_dict_list = []
ns_cmds = obj.commands()
for key, value in ns_cmds.iteritems():
cmd_dict = {
'cmd': key,
'description': value.description,
}
cmd_dict_list.append(cmd_dict)
# Then listing the namespaces available from this namespace
namespaces_dict_list = []
for nss in obj.namespaces():
if not isinstance(nss, EntityNamespace.SingleItemNamespace):
namespace_dict = {
'name': nss.name,
'description': nss.description,
}
namespaces_dict_list.append(namespace_dict)
# Finally listing the builtin cmds
builtin_cmd_dict_list = []
for key, value in context.ml.builtin_commands.iteritems():
builtin_cmd_dict = {
'cmd': key,
'description': value.description,
}
builtin_cmd_dict_list.append(builtin_cmd_dict)
# Finally printing all this out in unix `LESS(1)` pager style
output_call_list = []
if cmd_dict_list:
output_call_list.append(
Table(cmd_dict_list, [
Table.Column('Command', 'cmd', ValueType.STRING),
Table.Column('Description', 'description',
ValueType.STRING)
]))
if namespaces_dict_list:
output_call_list.append(
Table(namespaces_dict_list, [
Table.Column('Namespace', 'name', ValueType.STRING),
Table.Column('Description', 'description',
ValueType.STRING)
]))
# Only display the help on builtin commands if in the RootNamespace
if obj.__class__.__name__ == 'RootNamespace':
output_call_list.append(
Table(builtin_cmd_dict_list, [
Table.Column('Builtin Command', 'cmd',
ValueType.STRING),
Table.Column('Description', 'description',
ValueType.STRING)
]))
output_less(lambda: output_table_list(output_call_list))