diff options
Diffstat (limited to 'bitbake/lib/bb/ui/taskexp_ncurses.py')
| -rwxr-xr-x | bitbake/lib/bb/ui/taskexp_ncurses.py | 1511 |
1 files changed, 1511 insertions, 0 deletions
diff --git a/bitbake/lib/bb/ui/taskexp_ncurses.py b/bitbake/lib/bb/ui/taskexp_ncurses.py new file mode 100755 index 0000000000..ea94a4987f --- /dev/null +++ b/bitbake/lib/bb/ui/taskexp_ncurses.py @@ -0,0 +1,1511 @@ +# +# BitBake Graphical ncurses-based Dependency Explorer +# * Based on the GTK implementation +# * Intended to run on any Linux host +# +# Copyright (C) 2007 Ross Burton +# Copyright (C) 2007 - 2008 Richard Purdie +# Copyright (C) 2022 - 2024 David Reyna +# +# SPDX-License-Identifier: GPL-2.0-only +# + +# +# Execution example: +# $ bitbake -g -u taskexp_ncurses zlib acl +# +# Self-test example (executes a script of GUI actions): +# $ TASK_EXP_UNIT_TEST=1 bitbake -g -u taskexp_ncurses zlib acl +# ... +# $ echo $? +# 0 +# $ TASK_EXP_UNIT_TEST=1 bitbake -g -u taskexp_ncurses zlib acl foo +# ERROR: Nothing PROVIDES 'foo'. Close matches: +# ofono +# $ echo $? +# 1 +# +# Self-test with no terminal example (only tests dependency fetch from bitbake): +# $ TASK_EXP_UNIT_TEST_NOTERM=1 bitbake -g -u taskexp_ncurses quilt +# $ echo $? +# 0 +# +# Features: +# * Ncurses is used for the presentation layer. Only the 'curses' +# library is used (none of the extension libraries), plus only +# one main screen is used (no sub-windows) +# * Uses the 'generateDepTreeEvent' bitbake event to fetch the +# dynamic dependency data based on passed recipes +# * Computes and provides reverse dependencies +# * Supports task sorting on: +# (a) Task dependency order within each recipe +# (b) Pure alphabetical order +# (c) Provisions for third sort order (bitbake order?) +# * The 'Filter' does a "*string*" wildcard filter on tasks in the +# main window, dynamically re-ordering and re-centering the content +# * A 'Print' function exports the selected task or its whole recipe +# task set to the default file "taskdep.txt" +# * Supports a progress bar for bitbake loads and file printing +# * Line art for box drawing supported, ASCII art an alernative +# * No horizontal scrolling support. Selected task's full name +# shown in bottom bar +# * Dynamically catches terminals that are (or become) too small +# * Exception to insure return to normal terminal on errors +# * Debugging support, self test option +# + +import sys +import traceback +import curses +import re +import time + +# Bitbake server support +import threading +from xmlrpc import client +import bb +import bb.event + +# Dependency indexes (depends_model) +(TYPE_DEP, TYPE_RDEP) = (0, 1) +DEPENDS_TYPE = 0 +DEPENDS_TASK = 1 +DEPENDS_DEPS = 2 +# Task indexes (task_list) +TASK_NAME = 0 +TASK_PRIMARY = 1 +TASK_SORT_ALPHA = 2 +TASK_SORT_DEPS = 3 +TASK_SORT_BITBAKE = 4 +# Sort options (default is SORT_DEPS) +SORT_ALPHA = 0 +SORT_DEPS = 1 +SORT_BITBAKE_ENABLE = False # NOTE: future sort +SORT_BITBAKE = 2 +sort_model = SORT_DEPS +# Print options +PRINT_MODEL_1 = 0 +PRINT_MODEL_2 = 1 +print_model = PRINT_MODEL_2 +print_file_name = "taskdep_print.log" +print_file_backup_name = "taskdep_print_backup.log" +is_printed = False +is_filter = False + +# Standard (and backup) key mappings +CHAR_NUL = 0 # Used as self-test nop char +CHAR_BS_H = 8 # Alternate backspace key +CHAR_TAB = 9 +CHAR_RETURN = 10 +CHAR_ESCAPE = 27 +CHAR_UP = ord('{') # Used as self-test ASCII char +CHAR_DOWN = ord('}') # Used as self-test ASCII char + +# Color_pair IDs +CURSES_NORMAL = 0 +CURSES_HIGHLIGHT = 1 +CURSES_WARNING = 2 + + +################################################# +### Debugging support +### + +verbose = False + +# Debug: message display slow-step through display update issues +def alert(msg,screen): + if msg: + screen.addstr(0, 10, '[%-4s]' % msg) + screen.refresh(); + curses.napms(2000) + else: + if do_line_art: + for i in range(10, 24): + screen.addch(0, i, curses.ACS_HLINE) + else: + screen.addstr(0, 10, '-' * 14) + screen.refresh(); + +# Debug: display edge conditions on frame movements +def debug_frame(nbox_ojb): + if verbose: + nbox_ojb.screen.addstr(0, 50, '[I=%2d,O=%2d,S=%3s,H=%2d,M=%4d]' % ( + nbox_ojb.cursor_index, + nbox_ojb.cursor_offset, + nbox_ojb.scroll_offset, + nbox_ojb.inside_height, + len(nbox_ojb.task_list), + )) + nbox_ojb.screen.refresh(); + +# +# Unit test (assumes that 'quilt-native' is always present) +# + +unit_test = os.environ.get('TASK_EXP_UNIT_TEST') +unit_test_cmnds=[ + '# Default selected task in primary box', + 'tst_selected=<TASK>.do_recipe_qa', + '# Default selected task in deps', + 'tst_entry=<TAB>', + 'tst_selected=', + '# Default selected task in rdeps', + 'tst_entry=<TAB>', + 'tst_selected=<TASK>.do_fetch', + "# Test 'select' back to primary box", + 'tst_entry=<CR>', + '#tst_entry=<DOWN>', # optional injected error + 'tst_selected=<TASK>.do_fetch', + '# Check filter', + 'tst_entry=/uilt-nativ/', + 'tst_selected=quilt-native.do_recipe_qa', + '# Check print', + 'tst_entry=p', + 'tst_printed=quilt-native.do_fetch', + '#tst_printed=quilt-foo.do_nothing', # optional injected error + '# Done!', + 'tst_entry=q', +] +unit_test_idx=0 +unit_test_command_chars='' +unit_test_results=[] +def unit_test_action(active_package): + global unit_test_idx + global unit_test_command_chars + global unit_test_results + ret = CHAR_NUL + if unit_test_command_chars: + ch = unit_test_command_chars[0] + unit_test_command_chars = unit_test_command_chars[1:] + time.sleep(0.5) + ret = ord(ch) + else: + line = unit_test_cmnds[unit_test_idx] + unit_test_idx += 1 + line = re.sub('#.*', '', line).strip() + line = line.replace('<TASK>',active_package.primary[0]) + line = line.replace('<TAB>','\t').replace('<CR>','\n') + line = line.replace('<UP>','{').replace('<DOWN>','}') + if not line: line = 'nop=nop' + cmnd,value = line.split('=') + if cmnd == 'tst_entry': + unit_test_command_chars = value + elif cmnd == 'tst_selected': + active_selected = active_package.get_selected() + if active_selected != value: + unit_test_results.append("ERROR:SELFTEST:expected '%s' but got '%s' (NOTE:bitbake may have changed)" % (value,active_selected)) + ret = ord('Q') + else: + unit_test_results.append("Pass:SELFTEST:found '%s'" % (value)) + elif cmnd == 'tst_printed': + result = os.system('grep %s %s' % (value,print_file_name)) + if result: + unit_test_results.append("ERROR:PRINTTEST:expected '%s' in '%s'" % (value,print_file_name)) + ret = ord('Q') + else: + unit_test_results.append("Pass:PRINTTEST:found '%s'" % (value)) + # Return the action (CHAR_NUL for no action til next round) + return(ret) + +# Unit test without an interative terminal (e.g. ptest) +unit_test_noterm = os.environ.get('TASK_EXP_UNIT_TEST_NOTERM') + + +################################################# +### Window frame rendering +### +### By default, use the normal line art. Since +### these extended characters are not ASCII, one +### must use the ncursus API to render them +### The alternate ASCII line art set is optionally +### available via the 'do_line_art' flag + +# By default, render frames using line art +do_line_art = True + +# ASCII render set option +CHAR_HBAR = '-' +CHAR_VBAR = '|' +CHAR_UL_CORNER = '/' +CHAR_UR_CORNER = '\\' +CHAR_LL_CORNER = '\\' +CHAR_LR_CORNER = '/' + +# Box frame drawing with line-art +def line_art_frame(box): + x = box.base_x + y = box.base_y + w = box.width + h = box.height + 1 + + if do_line_art: + for i in range(1, w - 1): + box.screen.addch(y, x + i, curses.ACS_HLINE, box.color) + box.screen.addch(y + h - 1, x + i, curses.ACS_HLINE, box.color) + body_line = "%s" % (' ' * (w - 2)) + for i in range(1, h - 1): + box.screen.addch(y + i, x, curses.ACS_VLINE, box.color) + box.screen.addstr(y + i, x + 1, body_line, box.color) + box.screen.addch(y + i, x + w - 1, curses.ACS_VLINE, box.color) + box.screen.addch(y, x, curses.ACS_ULCORNER, box.color) + box.screen.addch(y, x + w - 1, curses.ACS_URCORNER, box.color) + box.screen.addch(y + h - 1, x, curses.ACS_LLCORNER, box.color) + box.screen.addch(y + h - 1, x + w - 1, curses.ACS_LRCORNER, box.color) + else: + top_line = "%s%s%s" % (CHAR_UL_CORNER,CHAR_HBAR * (w - 2),CHAR_UR_CORNER) + body_line = "%s%s%s" % (CHAR_VBAR,' ' * (w - 2),CHAR_VBAR) + bot_line = "%s%s%s" % (CHAR_UR_CORNER,CHAR_HBAR * (w - 2),CHAR_UL_CORNER) + tag_line = "%s%s%s" % ('[',CHAR_HBAR * (w - 2),']') + # Top bar + box.screen.addstr(y, x, top_line) + # Middle frame + for i in range(1, (h - 1)): + box.screen.addstr(y+i, x, body_line) + # Bottom bar + box.screen.addstr(y + (h - 1), x, bot_line) + +# Connect the separate boxes +def line_art_fixup(box): + if do_line_art: + box.screen.addch(box.base_y+2, box.base_x, curses.ACS_LTEE, box.color) + box.screen.addch(box.base_y+2, box.base_x+box.width-1, curses.ACS_RTEE, box.color) + + +################################################# +### Ncurses box object : box frame object to display +### and manage a sub-window's display elements +### using basic ncurses +### +### Supports: +### * Frame drawing, content (re)drawing +### * Content scrolling via ArrowUp, ArrowDn, PgUp, PgDN, +### * Highlighting for active selected item +### * Content sorting based on selected sort model +### + +class NBox(): + def __init__(self, screen, label, primary, base_x, base_y, width, height): + # Box description + self.screen = screen + self.label = label + self.primary = primary + self.color = curses.color_pair(CURSES_NORMAL) if screen else None + # Box boundaries + self.base_x = base_x + self.base_y = base_y + self.width = width + self.height = height + # Cursor/scroll management + self.cursor_enable = False + self.cursor_index = 0 # Absolute offset + self.cursor_offset = 0 # Frame centric offset + self.scroll_offset = 0 # Frame centric offset + # Box specific content + # Format of each entry is [package_name,is_primary_recipe,alpha_sort_key,deps_sort_key] + self.task_list = [] + + @property + def inside_width(self): + return(self.width-2) + + @property + def inside_height(self): + return(self.height-2) + + # Populate the box's content, include the sort mappings and is_primary flag + def task_list_append(self,task_name,dep): + task_sort_alpha = task_name + task_sort_deps = dep.get_dep_sort(task_name) + is_primary = False + for primary in self.primary: + if task_name.startswith(primary+'.'): + is_primary = True + if SORT_BITBAKE_ENABLE: + task_sort_bitbake = dep.get_bb_sort(task_name) + self.task_list.append([task_name,is_primary,task_sort_alpha,task_sort_deps,task_sort_bitbake]) + else: + self.task_list.append([task_name,is_primary,task_sort_alpha,task_sort_deps]) + + def reset(self): + self.task_list = [] + self.cursor_index = 0 # Absolute offset + self.cursor_offset = 0 # Frame centric offset + self.scroll_offset = 0 # Frame centric offset + + # Sort the box's content based on the current sort model + def sort(self): + if SORT_ALPHA == sort_model: + self.task_list.sort(key = lambda x: x[TASK_SORT_ALPHA]) + elif SORT_DEPS == sort_model: + self.task_list.sort(key = lambda x: x[TASK_SORT_DEPS]) + elif SORT_BITBAKE == sort_model: + self.task_list.sort(key = lambda x: x[TASK_SORT_BITBAKE]) + + # The target package list (to hightlight), from the command line + def set_primary(self,primary): + self.primary = primary + + # Draw the box's outside frame + def draw_frame(self): + line_art_frame(self) + # Title + self.screen.addstr(self.base_y, + (self.base_x + (self.width//2))-((len(self.label)+2)//2), + '['+self.label+']') + self.screen.refresh() + + # Draw the box's inside text content + def redraw(self): + task_list_len = len(self.task_list) + # Middle frame + body_line = "%s" % (' ' * (self.inside_width-1) ) + for i in range(0,self.inside_height+1): + if i < (task_list_len + self.scroll_offset): + str_ctl = "%%-%ss" % (self.width-3) + # Safety assert + if (i + self.scroll_offset) >= task_list_len: + alert("REDRAW:%2d,%4d,%4d" % (i,self.scroll_offset,task_list_len),self.screen) + break + + task_obj = self.task_list[i + self.scroll_offset] + task = task_obj[TASK_NAME][:self.inside_width-1] + task_primary = task_obj[TASK_PRIMARY] + + if task_primary: + line = str_ctl % task[:self.inside_width-1] + self.screen.addstr(self.base_y+1+i, self.base_x+2, line, curses.A_BOLD) + else: + line = str_ctl % task[:self.inside_width-1] + self.screen.addstr(self.base_y+1+i, self.base_x+2, line) + else: + line = "%s" % (' ' * (self.inside_width-1) ) + self.screen.addstr(self.base_y+1+i, self.base_x+2, line) + self.screen.refresh() + + # Show the current selected task over the bottom of the frame + def show_selected(self,selected_task): + if not selected_task: + selected_task = self.get_selected() + tag_line = "%s%s%s" % ('[',CHAR_HBAR * (self.width-2),']') + self.screen.addstr(self.base_y + self.height, self.base_x, tag_line) + self.screen.addstr(self.base_y + self.height, + (self.base_x + (self.width//2))-((len(selected_task)+2)//2), + '['+selected_task+']') + self.screen.refresh() + + # Load box with new table of content + def update_content(self,task_list): + self.task_list = task_list + if self.cursor_enable: + cursor_update(turn_on=False) + self.cursor_index = 0 + self.cursor_offset = 0 + self.scroll_offset = 0 + self.redraw() + if self.cursor_enable: + cursor_update(turn_on=True) + + # Manage the box's highlighted task and blinking cursor character + def cursor_on(self,is_on): + self.cursor_enable = is_on + self.cursor_update(is_on) + + # High-light the current pointed package, normal for released packages + def cursor_update(self,turn_on=True): + str_ctl = "%%-%ss" % (self.inside_width-1) + try: + if len(self.task_list): + task_obj = self.task_list[self.cursor_index] + task = task_obj[TASK_NAME][:self.inside_width-1] + task_primary = task_obj[TASK_PRIMARY] + task_font = curses.A_BOLD if task_primary else 0 + else: + task = '' + task_font = 0 + except Exception as e: + alert("CURSOR_UPDATE:%s" % (e),self.screen) + return + if turn_on: + self.screen.addstr(self.base_y+1+self.cursor_offset,self.base_x+1,">", curses.color_pair(CURSES_HIGHLIGHT) | curses.A_BLINK) + self.screen.addstr(self.base_y+1+self.cursor_offset,self.base_x+2,str_ctl % task, curses.color_pair(CURSES_HIGHLIGHT) | task_font) + else: + self.screen.addstr(self.base_y+1+self.cursor_offset,self.base_x+1," ") + self.screen.addstr(self.base_y+1+self.cursor_offset,self.base_x+2,str_ctl % task, task_font) + + # Down arrow + def line_down(self): + if len(self.task_list) <= (self.cursor_index+1): + return + self.cursor_update(turn_on=False) + self.cursor_index += 1 + self.cursor_offset += 1 + if self.cursor_offset > (self.inside_height): + self.cursor_offset -= 1 + self.scroll_offset += 1 + self.redraw() + self.cursor_update(turn_on=True) + debug_frame(self) + + # Up arrow + def line_up(self): + if 0 > (self.cursor_index-1): + return + self.cursor_update(turn_on=False) + self.cursor_index -= 1 + self.cursor_offset -= 1 + if self.cursor_offset < 0: + self.cursor_offset += 1 + self.scroll_offset -= 1 + self.redraw() + self.cursor_update(turn_on=True) + debug_frame(self) + + # Page down + def page_down(self): + max_task = len(self.task_list)-1 + if max_task < self.inside_height: + return + self.cursor_update(turn_on=False) + self.cursor_index += 10 + self.cursor_index = min(self.cursor_index,max_task) + self.cursor_offset = min(self.inside_height,self.cursor_index) + self.scroll_offset = self.cursor_index - self.cursor_offset + self.redraw() + self.cursor_update(turn_on=True) + debug_frame(self) + + # Page up + def page_up(self): + max_task = len(self.task_list)-1 + if max_task < self.inside_height: + return + self.cursor_update(turn_on=False) + self.cursor_index -= 10 + self.cursor_index = max(self.cursor_index,0) + self.cursor_offset = max(0, self.inside_height - (max_task - self.cursor_index)) + self.scroll_offset = self.cursor_index - self.cursor_offset + self.redraw() + self.cursor_update(turn_on=True) + debug_frame(self) + + # Return the currently selected task name for this box + def get_selected(self): + if self.task_list: + return(self.task_list[self.cursor_index][TASK_NAME]) + else: + return('') + +################################################# +### The helper sub-windows +### + +# Show persistent help at the top of the screen +class HelpBarView(NBox): + def __init__(self, screen, label, primary, base_x, base_y, width, height): + super(HelpBarView, self).__init__(screen, label, primary, base_x, base_y, width, height) + + def show_help(self,show): + self.screen.addstr(self.base_y,self.base_x, "%s" % (' ' * self.inside_width)) + if show: + help = "Help='?' Filter='/' NextBox=<Tab> Select=<Enter> Print='p','P' Quit='q'" + bar_size = self.inside_width - 5 - len(help) + self.screen.addstr(self.base_y,self.base_x+((self.inside_width-len(help))//2), help) + self.screen.refresh() + +# Pop up a detailed Help box +class HelpBoxView(NBox): + def __init__(self, screen, label, primary, base_x, base_y, width, height, dep): + super(HelpBoxView, self).__init__(screen, label, primary, base_x, base_y, width, height) + self.x_pos = 0 + self.y_pos = 0 + self.dep = dep + + # Instantial the pop-up help box + def show_help(self,show): + self.x_pos = self.base_x + 4 + self.y_pos = self.base_y + 2 + + def add_line(line): + if line: + self.screen.addstr(self.y_pos,self.x_pos,line) + self.y_pos += 1 + + # Gather some statisics + dep_count = 0 + rdep_count = 0 + for task_obj in self.dep.depends_model: + if TYPE_DEP == task_obj[DEPENDS_TYPE]: + dep_count += 1 + elif TYPE_RDEP == task_obj[DEPENDS_TYPE]: + rdep_count += 1 + + self.draw_frame() + line_art_fixup(self.dep) + add_line("Quit : 'q' ") + add_line("Filter task names : '/'") + add_line("Tab to next box : <Tab>") + add_line("Select a task : <Enter>") + add_line("Print task's deps : 'p'") + add_line("Print recipe's deps : 'P'") + add_line(" -> '%s'" % print_file_name) + add_line("Sort toggle : 's'") + add_line(" %s Recipe inner-depends order" % ('->' if (SORT_DEPS == sort_model) else '- ')) + add_line(" %s Alpha-numeric order" % ('->' if (SORT_ALPHA == sort_model) else '- ')) + if SORT_BITBAKE_ENABLE: + add_line(" %s Bitbake order" % ('->' if (TASK_SORT_BITBAKE == sort_model) else '- ')) + add_line("Alternate backspace : <CTRL-H>") + add_line("") + add_line("Primary recipes = %s" % ','.join(self.primary)) + add_line("Task count = %4d" % len(self.dep.pkg_model)) + add_line("Deps count = %4d" % dep_count) + add_line("RDeps count = %4d" % rdep_count) + add_line("") + self.screen.addstr(self.y_pos,self.x_pos+7,"<Press any key>", curses.color_pair(CURSES_HIGHLIGHT)) + self.screen.refresh() + c = self.screen.getch() + +# Show a progress bar +class ProgressView(NBox): + def __init__(self, screen, label, primary, base_x, base_y, width, height): + super(ProgressView, self).__init__(screen, label, primary, base_x, base_y, width, height) + + def progress(self,title,current,max): + if title: + self.label = title + else: + title = self.label + if max <=0: max = 10 + bar_size = self.width - 7 - len(title) + bar_done = int( (float(current)/float(max)) * float(bar_size) ) + self.screen.addstr(self.base_y,self.base_x, " %s:[%s%s]" % (title,'*' * bar_done,' ' * (bar_size-bar_done))) + self.screen.refresh() + return(current+1) + + def clear(self): + self.screen.addstr(self.base_y,self.base_x, "%s" % (' ' * self.width)) + self.screen.refresh() + +# Implement a task filter bar +class FilterView(NBox): + SEARCH_NOP = 0 + SEARCH_GO = 1 + SEARCH_CANCEL = 2 + + def __init__(self, screen, label, primary, base_x, base_y, width, height): + super(FilterView, self).__init__(screen, label, primary, base_x, base_y, width, height) + self.do_show = False + self.filter_str = "" + + def clear(self,enable_show=True): + self.filter_str = "" + + def show(self,enable_show=True): + self.do_show = enable_show + if self.do_show: + self.screen.addstr(self.base_y,self.base_x, "[ Filter: %-25s ] '/'=cancel, format='abc' " % self.filter_str[0:25]) + else: + self.screen.addstr(self.base_y,self.base_x, "%s" % (' ' * self.width)) + self.screen.refresh() + + def show_prompt(self): + self.screen.addstr(self.base_y,self.base_x + 10 + len(self.filter_str), " ") + self.screen.addstr(self.base_y,self.base_x + 10 + len(self.filter_str), "") + + # Keys specific to the filter box (start/stop filter keys are in the main loop) + def input(self,c,ch): + ret = self.SEARCH_GO + if c in (curses.KEY_BACKSPACE,CHAR_BS_H): + # Backspace + if self.filter_str: + self.filter_str = self.filter_str[0:-1] + self.show() + elif ((ch >= 'a') and (ch <= 'z')) or ((ch >= 'A') and (ch <= 'Z')) or ((ch >= '0') and (ch <= '9')) or (ch in (' ','_','.','-')): + # The isalnum() acts strangly with keypad(True), so explicit bounds + self.filter_str += ch + self.show() + else: + ret = self.SEARCH_NOP + return(ret) + + +################################################# +### The primary dependency windows +### + +# The main list of package tasks +class PackageView(NBox): + def __init__(self, screen, label, primary, base_x, base_y, width, height): + super(PackageView, self).__init__(screen, label, primary, base_x, base_y, width, height) + + # Find and verticaly center a selected task (from filter or from dependent box) + # The 'task_filter_str' can be a full or a partial (filter) task name + def find(self,task_filter_str): + found = False + max = self.height-2 + if not task_filter_str: + return(found) + for i,task_obj in enumerate(self.task_list): + task = task_obj[TASK_NAME] + if task.startswith(task_filter_str): + self.cursor_on(False) + self.cursor_index = i + + # Position selected at vertical center + vcenter = self.inside_height // 2 + if self.cursor_index <= vcenter: + self.scroll_offset = 0 + self.cursor_offset = self.cursor_index + elif self.cursor_index >= (len(self.task_list) - vcenter - 1): + self.cursor_offset = self.inside_height-1 + self.scroll_offset = self.cursor_index - self.cursor_offset + else: + self.cursor_offset = vcenter + self.scroll_offset = self.cursor_index - self.cursor_offset + + self.redraw() + self.cursor_on(True) + found = True + break + return(found) + +# The view of dependent packages +class PackageDepView(NBox): + def __init__(self, screen, label, primary, base_x, base_y, width, height): + super(PackageDepView, self).__init__(screen, label, primary, base_x, base_y, width, height) + +# The view of reverse-dependent packages +class PackageReverseDepView(NBox): + def __init__(self, screen, label, primary, base_x, base_y, width, height): + super(PackageReverseDepView, self).__init__(screen, label, primary, base_x, base_y, width, height) + + +################################################# +### DepExplorer : The parent frame and object +### + +class DepExplorer(NBox): + def __init__(self,screen): + title = "Task Dependency Explorer" + super(DepExplorer, self).__init__(screen, 'Task Dependency Explorer','',0,0,80,23) + + self.screen = screen + self.pkg_model = [] + self.depends_model = [] + self.dep_sort_map = {} + self.bb_sort_map = {} + self.filter_str = '' + self.filter_prev = 'deadbeef' + + if self.screen: + self.help_bar_view = HelpBarView(screen, "Help",'',1,1,79,1) + self.help_box_view = HelpBoxView(screen, "Help",'',0,2,40,20,self) + self.progress_view = ProgressView(screen, "Progress",'',2,1,76,1) + self.filter_view = FilterView(screen, "Filter",'',2,1,76,1) + self.package_view = PackageView(screen, "Package",'alpha', 0,2,40,20) + self.dep_view = PackageDepView(screen, "Dependencies",'beta',40,2,40,10) + self.reverse_view = PackageReverseDepView(screen, "Dependent Tasks",'gamma',40,13,40,9) + self.draw_frames() + + # Draw this main window's frame and all sub-windows + def draw_frames(self): + self.draw_frame() + self.package_view.draw_frame() + self.dep_view.draw_frame() + self.reverse_view.draw_frame() + if is_filter: + self.filter_view.show(True) + self.filter_view.show_prompt() + else: + self.help_bar_view.show_help(True) + self.package_view.redraw() + self.dep_view.redraw() + self.reverse_view.redraw() + self.show_selected(self.package_view.get_selected()) + line_art_fixup(self) + + # Parse the bitbake dependency event object + def parse(self, depgraph): + for task in depgraph["tdepends"]: + self.pkg_model.insert(0, task) + for depend in depgraph["tdepends"][task]: + self.depends_model.insert (0, (TYPE_DEP, task, depend)) + self.depends_model.insert (0, (TYPE_RDEP, depend, task)) + if self.screen: + self.dep_sort_prep() + + # Prepare the dependency sort order keys + # This method creates sort keys per recipe tasks in + # the order of each recipe's internal dependecies + # Method: + # Filter the tasks in dep order in dep_sort_map = {} + # (a) Find a task that has no dependecies + # Ignore non-recipe specific tasks + # (b) Add it to the sort mapping dict with + # key of "<task_group>_<order>" + # (c) Remove it as a dependency from the other tasks + # (d) Repeat till all tasks are mapped + # Use placeholders to insure each sub-dict is instantiated + def dep_sort_prep(self): + self.progress_view.progress('DepSort',0,4) + # Init the task base entries + self.progress_view.progress('DepSort',1,4) + dep_table = {} + bb_index = 0 + for task in self.pkg_model: + # First define the incoming bitbake sort order + self.bb_sort_map[task] = "%04d" % (bb_index) + bb_index += 1 + task_group = task[0:task.find('.')] + if task_group not in dep_table: + dep_table[task_group] = {} + dep_table[task_group]['-'] = {} # Placeholder + if task not in dep_table[task_group]: + dep_table[task_group][task] = {} + dep_table[task_group][task]['-'] = {} # Placeholder + # Add the task dependecy entries + self.progress_view.progress('DepSort',2,4) + for task_obj in self.depends_model: + if task_obj[DEPENDS_TYPE] != TYPE_DEP: + continue + task = task_obj[DEPENDS_TASK] + task_dep = task_obj[DEPENDS_DEPS] + task_group = task[0:task.find('.')] + # Only track depends within same group + if task_dep.startswith(task_group+'.'): + dep_table[task_group][task][task_dep] = 1 + self.progress_view.progress('DepSort',3,4) + for task_group in dep_table: + dep_index = 0 + # Whittle down the tasks of each group + this_pass = 1 + do_loop = True + while (len(dep_table[task_group]) > 1) and do_loop: + this_pass += 1 + is_change = False + delete_list = [] + for task in dep_table[task_group]: + if '-' == task: + continue + if 1 == len(dep_table[task_group][task]): + is_change = True + # No more deps, so collect this task... + self.dep_sort_map[task] = "%s_%04d" % (task_group,dep_index) + dep_index += 1 + # ... remove it from other lists as resolved ... + for dep_task in dep_table[task_group]: + if task in dep_table[task_group][dep_task]: + del dep_table[task_group][dep_task][task] + # ... and remove it from from the task group + delete_list.append(task) + for task in delete_list: + del dep_table[task_group][task] + if not is_change: + alert("ERROR:DEP_SIEVE_NO_CHANGE:%s" % task_group,self.screen) + do_loop = False + continue + self.progress_view.progress('',4,4) + self.progress_view.clear() + self.help_bar_view.show_help(True) + if len(self.dep_sort_map) != len(self.pkg_model): + alert("ErrorDepSort:%d/%d" % (len(self.dep_sort_map),len(self.pkg_model)),self.screen) + + # Look up a dep sort order key + def get_dep_sort(self,key): + if key in self.dep_sort_map: + return(self.dep_sort_map[key]) + else: + return(key) + + # Look up a bitbake sort order key + def get_bb_sort(self,key): + if key in self.bb_sort_map: + return(self.bb_sort_map[key]) + else: + return(key) + + # Find the selected package in the main frame, update the dependency frames content accordingly + def select(self, package_name, only_update_dependents=False): + if not package_name: + package_name = self.package_view.get_selected() + # alert("SELECT:%s:" % package_name,self.screen) + + if self.filter_str != self.filter_prev: + self.package_view.cursor_on(False) + # Fill of the main package task list using new filter + self.package_view.task_list = [] + for package in self.pkg_model: + if self.filter_str: + if self.filter_str in package: + self.package_view.task_list_append(package,self) + else: + self.package_view.task_list_append(package,self) + self.package_view.sort() + self.filter_prev = self.filter_str + + # Old position is lost, assert new position of previous task (if still filtered in) + self.package_view.cursor_index = 0 + self.package_view.cursor_offset = 0 + self.package_view.scroll_offset = 0 + self.package_view.redraw() + self.package_view.cursor_on(True) + + # Make sure the selected package is in view, with implicit redraw() + if (not only_update_dependents): + self.package_view.find(package_name) + # In case selected name change (i.e. filter removed previous) + package_name = self.package_view.get_selected() + + # Filter the package's dependent list to the dependent view + self.dep_view.reset() + for package_def in self.depends_model: + if (package_def[DEPENDS_TYPE] == TYPE_DEP) and (package_def[DEPENDS_TASK] == package_name): + self.dep_view.task_list_append(package_def[DEPENDS_DEPS],self) + self.dep_view.sort() + self.dep_view.redraw() + # Filter the package's dependent list to the reverse dependent view + self.reverse_view.reset() + for package_def in self.depends_model: + if (package_def[DEPENDS_TYPE] == TYPE_RDEP) and (package_def[DEPENDS_TASK] == package_name): + self.reverse_view.task_list_append(package_def[DEPENDS_DEPS],self) + self.reverse_view.sort() + self.reverse_view.redraw() + self.show_selected(package_name) + self.screen.refresh() + + # The print-to-file method + def print_deps(self,whole_group=False): + global is_printed + # Print the selected deptree(s) to a file + if not is_printed: + try: + # Move to backup any exiting file before first write + if os.path.isfile(print_file_name): + os.system('mv -f %s %s' % (print_file_name,print_file_backup_name)) + except Exception as e: + alert(e,self.screen) + alert('',self.screen) + print_list = [] + selected_task = self.package_view.get_selected() + if not selected_task: + return + if not whole_group: + print_list.append(selected_task) + else: + # Use the presorted task_group order from 'package_view' + task_group = selected_task[0:selected_task.find('.')+1] + for task_obj in self.package_view.task_list: + task = task_obj[TASK_NAME] + if task.startswith(task_group): + print_list.append(task) + with open(print_file_name, "a") as fd: + print_max = len(print_list) + print_count = 1 + self.progress_view.progress('Write "%s"' % print_file_name,0,print_max) + for task in print_list: + print_count = self.progress_view.progress('',print_count,print_max) + self.select(task) + self.screen.refresh(); + # Utilize the current print output model + if print_model == PRINT_MODEL_1: + print("=== Dependendency Snapshot ===",file=fd) + print(" = Package =",file=fd) + print(' '+task,file=fd) + # Fill in the matching dependencies + print(" = Dependencies =",file=fd) + for task_obj in self.dep_view.task_list: + print(' '+ task_obj[TASK_NAME],file=fd) + print(" = Dependent Tasks =",file=fd) + for task_obj in self.reverse_view.task_list: + print(' '+ task_obj[TASK_NAME],file=fd) + if print_model == PRINT_MODEL_2: + print("=== Dependendency Snapshot ===",file=fd) + dep_count = len(self.dep_view.task_list) - 1 + for i,task_obj in enumerate(self.dep_view.task_list): + print('%s%s' % ("Dep =" if (i==dep_count) else " ",task_obj[TASK_NAME]),file=fd) + if not self.dep_view.task_list: + print('Dep =',file=fd) + print("Package=%s" % task,file=fd) + for i,task_obj in enumerate(self.reverse_view.task_list): + print('%s%s' % ("RDep =" if (i==0) else " ",task_obj[TASK_NAME]),file=fd) + if not self.reverse_view.task_list: + print('RDep =',file=fd) + curses.napms(2000) + self.progress_view.clear() + self.help_bar_view.show_help(True) + print('',file=fd) + # Restore display to original selected task + self.select(selected_task) + is_printed = True + +################################################# +### Load bitbake data +### + +def bitbake_load(server, eventHandler, params, dep, curses_off, screen): + global bar_len_old + bar_len_old = 0 + + # Support no screen + def progress(msg,count,max): + global bar_len_old + if screen: + dep.progress_view.progress(msg,count,max) + else: + if msg: + if bar_len_old: + bar_len_old = 0 + print("\n") + print(f"{msg}: ({count} of {max})") + else: + bar_len = int((count*40)/max) + if bar_len_old != bar_len: + print(f"{'*' * (bar_len-bar_len_old)}",end='',flush=True) + bar_len_old = bar_len + def clear(): + if screen: + dep.progress_view.clear() + def clear_curses(screen): + if screen: + curses_off(screen) + + # + # Trigger bitbake "generateDepTreeEvent" + # + + cmdline = '' + try: + params.updateToServer(server, os.environ.copy()) + params.updateFromServer(server) + cmdline = params.parseActions() + if not cmdline: + clear_curses(screen) + print("ERROR: nothing to do. Use 'bitbake world' to build everything, or run 'bitbake --help' for usage information.") + return 1,cmdline + if 'msg' in cmdline and cmdline['msg']: + clear_curses(screen) + print('ERROR: ' + cmdline['msg']) + return 1,cmdline + cmdline = cmdline['action'] + if not cmdline or cmdline[0] != "generateDotGraph": + clear_curses(screen) + print("ERROR: This UI requires the -g option") + return 1,cmdline + ret, error = server.runCommand(["generateDepTreeEvent", cmdline[1], cmdline[2]]) + if error: + clear_curses(screen) + print("ERROR: running command '%s': %s" % (cmdline, error)) + return 1,cmdline + elif not ret: + clear_curses(screen) + print("ERROR: running command '%s': returned %s" % (cmdline, ret)) + return 1,cmdline + except client.Fault as x: + clear_curses(screen) + print("ERROR: XMLRPC Fault getting commandline:\n %s" % x) + return 1,cmdline + except Exception as e: + clear_curses(screen) + print("ERROR: in startup:\n %s" % traceback.format_exc()) + return 1,cmdline + + # + # Receive data from bitbake + # + + progress_total = 0 + load_bitbake = True + quit = False + try: + while load_bitbake: + try: + event = eventHandler.waitEvent(0.25) + if quit: + _, error = server.runCommand(["stateForceShutdown"]) + clear_curses(screen) + if error: + print('Unable to cleanly stop: %s' % error) + break + + if event is None: + continue + + if isinstance(event, bb.event.CacheLoadStarted): + progress_total = event.total + progress('Loading Cache',0,progress_total) + continue + + if isinstance(event, bb.event.CacheLoadProgress): + x = event.current + progress('',x,progress_total) + continue + + if isinstance(event, bb.event.CacheLoadCompleted): + clear() + progress('Bitbake... ',1,2) + continue + + if isinstance(event, bb.event.ParseStarted): + progress_total = event.total + progress('Processing recipes',0,progress_total) + if progress_total == 0: + continue + + if isinstance(event, bb.event.ParseProgress): + x = event.current + progress('',x,progress_total) + continue + + if isinstance(event, bb.event.ParseCompleted): + progress('Generating dependency tree',0,3) + continue + + if isinstance(event, bb.event.DepTreeGenerated): + progress('Generating dependency tree',1,3) + dep.parse(event._depgraph) + progress('Generating dependency tree',2,3) + + if isinstance(event, bb.command.CommandCompleted): + load_bitbake = False + progress('Generating dependency tree',3,3) + clear() + if screen: + dep.help_bar_view.show_help(True) + continue + + if isinstance(event, bb.event.NoProvider): + clear_curses(screen) + print('ERROR: %s' % event) + + _, error = server.runCommand(["stateShutdown"]) + if error: + print('ERROR: Unable to cleanly shutdown: %s' % error) + return 1,cmdline + + if isinstance(event, bb.command.CommandFailed): + clear_curses(screen) + print('ERROR: ' + str(event)) + return event.exitcode,cmdline + + if isinstance(event, bb.command.CommandExit): + clear_curses(screen) + return event.exitcode,cmdline + + if isinstance(event, bb.cooker.CookerExit): + break + + continue + except EnvironmentError as ioerror: + # ignore interrupted io + if ioerror.args[0] == 4: + pass + except KeyboardInterrupt: + if shutdown == 2: + clear_curses(screen) + print("\nThird Keyboard Interrupt, exit.\n") + break + if shutdown == 1: + clear_curses(screen) + print("\nSecond Keyboard Interrupt, stopping...\n") + _, error = server.runCommand(["stateForceShutdown"]) + if error: + print('Unable to cleanly stop: %s' % error) + if shutdown == 0: + clear_curses(screen) + print("\nKeyboard Interrupt, closing down...\n") + _, error = server.runCommand(["stateShutdown"]) + if error: + print('Unable to cleanly shutdown: %s' % error) + shutdown = shutdown + 1 + pass + except Exception as e: + # Safe exit on error + clear_curses(screen) + print("Exception : %s" % e) + print("Exception in startup:\n %s" % traceback.format_exc()) + + return 0,cmdline + +################################################# +### main +### + +SCREEN_COL_MIN = 83 +SCREEN_ROW_MIN = 26 + +def main(server, eventHandler, params): + global verbose + global sort_model + global print_model + global is_printed + global is_filter + global screen_too_small + + shutdown = 0 + screen_too_small = False + quit = False + + # Unit test with no terminal? + if unit_test_noterm: + # Load bitbake, test that there is valid dependency data, then exit + screen = None + print("* UNIT TEST:START") + dep = DepExplorer(screen) + print("* UNIT TEST:BITBAKE FETCH") + ret,cmdline = bitbake_load(server, eventHandler, params, dep, None, screen) + if ret: + print("* UNIT TEST: BITBAKE FAILED") + return ret + # Test the acquired dependency data + quilt_native_deps = 0 + quilt_native_rdeps = 0 + quilt_deps = 0 + quilt_rdeps = 0 + for i,task_obj in enumerate(dep.depends_model): + if TYPE_DEP == task_obj[0]: + task = task_obj[1] + if task.startswith('quilt-native'): + quilt_native_deps += 1 + elif task.startswith('quilt'): + quilt_deps += 1 + elif TYPE_RDEP == task_obj[0]: + task = task_obj[1] + if task.startswith('quilt-native'): + quilt_native_rdeps += 1 + elif task.startswith('quilt'): + quilt_rdeps += 1 + # Print results + failed = False + if 0 < len(dep.depends_model): + print(f"Pass:Bitbake dependency count = {len(dep.depends_model)}") + else: + failed = True + print(f"FAIL:Bitbake dependency count = 0") + if quilt_native_deps: + print(f"Pass:Quilt-native depends count = {quilt_native_deps}") + else: + failed = True + print(f"FAIL:Quilt-native depends count = 0") + if quilt_native_rdeps: + print(f"Pass:Quilt-native rdepends count = {quilt_native_rdeps}") + else: + failed = True + print(f"FAIL:Quilt-native rdepends count = 0") + if quilt_deps: + print(f"Pass:Quilt depends count = {quilt_deps}") + else: + failed = True + print(f"FAIL:Quilt depends count = 0") + if quilt_rdeps: + print(f"Pass:Quilt rdepends count = {quilt_rdeps}") + else: + failed = True + print(f"FAIL:Quilt rdepends count = 0") + print("* UNIT TEST:STOP") + return failed + + # Help method to dynamically test parent window too small + def check_screen_size(dep, active_package): + global screen_too_small + rows, cols = screen.getmaxyx() + if (rows >= SCREEN_ROW_MIN) and (cols >= SCREEN_COL_MIN): + if screen_too_small: + # Now big enough, remove error message and redraw screen + dep.draw_frames() + active_package.cursor_on(True) + screen_too_small = False + return True + # Test on App init + if not dep: + # Do not start this app if screen not big enough + curses.endwin() + print("") + print("ERROR(Taskexp_cli): Mininal screen size is %dx%d" % (SCREEN_COL_MIN,SCREEN_ROW_MIN)) + print("Current screen is Cols=%s,Rows=%d" % (cols,rows)) + return False + # First time window too small + if not screen_too_small: + active_package.cursor_on(False) + dep.screen.addstr(0,2,'[BIGGER WINDOW PLEASE]', curses.color_pair(CURSES_WARNING) | curses.A_BLINK) + screen_too_small = True + return False + + # Helper method to turn off curses mode + def curses_off(screen): + if not screen: return + # Safe error exit + screen.keypad(False) + curses.echo() + curses.curs_set(1) + curses.endwin() + + if unit_test_results: + print('\nUnit Test Results:') + for line in unit_test_results: + print(" %s" % line) + + # + # Initialize the ncurse environment + # + + screen = curses.initscr() + try: + if not check_screen_size(None, None): + exit(1) + try: + curses.start_color() + curses.use_default_colors(); + curses.init_pair(0xFF, curses.COLOR_BLACK, curses.COLOR_WHITE); + curses.init_pair(CURSES_NORMAL, curses.COLOR_WHITE, curses.COLOR_BLACK) + curses.init_pair(CURSES_HIGHLIGHT, curses.COLOR_WHITE, curses.COLOR_BLUE) + curses.init_pair(CURSES_WARNING, curses.COLOR_WHITE, curses.COLOR_RED) + except: + curses.endwin() + print("") + print("ERROR(Taskexp_cli): Requires 256 colors. Please use this or the equivalent:") + print(" $ export TERM='xterm-256color'") + exit(1) + + screen.keypad(True) + curses.noecho() + curses.curs_set(0) + screen.refresh(); + except Exception as e: + # Safe error exit + curses_off(screen) + print("Exception : %s" % e) + print("Exception in startup:\n %s" % traceback.format_exc()) + exit(1) + + try: + # + # Instantiate the presentation layers + # + + dep = DepExplorer(screen) + + # + # Prepare bitbake + # + + # Fetch bitbake dependecy data + ret,cmdline = bitbake_load(server, eventHandler, params, dep, curses_off, screen) + if ret: return ret + + # + # Preset the views + # + + # Cmdline example = ['generateDotGraph', ['acl', 'zlib'], 'build'] + primary_packages = cmdline[1] + dep.package_view.set_primary(primary_packages) + dep.dep_view.set_primary(primary_packages) + dep.reverse_view.set_primary(primary_packages) + dep.help_box_view.set_primary(primary_packages) + dep.help_bar_view.show_help(True) + active_package = dep.package_view + active_package.cursor_on(True) + dep.select(primary_packages[0]+'.') + if unit_test: + alert('UNIT_TEST',screen) + + # Help method to start/stop the filter feature + def filter_mode(new_filter_status): + global is_filter + if is_filter == new_filter_status: + # Ignore no changes + return + if not new_filter_status: + # Turn off + curses.curs_set(0) + #active_package.cursor_on(False) + active_package = dep.package_view + active_package.cursor_on(True) + is_filter = False + dep.help_bar_view.show_help(True) + dep.filter_str = '' + dep.select('') + else: + # Turn on + curses.curs_set(1) + dep.help_bar_view.show_help(False) + dep.filter_view.clear() + dep.filter_view.show(True) + dep.filter_view.show_prompt() + is_filter = True + + # + # Main user loop + # + + while not quit: + if is_filter: + dep.filter_view.show_prompt() + if unit_test: + c = unit_test_action(active_package) + else: + c = screen.getch() + ch = chr(c) + + # Do not draw if window now too small + if not check_screen_size(dep,active_package): + continue + + if verbose: + if c == CHAR_RETURN: + screen.addstr(0, 4, "|%3d,CR |" % (c)) + else: + screen.addstr(0, 4, "|%3d,%3s|" % (c,chr(c))) + + # pre-map alternate filter close keys + if is_filter and (c == CHAR_ESCAPE): + # Alternate exit from filter + ch = '/' + c = ord(ch) + + # Filter and non-filter mode command keys + # https://docs.python.org/3/library/curses.html + if c in (curses.KEY_UP,CHAR_UP): + active_package.line_up() + if active_package == dep.package_view: + dep.select('',only_update_dependents=True) + elif c in (curses.KEY_DOWN,CHAR_DOWN): + active_package.line_down() + if active_package == dep.package_view: + dep.select('',only_update_dependents=True) + elif curses.KEY_PPAGE == c: + active_package.page_up() + if active_package == dep.package_view: + dep.select('',only_update_dependents=True) + elif curses.KEY_NPAGE == c: + active_package.page_down() + if active_package == dep.package_view: + dep.select('',only_update_dependents=True) + elif CHAR_TAB == c: + # Tab between boxes + active_package.cursor_on(False) + if active_package == dep.package_view: + active_package = dep.dep_view + elif active_package == dep.dep_view: + active_package = dep.reverse_view + else: + active_package = dep.package_view + active_package.cursor_on(True) + elif curses.KEY_BTAB == c: + # Shift-Tab reverse between boxes + active_package.cursor_on(False) + if active_package == dep.package_view: + active_package = dep.reverse_view + elif active_package == dep.reverse_view: + active_package = dep.dep_view + else: + active_package = dep.package_view + active_package.cursor_on(True) + elif (CHAR_RETURN == c): + # CR to select + selected = active_package.get_selected() + if selected: + active_package.cursor_on(False) + active_package = dep.package_view + filter_mode(False) + dep.select(selected) + else: + filter_mode(False) + dep.select(primary_packages[0]+'.') + + elif '/' == ch: # Enter/exit dep.filter_view + if is_filter: + filter_mode(False) + else: + filter_mode(True) + elif is_filter: + # If in filter mode, re-direct all these other keys to the filter box + result = dep.filter_view.input(c,ch) + dep.filter_str = dep.filter_view.filter_str + dep.select('') + + # Non-filter mode command keys + elif 'p' == ch: + dep.print_deps(whole_group=False) + elif 'P' == ch: + dep.print_deps(whole_group=True) + elif 'w' == ch: + # Toggle the print model + if print_model == PRINT_MODEL_1: + print_model = PRINT_MODEL_2 + else: + print_model = PRINT_MODEL_1 + elif 's' == ch: + # Toggle the sort model + if sort_model == SORT_DEPS: + sort_model = SORT_ALPHA + elif sort_model == SORT_ALPHA: + if SORT_BITBAKE_ENABLE: + sort_model = TASK_SORT_BITBAKE + else: + sort_model = SORT_DEPS + else: + sort_model = SORT_DEPS + active_package.cursor_on(False) + current_task = active_package.get_selected() + dep.package_view.sort() + dep.dep_view.sort() + dep.reverse_view.sort() + active_package = dep.package_view + active_package.cursor_on(True) + dep.select(current_task) + # Announce the new sort model + alert("SORT=%s" % ("ALPHA" if (sort_model == SORT_ALPHA) else "DEPS"),screen) + alert('',screen) + + elif 'q' == ch: + quit = True + elif ch in ('h','?'): + dep.help_box_view.show_help(True) + dep.select(active_package.get_selected()) + + # + # Debugging commands + # + + elif 'V' == ch: + verbose = not verbose + alert('Verbose=%s' % str(verbose),screen) + alert('',screen) + elif 'R' == ch: + screen.refresh() + elif 'B' == ch: + # Progress bar unit test + dep.progress_view.progress('Test',0,40) + curses.napms(1000) + dep.progress_view.progress('',10,40) + curses.napms(1000) + dep.progress_view.progress('',20,40) + curses.napms(1000) + dep.progress_view.progress('',30,40) + curses.napms(1000) + dep.progress_view.progress('',40,40) + curses.napms(1000) + dep.progress_view.clear() + dep.help_bar_view.show_help(True) + elif 'Q' == ch: + # Simulated error + curses_off(screen) + print('ERROR: simulated error exit') + return 1 + + # Safe exit + curses_off(screen) + except Exception as e: + # Safe exit on error + curses_off(screen) + print("Exception : %s" % e) + print("Exception in startup:\n %s" % traceback.format_exc()) + + # Reminder to pick up your printed results + if is_printed: + print("") + print("You have output ready!") + print(" * Your printed dependency file is: %s" % print_file_name) + print(" * Your previous results saved in: %s" % print_file_backup_name) + print("") |