def show(cls, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8, colors=not args.no_color, pastable=args.pastable)
tbl.add_column("ResourceName")
tbl.add_column("SnapshotName")
tbl.add_column("NodeNames")
tbl.add_column("Volumes")
tbl.add_column("State", color=Output.color(Color.DARKGREEN, args.no_color))
for snapshot_dfn in lstmsg.snapshot_dfns:
if FLAG_DELETE in snapshot_dfn.snapshot_dfn_flags:
state_cell = tbl.color_cell("DELETING", Color.RED)
elif FLAG_FAILED_DEPLOYMENT in snapshot_dfn.snapshot_dfn_flags:
state_cell = tbl.color_cell("Failed", Color.RED)
elif FLAG_FAILED_DISCONNECT in snapshot_dfn.snapshot_dfn_flags:
state_cell = tbl.color_cell("Satellite disconnected", Color.RED)
elif FLAG_SUCCESSFUL in snapshot_dfn.snapshot_dfn_flags:
state_cell = tbl.color_cell("Successful", Color.DARKGREEN)
else:
state_cell = tbl.color_cell("Incomplete", Color.DARKBLUE)
tbl.add_row([
snapshot_dfn.rsc_name,
snapshot_dfn.snapshot_name,
", ".join([snapshot.node_name for snapshot in snapshot_dfn.snapshots]),
", ".join([
str(snapshot_vlm_dfn.vlm_nr) + ": " + SizeCalc.approximate_size_string(snapshot_vlm_dfn.vlm_size)
for snapshot_vlm_dfn in snapshot_dfn.snapshot_vlm_dfns]),
state_cell
])
tbl.show()
def show_volumes(cls, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
tbl.add_column("Node")
tbl.add_column("Resource")
tbl.add_column("StoragePool")
tbl.add_column("VolumeNr")
tbl.add_column("MinorNr")
tbl.add_column("DeviceName")
tbl.add_column("State",
color=Output.color(Color.DARKGREEN, args.no_color),
just_txt='>')
for rsc in lstmsg.resources:
rsc_state = ResourceCommands.get_resource_state(
lstmsg.resource_states, rsc.node_name, rsc.name)
for vlm in rsc.vlms:
vlm_state = ResourceCommands.get_volume_state(
rsc_state.vlm_states, vlm.vlm_nr) if rsc_state else None
state_txt, color = cls.volume_state_cell(
vlm_state, rsc.rsc_flags, vlm.vlm_flags)
state = tbl.color_cell(state_txt,
color) if color else state_txt
tbl.add_row([
rsc.node_name, rsc.name, vlm.stor_pool_name,
str(vlm.vlm_nr),
str(vlm.vlm_minor_nr), vlm.device_path, state
])
tbl.show()
def show(self, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8, colors=not args.no_color, pastable=args.pastable)
for hdr in self._stor_pool_headers:
tbl.add_header(hdr)
tbl.set_groupby(args.groupby if args.groupby else [self._stor_pool_headers[0].name])
for storpool in lstmsg.stor_pools:
driver_device = self._linstor.storage_props_to_driver_pool(storpool.driver[:-len('Driver')], storpool.props)
supports_snapshots_prop = [x for x in storpool.static_traits if x.key == KEY_STOR_POOL_SUPPORTS_SNAPSHOTS]
supports_snapshots = supports_snapshots_prop[0].value if supports_snapshots_prop else ''
provisioning_prop = [x for x in storpool.static_traits if x.key == KEY_STOR_POOL_PROVISIONING]
provisioning = provisioning_prop[0].value if provisioning_prop else ''
freespace = ""
if provisioning == VAL_STOR_POOL_PROVISIONING_THIN:
freespace = "(thin)"
elif storpool.driver != 'DisklessDriver' and storpool.HasField("free_space"):
freespace = SizeCalc.approximate_size_string(storpool.free_space.free_space)
tbl.add_row([
storpool.stor_pool_name,
storpool.node_name,
storpool.driver,
driver_device,
freespace,
supports_snapshots
])
tbl.show()
def _print_props(cls, prop_list_map, args):
"""Print properties in machine or human readable format"""
if args.machine_readable:
s = ''
if prop_list_map:
d = [[{"key": x, "value": prop_list_map[0][x]} for x in prop_list_map[0]]]
s = json.dumps(d, indent=2)
print(s)
return None
property_map_count = len(prop_list_map)
if property_map_count == 0:
print(Output.color_str("No property map found for this entry.", Color.YELLOW, args.no_color))
return None
tbl = linstor_client.Table(utf8=not args.no_utf8, colors=not args.no_color, pastable=args.pastable)
tbl.add_column("Key")
tbl.add_column("Value")
if property_map_count > 0:
prop_map = prop_list_map[0]
for p in sorted(prop_map.keys()):
tbl.add_row([p, prop_map[p]])
tbl.show()
if property_map_count > 1:
print(Output.color_str("Unexpected additional property data, ignoring.", Color.YELLOW, args.no_color))
def show(cls, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8, colors=not args.no_color, pastable=args.pastable)
vlm_dfn_hdrs = list(cls._vlm_dfn_headers)
if args.external_name:
vlm_dfn_hdrs.insert(1, linstor_client.TableHeader("External"))
for hdr in vlm_dfn_hdrs:
tbl.add_header(hdr)
tbl.set_groupby(args.groupby if args.groupby else [tbl.header_name(0)])
for rsc_dfn in lstmsg.resource_definitions:
for vlmdfn in rsc_dfn.volume_definitions:
state = tbl.color_cell("ok", Color.DARKGREEN)
if FLAG_DELETE in vlmdfn.flags:
state = tbl.color_cell("DELETING", Color.RED)
elif FLAG_RESIZE in vlmdfn.flags:
state = tbl.color_cell("resizing", Color.DARKPINK)
drbd_data = vlmdfn.drbd_data
tbl.add_row([
rsc_dfn.name,
vlmdfn.number,
drbd_data.minor if drbd_data else "",
SizeCalc.approximate_size_string(vlmdfn.size),
"+" if FLAG_GROSS_SIZE in vlmdfn.flags else "",
state
])
tbl.show()
def show(cls, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
rsc_dfn_hdr = list(cls._rsc_dfn_headers)
if args.external_name:
rsc_dfn_hdr.insert(1, linstor_client.TableHeader("External"))
for hdr in rsc_dfn_hdr:
tbl.add_header(hdr)
tbl.set_groupby(args.groupby if args.groupby else [tbl.header_name(0)])
for rsc_dfn in lstmsg.resource_definitions:
drbd_data = rsc_dfn.drbd_data
row = [rsc_dfn.name]
if args.external_name and isinstance(rsc_dfn.external_name, str):
row.append(rsc_dfn.external_name)
row.append(drbd_data.port if drbd_data else "")
row.append(rsc_dfn.resource_group_name)
row.append(
tbl.color_cell("DELETING", Color.RED) if FLAG_DELETE in
rsc_dfn.flags else tbl.color_cell("ok", Color.DARKGREEN))
tbl.add_row(row)
tbl.show()
def show_enclosures(cls, args, list_msg):
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
header = list(cls._exos_enclosure_headers)
for hdr in header:
tbl.add_header(hdr)
tbl.set_groupby([tbl.header_name(0)])
health_colors_dict = {"OK": Color.GREEN}
for encl in list_msg.exos_enclosures:
if encl.health in health_colors_dict:
health_color = health_colors_dict[encl.health]
else:
health_color = Color.RED
row = [
encl.name, encl.ctrl_a_ip if encl.ctrl_a_ip else "-",
encl.ctrl_b_ip if encl.ctrl_b_ip else "-",
tbl.color_cell(encl.health, health_color),
encl.health_reason if encl.health_reason else ""
]
tbl.add_row(row)
tbl.show()
def show_nodes(cls, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
for hdr in cls._node_headers:
tbl.add_header(hdr)
conn_stat_dict = {
apiconsts.CONN_STATUS_OFFLINE: ("OFFLINE", Color.RED),
apiconsts.CONN_STATUS_CONNECTED: ("Connected", Color.YELLOW),
apiconsts.CONN_STATUS_ONLINE: ("Online", Color.GREEN),
apiconsts.CONN_STATUS_VERSION_MISMATCH:
("OFFLINE(VERSION MISMATCH)", Color.RED),
apiconsts.CONN_STATUS_FULL_SYNC_FAILED:
("OFFLINE(FULL SYNC FAILED)", Color.RED),
apiconsts.CONN_STATUS_AUTHENTICATION_ERROR:
("OFFLINE(AUTHENTICATION ERROR)", Color.RED),
apiconsts.CONN_STATUS_UNKNOWN: ("Unknown", Color.YELLOW)
}
tbl.set_groupby(args.groupby if args.groupby else [tbl.header_name(0)])
node_list = [x for x in lstmsg.nodes
if x.name in args.nodes] if args.nodes else lstmsg.nodes
for n in node_list:
ips = [if_.address for if_ in n.net_interfaces]
conn_stat = conn_stat_dict[n.connection_status]
tbl.add_row([
n.name, n.type, ",".join(ips),
tbl.color_cell(conn_stat[0], conn_stat[1])
])
tbl.show()
def _show_query_max_volume(cls, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8, colors=not args.no_color, pastable=args.pastable)
tbl.add_column("StoragePool")
tbl.add_column("MaxVolumeSize", just_txt='>')
tbl.add_column("Nodes")
def limited_string(obj_list):
limit = 40
s = ""
list_length = len(obj_list)
for i in range(0, len(obj_list)):
obj = obj_list[i]
s += obj + (", " if i != list_length - 1 else "")
if len(s) > limit:
s = s[:limit-3] + "..."
return s
for candidate in lstmsg.candidates:
if candidate.all_thin:
max_vlm_size = "(thin)"
else:
max_vlm_size = SizeCalc.approximate_size_string(candidate.max_vlm_size)
tbl.add_row([
candidate.stor_pool_name,
max_vlm_size,
limited_string(candidate.node_names)
])
tbl.show()
def show(cls, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
tbl.add_column("StoragePool")
for storpool_dfn in lstmsg.storage_pool_definitions:
tbl.add_row([storpool_dfn.name])
tbl.show()
def _show_query_max_volume(self, args, lstmsg):
"""
DEPRECATED will be removed
:param args:
:param lstmsg:
:return:
"""
print(
Output.color_str("DEPRECATED:", Color.YELLOW, args.no_color) +
" use `linstor controller query-max-volume-size`")
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
tbl.add_column("StoragePool")
tbl.add_column("MaxVolumeSize", just_txt='>')
tbl.add_column("Provisioning")
tbl.add_column("Nodes")
def limited_string(obj_list):
limit = 40
s = ""
list_length = len(obj_list)
for i in range(0, len(obj_list)):
obj = obj_list[i]
s += obj + (", " if i != list_length - 1 else "")
if len(s) > limit:
s = s[:limit - 3] + "..."
return s
storage_pool_dfns = self.get_linstorapi().storage_pool_dfn_list(
)[0].storage_pool_definitions
for candidate in lstmsg.candidates:
max_vlm_size = SizeCalc.approximate_size_string(
candidate.max_volume_size)
storage_pool_props = [
x for x in storage_pool_dfns
if x.name == candidate.storage_pool
][0].properties
max_oversubscription_ratio_props = \
[x for x in storage_pool_props if x.key == KEY_STOR_POOL_DFN_MAX_OVERSUBSCRIPTION_RATIO]
max_oversubscription_ratio_prop = max_oversubscription_ratio_props[0].value \
if max_oversubscription_ratio_props \
else lstmsg.default_max_oversubscription_ratio
max_oversubscription_ratio = float(max_oversubscription_ratio_prop)
tbl.add_row([
candidate.storage_pool, max_vlm_size,
"Thin, oversubscription ratio " +
str(max_oversubscription_ratio)
if candidate.all_thin else "Thick",
limited_string(candidate.node_names)
])
tbl.show()
def show_table(self, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
for hdr in FileCommands._file_headers:
tbl.add_header(hdr)
for file in lstmsg.files:
tbl.add_row([file.path])
tbl.show()
def show(cls, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
tbl.add_column("ResourceName")
tbl.add_column("SnapshotName")
tbl.add_column("NodeNames")
tbl.add_column("Volumes")
tbl.add_column("CreatedOn")
tbl.add_column("State",
color=Output.color(Color.DARKGREEN, args.no_color))
for snapshot_dfn in lstmsg.snapshots:
if FLAG_DELETE in snapshot_dfn.flags:
state_cell = tbl.color_cell("DELETING", Color.RED)
elif FLAG_FAILED_DEPLOYMENT in snapshot_dfn.flags:
state_cell = tbl.color_cell("Failed", Color.RED)
elif FLAG_FAILED_DISCONNECT in snapshot_dfn.flags:
state_cell = tbl.color_cell("Satellite disconnected",
Color.RED)
elif FLAG_SUCCESSFUL in snapshot_dfn.flags:
in_backup_restore = False
in_backup_create = False
if FLAG_BACKUP in snapshot_dfn.flags and FLAG_SHIPPING in snapshot_dfn.flags:
for snap in snapshot_dfn.snapshots:
in_backup_create |= FLAG_BACKUP_SOURCE in snap.flags
in_backup_restore |= FLAG_BACKUP_TARGET in snap.flags
if in_backup_create:
state_cell = tbl.color_cell("Shipping", Color.YELLOW)
elif in_backup_restore:
state_cell = tbl.color_cell("Restoring", Color.YELLOW)
else:
state_cell = tbl.color_cell("Successful", Color.DARKGREEN)
else:
state_cell = tbl.color_cell("Incomplete", Color.DARKBLUE)
snapshot_date = ""
if snapshot_dfn.snapshots and snapshot_dfn.snapshots[
0].create_datetime:
snapshot_date = str(
snapshot_dfn.snapshots[0].create_datetime)[:19]
tbl.add_row([
snapshot_dfn.resource_name, snapshot_dfn.name,
", ".join([node_name for node_name in snapshot_dfn.nodes]),
", ".join([
str(snapshot_vlm_dfn.number) + ": " +
SizeCalc.approximate_size_string(snapshot_vlm_dfn.size)
for snapshot_vlm_dfn in
snapshot_dfn.snapshot_volume_definitions
]), snapshot_date, state_cell
])
tbl.show()
def maintenance(self, args):
state = self._state_of_the_world()
found_issues = []
rsc_to_check = args.resources or state.resource_definitions.keys()
for rsc_name in rsc_to_check:
if (args.node, rsc_name) not in state.resources:
# Resource not deployed on node
continue
diskfull_nodes = [
node for (node, name), rsc in state.resources.items() if
name == rsc_name and apiconsts.FLAG_DISKLESS not in rsc.flags
]
if diskfull_nodes == [args.node]:
found_issues.append(
_Issue(resource=rsc_name,
what=_Issue.WHAT_SINGLE_REPLICA,
fix=_Issue.FIX_AUTOPLACE.format(rsc=rsc_name,
count=2)))
continue
all_deployed = [
node for (node, name), rsc in state.resources.items()
if name == rsc_name
]
if len(all_deployed) < 3:
# TODO: include quorum information: if explicit quorum is set, this advise is likely wrong
# Also, in case the node to check is diskless, we may need to advise to add another diskfull replica.
found_issues.append(
_Issue(
resource=rsc_name,
what=_Issue.WHAT_POTENTIAL_SPLIT_BRAIN,
fix=_Issue.FIX_AUTOPLACE_TIEBREAKER.format(
rsc=rsc_name),
))
if args.machine_readable:
json.dump([issue.__dict__ for issue in found_issues], sys.stdout)
else:
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
tbl.add_headers(AdviceCommands._issue_headers)
for issue in found_issues:
tbl.add_row([issue.resource, issue.what, issue.fix])
tbl.show()
def show(cls, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8, colors=not args.no_color, pastable=args.pastable)
for hdr in cls._rsc_dfn_headers:
tbl.add_header(hdr)
tbl.set_groupby(args.groupby if args.groupby else [tbl.header_name(0)])
for rsc_dfn in cls.filter_rsc_dfn_list(lstmsg.rsc_dfns, args.resources):
tbl.add_row([
rsc_dfn.rsc_name,
rsc_dfn.rsc_dfn_port,
tbl.color_cell("DELETING", Color.RED)
if FLAG_DELETE in rsc_dfn.rsc_dfn_flags else tbl.color_cell("ok", Color.DARKGREEN)
])
tbl.show()
def show(cls, args, lstmsg):
vlm_grps = lstmsg # type: linstor.responses.VolumeGroupResponse
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
for hdr in cls._vlm_grp_headers:
tbl.add_header(hdr)
tbl.set_groupby(args.groupby if args.groupby else [tbl.header_name(0)])
for vlm_grp in vlm_grps.volume_groups:
row = [str(vlm_grp.number)]
tbl.add_row(row)
tbl.show()
def show_nodes(cls, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8, colors=not args.no_color, pastable=args.pastable)
node_hdr = list(cls._node_headers)
if args.show_aux_props:
node_hdr.insert(-1, linstor_client.TableHeader("AuxProps"))
for hdr in node_hdr:
tbl.add_header(hdr)
conn_stat_dict = {
apiconsts.ConnectionStatus.OFFLINE.name: ("OFFLINE", Color.RED),
apiconsts.ConnectionStatus.CONNECTED.name: ("Connected", Color.YELLOW),
apiconsts.ConnectionStatus.ONLINE.name: ("Online", Color.GREEN),
apiconsts.ConnectionStatus.VERSION_MISMATCH.name: ("OFFLINE(VERSION MISMATCH)", Color.RED),
apiconsts.ConnectionStatus.FULL_SYNC_FAILED.name: ("OFFLINE(FULL SYNC FAILED)", Color.RED),
apiconsts.ConnectionStatus.AUTHENTICATION_ERROR.name: ("OFFLINE(AUTHENTICATION ERROR)", Color.RED),
apiconsts.ConnectionStatus.UNKNOWN.name: ("Unknown", Color.YELLOW),
apiconsts.ConnectionStatus.HOSTNAME_MISMATCH.name: ("OFFLINE(HOSTNAME MISMATCH)", Color.RED),
apiconsts.ConnectionStatus.OTHER_CONTROLLER.name: ("OFFLINE(OTHER_CONTROLLER)", Color.RED),
apiconsts.ConnectionStatus.NO_STLT_CONN.name: ("OFFLINE(NO CONNECTION TO SATELLITE)", Color.RED)
}
tbl.set_groupby(args.groupby if args.groupby else [tbl.header_name(0)])
for node in lstmsg.nodes:
# concat a ip list with satellite connection indicator
active_ip = ""
for net_if in node.net_interfaces:
if net_if.is_active and net_if.stlt_port:
active_ip = net_if.address + ":" + str(net_if.stlt_port) + " (" + net_if.stlt_encryption_type + ")"
aux_props = ["{k}={v}".format(k=k, v=v)
for k, v in node.properties.items() if k.startswith(apiconsts.NAMESPC_AUXILIARY + '/')]
if apiconsts.FLAG_EVICTED in node.flags:
conn_stat = (apiconsts.FLAG_EVICTED, Color.RED)
elif apiconsts.FLAG_DELETE in node.flags:
conn_stat = (apiconsts.FLAG_DELETE, Color.RED)
else:
conn_stat = conn_stat_dict.get(node.connection_status)
row = [node.name, node.type, active_ip]
if args.show_aux_props:
row.append("\n".join(aux_props))
row += [tbl.color_cell(conn_stat[0], conn_stat[1])]
tbl.add_row(row)
tbl.show()
def _print_props(cls, prop_list_map, args):
"""Print properties in machine or human readable format"""
if args.machine_readable:
d = [[protobuf_to_dict(y) for y in x] for x in prop_list_map]
s = json.dumps(d, indent=2)
print(s)
return None
for prop_map in prop_list_map:
tbl = linstor_client.Table(utf8=not args.no_utf8, colors=not args.no_color, pastable=args.pastable)
tbl.add_column("Key")
tbl.add_column("Value")
for p in prop_map:
tbl.add_row([p.key, p.value])
tbl.show()
def show_netinterfaces(cls, args, lstnodes):
node = NodeCommands.find_node(lstnodes, args.node_name)
if node:
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
tbl.add_column(node.name, color=Color.GREEN)
tbl.add_column("NetInterface")
tbl.add_column("IP")
for netif in node.net_interfaces:
tbl.add_row(["+", netif.name, netif.address])
tbl.show()
else:
raise LinstorClientError(
"Node '{n}' not found on controller.".format(n=args.node_name),
ExitCode.OBJECT_NOT_FOUND)
def show_error_report_list(self, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8, colors=not args.no_color, pastable=args.pastable)
tbl.add_header(linstor_client.TableHeader("Nr.", alignment_text=">"))
tbl.add_header(linstor_client.TableHeader("Id"))
tbl.add_header(linstor_client.TableHeader("Datetime"))
tbl.add_header(linstor_client.TableHeader("Node"))
i = 1
for error in lstmsg:
tbl.add_row([
str(i),
error.id,
str(error.datetime)[:19],
error.node_names
])
i += 1
tbl.show()
def show_exos_dflts(cls, args, exos_dflts):
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
header = list(cls._exos_defaults_headers)
for hdr in header:
tbl.add_header(hdr)
# tbl.set_groupby([tbl.header_name(0)])
tbl.add_row(cls._get_row("Username", exos_dflts.username))
tbl.add_row(cls._get_row("UsernameEnv", exos_dflts.username_env))
tbl.add_row(cls._get_row("Password", exos_dflts.password))
tbl.add_row(cls._get_row("PasswordEnv", exos_dflts.password_env))
tbl.show()
def _show_query_max_volume(self, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
tbl.add_column("StoragePool")
tbl.add_column("MaxVolumeSize", just_txt='>')
tbl.add_column("Provisioning")
tbl.add_column("Nodes")
def limited_string(obj_list):
limit = 40
s = ""
list_length = len(obj_list)
for i in range(0, len(obj_list)):
obj = obj_list[i]
s += obj + (", " if i != list_length - 1 else "")
if len(s) > limit:
s = s[:limit - 3] + "..."
return s
storage_pool_dfns = self.get_linstorapi().storage_pool_dfn_list(
)[0].storage_pool_definitions
for candidate in lstmsg.candidates:
max_vlm_size = SizeCalc.approximate_size_string(
candidate.max_volume_size)
storage_pool_props = [
x for x in storage_pool_dfns
if x.name == candidate.storage_pool
][0].properties
max_oversubscription_ratio = float(
storage_pool_props.get(
KEY_STOR_POOL_DFN_MAX_OVERSUBSCRIPTION_RATIO,
lstmsg.default_max_oversubscription_ratio))
tbl.add_row([
candidate.storage_pool, max_vlm_size,
"Thin, oversubscription ratio " +
str(max_oversubscription_ratio)
if candidate.all_thin else "Thick",
limited_string(candidate.node_names)
])
tbl.show()
def show_map(cls, args, list_msg):
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
header = list(cls._exos_map_headers)
for hdr in header:
tbl.add_header(hdr)
tbl.set_groupby([tbl.header_name(0)])
for con_map in list_msg.exos_connections:
row = [
con_map.node_name, con_map.enclosure_name,
", ".join(con_map.connections)
]
tbl.add_row(row)
tbl.show()
def show(self, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
for hdr in self._stor_pool_headers:
tbl.add_header(hdr)
storage_pool_resp = lstmsg # type: StoragePoolListResponse
tbl.set_groupby(args.groupby if args.
groupby else [self._stor_pool_headers[0].name])
errors = []
for storpool in storage_pool_resp.storage_pools:
driver_device = linstor.StoragePoolDriver.storage_props_to_driver_pool(
storpool.provider_kind, storpool.properties)
free_capacity = ""
total_capacity = ""
if not storpool.is_diskless() and storpool.free_space is not None:
free_capacity = SizeCalc.approximate_size_string(
storpool.free_space.free_capacity)
total_capacity = SizeCalc.approximate_size_string(
storpool.free_space.total_capacity)
for error in storpool.reports:
if error not in errors:
errors.append(error)
state_str, state_color = self.get_replies_state(storpool.reports)
tbl.add_row([
storpool.name, storpool.node_name, storpool.provider_kind,
driver_device, free_capacity, total_capacity,
storpool.supports_snapshots(),
tbl.color_cell(state_str,
state_color), storpool.free_space_mgr_name
if ':' not in storpool.free_space_mgr_name else ''
])
tbl.show()
for err in errors:
Output.handle_ret(err,
warn_as_error=args.warn_as_error,
no_color=args.no_color)
def show(self, args, lstmsg):
rsc_dfns = self._linstor.resource_dfn_list()
if isinstance(rsc_dfns[0], linstor.ApiCallResponse):
return self.handle_replies(args, rsc_dfns)
rsc_dfns = rsc_dfns[0].proto_msg.rsc_dfns
rsc_dfn_map = {x.rsc_name: x for x in rsc_dfns}
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
for hdr in ResourceCommands._resource_headers:
tbl.add_header(hdr)
tbl.set_groupby(args.groupby if args.groupby else
[ResourceCommands._resource_headers[0].name])
for rsc in lstmsg.resources:
rsc_dfn = rsc_dfn_map[rsc.name]
marked_delete = apiconsts.FLAG_DELETE in rsc.rsc_flags
rsc_state_proto = ResourceCommands.find_rsc_state(
lstmsg.resource_states, rsc.name, rsc.node_name)
rsc_state = tbl.color_cell("Unknown", Color.YELLOW)
if marked_delete:
rsc_state = tbl.color_cell("DELETING", Color.RED)
elif rsc_state_proto:
if rsc_state_proto.HasField(
'in_use') and rsc_state_proto.in_use:
rsc_state = tbl.color_cell("InUse", Color.GREEN)
else:
for vlm in rsc.vlms:
vlm_state = ResourceCommands.get_volume_state(
rsc_state_proto.vlm_states,
vlm.vlm_nr) if rsc_state_proto else None
state_txt, color = self.volume_state_cell(
vlm_state, rsc.rsc_flags, vlm.vlm_flags)
rsc_state = tbl.color_cell(state_txt, color)
if color is not None:
break
tbl.add_row(
[rsc.name, rsc.node_name, rsc_dfn.rsc_dfn_port, rsc_state])
tbl.show()
def show(self, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8, colors=not args.no_color, pastable=args.pastable)
for hdr in self._rsc_grp_headers:
tbl.add_header(hdr)
rsc_grps = lstmsg # type: ResourceGroupResponse
tbl.set_groupby(args.groupby if args.groupby else [tbl.header_name(0)])
for rsc_grp in rsc_grps.resource_groups:
vlm_grps = self.get_linstorapi().volume_group_list_raise(rsc_grp.name).volume_groups
row = [
rsc_grp.name,
str(rsc_grp.select_filter),
",".join([str(x.number) for x in vlm_grps]),
rsc_grp.description
]
tbl.add_row(row)
tbl.show()
def show_ship_list(self, args, shipping_resp):
"""
:param args:
:param shipping_resp: ShippingResponse
:return:
"""
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
tbl.add_headers(self._shipping_headers)
for shipping in shipping_resp.shippings:
tbl.add_row([
shipping.snapshot_dfn.resource_name,
shipping.snapshot_dfn.snapshot_name, shipping.from_node_name,
shipping.to_node_name,
tbl.color_cell(
shipping.status.value, None if shipping.status
== consts.SnapshotShipStatus.COMPLETE else Color.YELLOW)
])
tbl.show()
def resource(self, args):
state = self._state_of_the_world()
found_issues = []
rsc_to_check = args.resources or state.resource_definitions.keys()
for rsc_name in rsc_to_check:
r_def = state.resource_definitions[rsc_name]
rg = state.resource_groups[r_def.resource_group_name
or "DfltRscGrp"]
r_deployed = {
node: r
for (node, name), r in state.resources.items()
if name == rsc_name
}
r_states = {
node: r
for (node, name), r in state.resource_states.items()
if name == rsc_name
}
found_issues.extend(
_check_needless_diskless(r_def, r_deployed, r_states, rg,
state.storage_pools))
found_issues.extend(
_check_expected_replicas(r_def, r_deployed, r_states, rg,
state.storage_pools))
if args.machine_readable:
json.dump([issue.__dict__ for issue in found_issues], sys.stdout)
else:
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
tbl.add_headers(AdviceCommands._issue_headers)
for issue in found_issues:
tbl.add_row([issue.resource, issue.what, issue.fix])
tbl.show()
def show(cls, args, lstmsg):
tbl = linstor_client.Table(utf8=not args.no_utf8,
colors=not args.no_color,
pastable=args.pastable)
for hdr in cls._vlm_dfn_headers:
tbl.add_header(hdr)
tbl.set_groupby(args.groupby if args.groupby else [tbl.header_name(0)])
for rsc_dfn in cls.filter_rsc_dfn_list(lstmsg.rsc_dfns,
args.resources):
for vlmdfn in rsc_dfn.vlm_dfns:
state = tbl.color_cell("ok", Color.DARKGREEN)
if FLAG_DELETE in rsc_dfn.rsc_dfn_flags:
state = tbl.color_cell("DELETING", Color.RED)
elif FLAG_RESIZE in vlmdfn.vlm_flags:
state = tbl.color_cell("resizing", Color.DARKPINK)
tbl.add_row([
rsc_dfn.rsc_name, vlmdfn.vlm_nr, vlmdfn.vlm_minor,
SizeCalc.approximate_size_string(vlmdfn.vlm_size), state
])
tbl.show()
def show_netinterfaces(cls, args, lstnodes):
node = lstnodes.node(args.node_name)
if node:
tbl = linstor_client.Table(utf8=not args.no_utf8, colors=not args.no_color, pastable=args.pastable)
tbl.add_column(node.name, color=Color.GREEN)
tbl.add_column("NetInterface")
tbl.add_column("IP")
tbl.add_column("Port")
tbl.add_column("EncryptionType")
# warning: system test depends on alphabetical ordering
for net_if in node.net_interfaces:
tbl.add_row([
"+ StltCon" if net_if.is_active else "+",
net_if.name,
net_if.address,
net_if.stlt_port if net_if.stlt_port else "",
net_if.stlt_encryption_type if net_if.stlt_encryption_type else ""
])
tbl.show()
else:
raise LinstorClientError("Node '{n}' not found on controller.".format(n=args.node_name),
ExitCode.OBJECT_NOT_FOUND)
