def _layers(self):
self.walker.append(RowWidget([SelectableText("")]))
self.walker.append(
RowWidget(
[SelectableText("Layers", maps=get_map("main_list_white"))]))
i = self.docker_image
parent = i.parent_image
layers = self.docker_image.layers
index = 0
if isinstance(
parent,
RootImage) and len(layers) > 0: # pulled image, docker 1.10+
for image in layers:
self.walker.append(
RowWidget([LayerWidget(self.ui, image, index=index)]))
index += 1
else:
self.walker.append(
RowWidget(
[LayerWidget(self.ui, self.docker_image, index=index)]))
while True:
index += 1
parent = i.parent_image
if parent:
self.walker.append(
RowWidget([LayerWidget(self.ui, parent, index=index)]))
i = parent
else:
break
def _containers(self):
if not self.docker_image.containers():
return
self.walker.append(RowWidget([SelectableText("")]))
self.walker.append(RowWidget([SelectableText("Containers", maps=get_map("main_list_white"))]))
for container in self.docker_image.containers():
self.walker.append(RowWidget([ContainerOneLinerWidget(self.ui, container)]))
def _image_names(self):
if not self.docker_image.names:
return
self.walker.append(RowWidget([SelectableText("")]))
self.walker.append(RowWidget([SelectableText("Image Names", maps=get_map("main_list_white"))]))
for n in self.docker_image.names:
self.walker.append(RowWidget([TagWidget(self.docker_image, n)]))
def _image(self):
self.view_widgets.append(RowWidget([SelectableText("")]))
self.view_widgets.append(
RowWidget(
[SelectableText("Image", maps=get_map("main_list_white"))]))
self.view_widgets.append(
RowWidget([LayerWidget(self.ui, self.docker_container.image)]))
def _logs(self):
operation = self.docker_container.logs(follow=False, lines=10)
if operation.response:
self.walker.append(RowWidget([SelectableText("")]))
self.walker.append(RowWidget([SelectableText("Logs",
maps=get_map("main_list_white"))]))
for x in operation.response.splitlines():
self.walker.append(RowWidget([SelectableText(x)]))
def _process_tree(self):
top = self.docker_container.top().response
logger.debug(top)
if top:
self.walker.append(RowWidget([SelectableText("")]))
self.walker.append(RowWidget([SelectableText("Process Tree",
maps=get_map("main_list_white"))]))
self.walker.append(BoxAdapter(ProcessTree(top), len(top)))
def _logs(self):
operation = self.docker_container.logs(follow=False, lines=10)
if operation.response:
l = []
l.append(RowWidget([SelectableText("")]))
l.append(RowWidget([SelectableText("Logs", maps=get_map("main_list_white"))]))
l.extend([RowWidget([SelectableText(x)]) for x in operation.response.splitlines()])
self.view_widgets.extend(l)
def _labels(self):
if not self.docker_image.labels:
return []
data = []
self.walker.append(RowWidget([SelectableText("")]))
self.walker.append(RowWidget([SelectableText("Labels", maps=get_map("main_list_white"))]))
for label_key, label_value in self.docker_image.labels.items():
data.append([SelectableText(label_key, maps=get_map("main_list_green")), SelectableText(label_value)])
self.walker.extend(assemble_rows(data, ignore_columns=[1]))
def assemble_rows(data,
headers=None,
max_allowed_lengths=None,
dividechars=1,
ignore_columns=None):
"""
:param data: list of lists:
[["row 1 column 1", "row 1 column 2"],
["row 2 column 1", "row 2 column 2"]]
each item consists of instance of urwid.Text
:param headers: list of str, headers of table
:param max_allowed_lengths: dict:
{col_index: maximum_allowed_length}
:param ignore_columns: list of ints, indexes which should not be calculated
"""
rows = []
max_lengths = {}
ignore_columns = ignore_columns or []
# shitty performance, here we go
# it would be way better to do a single double loop and provide mutable variable
# FIXME: merge this code with calculate() from above
for row in data:
col_index = 0
for widget in row:
if col_index in ignore_columns:
continue
l = len(widget.text)
if max_allowed_lengths:
if col_index in max_allowed_lengths and max_allowed_lengths[
col_index] < l:
# l is bigger then what is allowed
l = max_allowed_lengths[col_index]
max_lengths.setdefault(col_index, l)
max_lengths[col_index] = max(l, max_lengths[col_index])
col_index += 1
if headers:
header_widgets = []
for header in headers:
try:
header_widgets.append(urwid.Text(*header[0], **header[1]))
except IndexError:
header_widgets.append(urwid.Text(*header[0]))
rows.append(urwid.Columns(header_widgets, dividechars=1))
for row in data:
row_widgets = []
for idx, item in enumerate(row):
if idx in ignore_columns:
row_widgets.append(item)
else:
row_widgets.append((max_lengths[idx], item))
rows.append(RowWidget(row_widgets, dividechars=dividechars))
return rows
def _layers(self):
self.walker.append(RowWidget([SelectableText("")]))
self.walker.append(
RowWidget(
[SelectableText("Layers", maps=get_map("main_list_white"))]))
i = self.docker_image
index = 0
self.walker.append(
RowWidget([LayerWidget(self.ui, self.docker_image, index=index)]))
while True:
index += 1
parent = i.parent_image
if parent:
self.walker.append(
RowWidget([LayerWidget(self.ui, parent, index=index)]))
i = parent
else:
break
def _resources(self):
self.view_widgets.append(RowWidget([SelectableText("")]))
self.view_widgets.append(
RowWidget([
SelectableText("Resource Usage",
maps=get_map("main_list_white"))
]))
cpu_g = ContainerInfoGraph("graph_lines_cpu_tips", "graph_lines_cpu")
mem_g = ContainerInfoGraph("graph_lines_mem_tips", "graph_lines_mem")
blk_r_g = ContainerInfoGraph("graph_lines_blkio_r_tips",
"graph_lines_blkio_r")
blk_w_g = ContainerInfoGraph("graph_lines_blkio_w_tips",
"graph_lines_blkio_w")
net_r_g = ContainerInfoGraph("graph_lines_net_r_tips",
"graph_lines_net_r")
net_w_g = ContainerInfoGraph("graph_lines_net_w_tips",
"graph_lines_net_w")
cpu_label = ColorText("CPU ", "graph_lines_cpu_legend")
cpu_value = ColorText("0.0 %", "graph_lines_cpu_legend")
mem_label = ColorText("Memory ", "graph_lines_mem_legend")
mem_value = ColorText("0.0 %", "graph_lines_mem_legend")
blk_r_label = ColorText("I/O Read ", "graph_lines_blkio_r_legend")
blk_r_value = ColorText("0 B", "graph_lines_blkio_r_legend")
blk_w_label = ColorText("I/O Write ", "graph_lines_blkio_w_legend")
blk_w_value = ColorText("0 B", "graph_lines_blkio_w_legend")
net_r_label = ColorText("Net Rx ", "graph_lines_net_r_legend")
net_r_value = ColorText("0 B", "graph_lines_net_r_legend")
net_w_label = ColorText("Net Tx ", "graph_lines_net_w_legend")
net_w_value = ColorText("0 B", "graph_lines_net_w_legend")
self.view_widgets.append(
urwid.Columns([
BoxAdapter(cpu_g, 12),
BoxAdapter(mem_g, 12),
("weight", 0.5, BoxAdapter(blk_r_g, 12)),
("weight", 0.5, BoxAdapter(blk_w_g, 12)),
("weight", 0.5, BoxAdapter(net_r_g, 12)),
("weight", 0.5, BoxAdapter(net_w_g, 12)),
BoxAdapter(
UnselectableListBox(
urwid.SimpleFocusListWalker([
UnselectableRowWidget([(12, cpu_label),
cpu_value]),
UnselectableRowWidget([(12, mem_label),
mem_value]),
UnselectableRowWidget([(12, blk_r_label),
blk_r_value]),
UnselectableRowWidget([(12, blk_w_label),
blk_w_value]),
UnselectableRowWidget([(12, net_r_label),
net_r_value]),
UnselectableRowWidget([(12, net_w_label),
net_w_value]),
])), 12),
]))
self.view_widgets.append(RowWidget([SelectableText("")]))
@log_traceback
def realtime_updates():
g = self.docker_container.stats().response
while True:
try:
update = next(g)
except Exception as ex:
if "Timeout" in ex.__class__.__name__:
logger.info("timeout when reading stats: %r", ex)
g = self.docker_container.stats().response
continue
logger.error("error while getting stats: %r", ex)
self.ui.notify_message("Error while getting stats: %s" %
ex,
level="error")
break
if self.stop.is_set():
break
logger.debug(update)
cpu_percent = update["cpu_percent"]
cpu_value.text = "%.2f %%" % cpu_percent
cpu_g.rotate_value(int(cpu_percent), max_val=100)
mem_percent = update["mem_percent"]
mem_current = humanize_bytes(update["mem_current"])
mem_value.text = "%.2f %% (%s)" % (mem_percent, mem_current)
mem_g.rotate_value(int(mem_percent), max_val=100)
blk_read = update["blk_read"]
blk_write = update["blk_write"]
blk_r_value.text = humanize_bytes(blk_read)
blk_w_value.text = humanize_bytes(blk_write)
r_max_val = blk_r_g.rotate_value(blk_read, adaptive_max=True)
w_max_val = blk_w_g.rotate_value(blk_write, adaptive_max=True)
blk_r_g.set_max(max((r_max_val, w_max_val)))
blk_w_g.set_max(max((r_max_val, w_max_val)))
net_read = update["net_rx"]
net_write = update["net_tx"]
net_r_value.text = humanize_bytes(net_read)
net_w_value.text = humanize_bytes(net_write)
r_max_val = net_r_g.rotate_value(net_read, adaptive_max=True)
w_max_val = net_w_g.rotate_value(net_write, adaptive_max=True)
net_r_g.set_max(max((r_max_val, w_max_val)))
net_w_g.set_max(max((r_max_val, w_max_val)))
self.thread = threading.Thread(target=realtime_updates, daemon=True)
self.thread.start()
def __getitem__(self, pos):
logger.debug("do widget for %s", pos)
return RowWidget([SelectableText(str(pos))])
def __getitem__(self, pos):
return RowWidget([TreeNodeWidget(self.ui, pos)])
