import subprocess from queue import Queue from threading import Thread import os import time import json5 import re import sys import ast from bqplot import * import bqplot.pyplot as plt import sqlite3 from typing import List from .stap_kernel import * from ipyevents import Event from ipywidgets import Text, Button, Tab, GridBox, Layout, Label, HBox, VBox, Output, TagsInput, Combobox, IntProgress, HTML, Valid from IPython.display import JSON, Code, Markdown, Javascript from shlex import quote # FIXME: poll's small changes should be added to the jupyter-ui-poll, and the file should be removed from .poll import ui_events JUPYTER_MAGIC = "JUPYTER_MAGIC_" # File is created at build time try: from .constants import STAP_PKGDATADIR, STAP_PREFIX STAP_INSTALL_DIR = f'{STAP_PREFIX}/bin' SUBPROCESS_ENV = {**os.environ, 'PATH':f'{STAP_INSTALL_DIR}:{os.environ["PATH"]}'} except: # An educated guess STAP_PKGDATADIR = '/usr/local/share/systemtap' STAP_INSTALL_DIR = '/usr/bin' SUBPROCESS_ENV = None # When running in a container we ssh back to the host to run stap. The dest is the host ip we use (localhost here) try: from .constants import SSH_DEST except: SSH_DEST = None def format_subprocess_args(*args): flattened_args = [] for a in args: if type(a) is list: flattened_args.extend(a) else: flattened_args.append(a) if SSH_DEST: command = f'PATH={STAP_INSTALL_DIR+":$PATH"} ' + " ".join([quote(a) for a in flattened_args]) flattened_args = ['ssh', SSH_DEST, command] return flattened_args class JSubprocess(subprocess.Popen): """ A subprocess that allows to read its stdout and stderr in real time Based on https://github.com/brendan-rius/jupyter-c-kernel/blob/master/jupyter_c_kernel/kernel.py """ def __init__(self, cmd): super().__init__(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=0) self._stdout_queue = Queue() self._stdout_leftovers = list() self._stdout_thread = Thread( target=JSubprocess._enqueue_output, args=(self.stdout, self._stdout_queue)) self._stdout_thread.daemon = True self._stdout_thread.start() self._stderr_queue = Queue() self._stderr_leftovers = list() self._stderr_thread = Thread( target=JSubprocess._enqueue_output, args=(self.stderr, self._stderr_queue)) self._stderr_thread.daemon = True self._stderr_thread.start() def write_to_stdin(self, contents): self.stdin.write(contents.encode()) self.stdin.flush() @staticmethod def _enqueue_output(stream, queue): """ Add chunks of data from a stream to a queue until the stream is empty. """ for line in iter(lambda: stream.read(4096), b''): queue.put(line) stream.close() def get_lines(self, retain_partial_lines=True): """ Return a list of tuples (line, stream). Unless retain_partial_lines is False it is safe to assume a line is complete (ends with \n) """ lines = [] def read_all_from_queue(queue, leftovers, stream_name): res = b''.join(leftovers) leftovers.clear() size = queue.qsize() while size != 0: res += queue.get_nowait() size -= 1 raw_lines = res.split(b'\n') if len(res) > 0 and res[-1] != b'\n' and retain_partial_lines: leftovers.append(raw_lines.pop()) lines.extend([(line + b'\n', stream_name) for line in raw_lines if line != b'']) read_all_from_queue(self._stdout_queue, self._stdout_leftovers, "stdout") read_all_from_queue(self._stderr_queue, self._stderr_leftovers, "stderr") return lines class JHistogram(): def __init__(self, kernel, func, name, start=0, end=0, width=0): self.kernel = kernel self.name = name self.func = func self.start = int(start) self.end = int(end) self.width = int(width) self.data = [] def record_entry(self, bucket, value): self.data.append((bucket, value)) def display_hist(self): bins = [p[0] for p in self.data] counts = [p[1] for p in self.data] try: # bqplot bar plot scale_x = OrdinalScale() scale_y = LinearScale() fig = plt.figure( title=f'{"Linear" if self.func == "linear" else "Logarithmic"} Histogram of {self.name}') def_tt = Tooltip(fields=['x', 'y'], labels=['Value', 'Count']) bar = plt.bar(x=bins, y=counts, scales={'x': scale_x, "y": scale_y}, colors=['coral'], stroke='white', stroke_width=0.4, tooltip=def_tt) self.kernel.display(fig) except Exception as e: self.kernel.error(e) class JNamespace: def __init__(self, kernel, name=""): self.name : str = name # If "name" is used as a module name will be updated to "name"i at runtime self.mod_name: str = name self.kernel = kernel self._cells : List[JCell] = list() self._proc : JSubprocess = None self._globals: dict = dict() def __del__(self): # If the destructor is called, remove the namespace # from the kernel's map self.kernel.jnamespaces.pop(self.name, None) def add_cell(self, cell): self._cells.append(cell) def remove_cell(self, cell): if cell in self._cells: self._cells.remove(cell) def remove_cell_by_id(self, cell_id): self._cells = [c for c in self._cells if c.cell_id != cell_id] def remove_all_cells(self): self._cells.clear() def get_cells(self): return self._cells def update_globals(self, globals_dict): """Update the internal states of the namespace's globals""" # Keep what is already stored if globals_dict is None: return globs = {} for g, v in globals_dict.items(): if isinstance(v, dict): # An array so parse the keys # May have tuple keys for stap assosiative array # For stats keys will just be unparsed strings globs[g] = {(ast.literal_eval( k) if "\"" in k or "(" in k else k): vi for k, vi in v.items()} else: globs[g] = v self._globals = globs def get_globals(self): return self._globals class CellExeMode(): EDIT = "edit" RUN = "run" SCRIPT = "script" PYTHON = "python" EXAMPLES = "examples" PROBES = "probes" HELP = "help" UNDEF = "undefined" class JCell: def __init__(self, cell_id: str, kernel): self.cell_id = cell_id self.kernel = kernel self.namespace: JNamespace = None self.mode = CellExeMode.UNDEF self.script = "" self.options = list() self.args = list() self.hist: JHistogram = None def __del__(self): # When a cell's dtor is called, make sure to remove it # (not just a cell with the same id) from the namespace too if self.namespace: self.namespace.remove_cell(self) if self.namespace.get_cells == []: del self.namespace def _load_script(self, code: str): script = "" namespace = "" try: for line in code.split("\n"): # We found a possible magic header if len(line) >= 2 and line[:2] == "%%": if self.mode != CellExeMode.UNDEF: self.kernel.error( "Only 1 magic command is allowed per cell") return False # Before anything else, see if our internal special argument (--args) # exists, and if so extract and parse it a_start = line.find('--args') a_open, a_close = line.find( '(', a_start), line.rfind(')', a_start) if a_start != -1: if a_open > a_close or a_open == -1 or a_close == -1: self.kernel.error( "Invalid args usage: Should be --args=(x,y,z)") return False else: self.args = line[a_open+1: a_close].split(",") # We've removed the args, so the line is updated accordingly line = line[:a_start] + line[a_close+1:] split_magic = line[2:].rstrip().split(" ") command = split_magic.pop(0) # Cells with namespaces if command in (CellExeMode.EDIT, CellExeMode.RUN, CellExeMode.PYTHON, CellExeMode.SCRIPT): # We have a magic with a namespace provided # otherwise namespace = "" i.e the global namespace if len(split_magic) >= 1 and split_magic[0][0] != '-': namespace = split_magic.pop(0) # Cells with arguments if command != CellExeMode.SCRIPT and self.args != []: self.kernel.error( "Invalid args usage: Should only be used with script cells") return False # Cells with options VALID_OPTIONS = ('-v', '--vp', '-V', '--version', '-P', '-u', '-w', '-W', '-t', '-s', '-I', '-D', '-B', '-a', '--modinfo', '-r', '-d', '--ldd', '--all-modules', '-c', '-x', '-T', '-g', '--prologue-searching', '--suppress-handler-errors', '--compatible', '--check-version', '--disable-cache', '--poison-cache', '--privilege', '--unprivileged', '--download-debuginfo', '--rlimit-', '--sysroot', '--runtime', '--dyninst', '--bpf', '--suppress-time-limits') if command not in (CellExeMode.EDIT, CellExeMode.RUN, CellExeMode.SCRIPT) and split_magic != []: self.kernel.error( "Invalid options usage: Should only be used with run, edit and script cells. Skipping line") return False else: self.options = split_magic # Make sure the flags are all valid if any(all(not flag.startswith(valid_flag) for valid_flag in VALID_OPTIONS) for flag in [o for o in self.options if o[0] == '-']): self.kernel.error( f'Invalid Options: {self.options}. Only {VALID_OPTIONS} can be used') return False if command not in (CellExeMode.EDIT, CellExeMode.EXAMPLES, CellExeMode.HELP, CellExeMode.PROBES, CellExeMode.PYTHON, CellExeMode.RUN, CellExeMode.SCRIPT): self.kernel.error( f"Skipping unknown magic command {command}") return False self.mode = command elif len(line) >= 1 and line[0] == "!": p = subprocess.run(format_subprocess_args(line[1:].split(" ")), capture_output=True, text=True, env=SUBPROCESS_ENV) if p.stdout: self.kernel.write(p.stdout) if p.returncode != 0: self.kernel.error(p.stderr) return False else: # We want to find lines which print histograms and bookend them with magic commands that isystemtap # will recognize to replace the output with our own. r = re.compile( r'(.*?(?=print))(print.*\(.*\@hist_)(.*\)*)(.*)') m = r.search(line) if m: prefix = m[1] # Stuff before operator = m[2] # Ex. 'print(@hist_' operands = m[3] # Ex. 'log(foo)' or 'linear(a, 1,2, 3)' suffix = m[4] # Stuff after self.kernel.log.debug( f'Parsed histogram with {prefix, operator, operands, suffix = }') # Don't magic up commented out histograms if any(c in prefix for c in ('//', '#', '/*')): self.kernel.log.debug( 'Skipping commented histogram') script += line+"\n" continue # We can't print a histogram for '@hist_log(foo)[0] or @hist_linear(bar[baz], 1, 2 , 3)[2]' # If a ) comes before a [ then we can say that the hist_foo(...) is done and then an index is started so skip if operands.find(")") < operands.rfind("["): self.kernel.log.debug( 'Skipping hisogram which is being indexed') script += line+"\n" continue # The inner most '(' and the outmost ')' paren_open, paren_close = operands.rfind( "("), operands.find(')') # We use the commands hist_FUNC:ARG1:... and hist_end args = [operands[:paren_open]] + [s.strip() for s in operands[paren_open + 1:paren_close].split(",")] # We want to display the literal for scalar stats BUT the value for the arguments to arrays # Ex. hist_log(foo[name]) should be called foo[VALUE_OF_NAME] p1_args = "" if '[' in args[1]: index_open = args[1].find("[") index_close = args[1].find(']') subscript = args[1][index_open+1: index_close] p1_args = f', {subscript}' # Replace the subscript with the appropriate %s, ... args[1] = args[1][:index_open+1] + ", ".join( ["%s" for _ in subscript.split(",")]) + args[1][index_close:] p1 = "hist_" + ":".join(args) p2 = "hist_end" line = prefix + f' ; printf("\\n{JUPYTER_MAGIC}{p1}\\n"{p1_args}); ' + \ operator + operands + \ f' ; println("\\n{JUPYTER_MAGIC}{p2}\\n"); ' + suffix self.kernel.log.debug( f'Histogram line replaced with { line }') script += line+"\n" except: return False if self.mode == CellExeMode.UNDEF and script != "": self.kernel.print( "Defaulting to a script cell") self.mode = CellExeMode.SCRIPT if not re.match(r"^[a-z0-9_]*$", namespace): self.kernel.error( f'"{namespace}" is not a valid namespace i.e ^[a-z0-9_]*$') return False if namespace == "": namespace = "isystemtap_global" # We get a namespace BUT are not yet added to it, that's only done once validity is checked if namespace not in self.kernel.jnamespaces: ns = JNamespace(self.kernel, namespace) self.namespace = ns self.kernel.jnamespaces[namespace] = ns else: self.namespace = self.kernel.jnamespaces[namespace] # FIXME: What if the cell was in a different namespace self.namespace.remove_cell_by_id(self.cell_id) self.script = script self.kernel.log.debug( f'Loaded cell of type {self.mode} into namespace "{self.namespace.name}" with args {self.args} and options {self.options}') self.kernel.log.debug(f'The script is: {self.script}') return True def _validate_syntax(self): """ Run pass 1; To quickly detect any syntax errors """ p = subprocess.run(format_subprocess_args("stap", "-e", self.script, "-p1"), capture_output=True, text=True, env=SUBPROCESS_ENV) if p.returncode == 0: return True else: self.kernel.send_response(self.kernel.iopub_socket, 'stream', { 'name': "stderr", 'text': p.stderr}) return False def _validate_symbols_and_types(self): """ Run pass 2 against all of the cells within the namespace, combining them into 1 large virtual_script (In the order they are executed) On success add this cell to the namespace's execution queue otherwise remove any info from this cell, since its invalid """ # Combine the various partial-scripts virtual_script = "".join(cell.script for cell in self.namespace.get_cells()) virtual_script += self.script # In order to avoid a premature no probes found error just add a never probe # This will never make it to stap passes 3+, just temporarily avoid the error virtual_script += '\n probe never { printf("Spam, Ham and Eggs") } ' p = subprocess.run(format_subprocess_args("stap", self.options, "-e", virtual_script, "-p2"), capture_output=True, text=True, env=SUBPROCESS_ENV) self.kernel.log.debug(f'Executing {p.args}') if p.returncode == 0: self.namespace.add_cell(self) return True else: self.kernel.send_response(self.kernel.iopub_socket, 'stream', { 'name': "stderr", 'text': p.stderr}) return False def _run_namespace(self): # Stitch together the cells into 1 virtual script virtual_script = "".join(cell.script for cell in self.namespace.get_cells()) # We need to ensure the module name is not in use already self.namespace.mod_name = self.namespace.name i = 1 with open("/proc/modules", "r") as f: # Technically this introduces a race condition where the modules list is only loaded once # so k users could simultaneously find the same 'free' mod name. But even if restricted to a read each # loop iter the race condition remains, so just leave it since this is faster. modules = f.read() while True: if self.namespace.mod_name not in modules: break self.namespace.mod_name = f'{self.namespace.name}{i}' i += 1 extra_options = [ "-m", self.namespace.mod_name, "--monitor", #FIXME: Is there a way to wait for --monitor mode to start up fully "-D", "MAXSTRINGLEN=4096", "--skip-badvars", "-e", virtual_script ] cmd = format_subprocess_args("stap", self.options, extra_options, self.args) self.kernel.log.info(f'Executing {cmd}') p = JSubprocess(cmd) proc_path = f'/proc/systemtap/{self.namespace.mod_name}' def monitor_write(content): try: f = open(proc_path+"/monitor_control", 'w') f.write(content) f.flush() f.close() except OSError: pass # Tab 0: Controls class tab_controls: def __init__(self, namespace, options, args): self.uptime = Label(value="Uptime: 00:00:00") self.memory = Label( value="Memory: 0data/0text/0ctx/0net/0alloc KB") self.play_pause = Button( button_style='info', tooltip='Pause/resume script by toggling off/on all probes', icon='pause') def handle_play_pause(button): if button.icon == "pause": # Script is running monitor_write('pause') button.icon = "play" else: monitor_write('resume') button.icon = "pause" self.play_pause.on_click(handle_play_pause) self.stop = Button(button_style='danger', tooltip='Quit script', icon='stop') self.stop.on_click(lambda _: monitor_write('quit')) self.reset = Button( button_style='info', tooltip='Reset all global variables to their initial states', icon='rotate-left') self.reset.on_click(lambda _: monitor_write('clear')) self.export = Button( button_style='info', tooltip='Export the script', icon='download') self.export_out = Output() self.export_hbox = HBox([self.export,self.export_out]) def handle_export(btn): btn.icon='check-circle' btn.disabled = True file_content = f'#!stap {" ".join(options)} {" ".join(args)}\n' file_content += virtual_script # The following is based on # https://stackoverflow.com/questions/3749231/download-file-using-javascript-jquery jscode = ' \ const blob = new Blob([%s], { type : "plain/text" }); \ const url = window.URL.createObjectURL(blob); \ const a = document.createElement("a"); \ a.style.display = "none"; \ a.href = url; \ a.download = "%s"; \ document.body.appendChild(a); \ a.click(); \ window.URL.revokeObjectURL(url);' % (json.dumps(file_content), f'{namespace}.stp') self.export_out.append_display_data(Javascript(jscode)) self.export.on_click(handle_export) self.stdin = Text(description='>>>') self.controls = VBox(\ [self.export_hbox, HBox([self.uptime, self.memory]), HBox([self.play_pause, self.reset, self.stop]), self.stdin]) def get_widget(self): return self.controls def update(self, uptime, memory): if uptime: self.uptime.value = f'Uptime: {uptime}' if memory: self.memory.value = f'Memory: {memory}' def disable(self): for sub_widget in [self.play_pause, self.stop, self.reset, self.stdin]: sub_widget.disabled = True # Tab 1: Globals class tab_globals: def __init__(self): self.global_viewer = Output() # FIXME: The flickering issue is known, but how do I know a height to set it to? # https://ipywidgets.readthedocs.io/en/stable/examples/Using%20Interact.html#Flickering-and-jumping-output def get_widget(self): return self.global_viewer def update(self, globals_json): if globals_json is None and len(self.global_viewer.outputs) != 0: # Keep the old data (ex. after cell execution) pass elif globals_json is None and len(self.global_viewer.outputs) == 0: self.global_viewer.append_display_data(Markdown(data="*No data available*")) else: # NB: What should be done here is a tab_globals.clear_output() # The issue is that this isn't the primary Output widget and so # the clear doesn't act correctly. So we do this 'hack' variant self.global_viewer.outputs = () self.global_viewer.append_display_data(JSON(data=globals_json, expanded=True, root="globals")) # Tab 2: Probes class tab_probes: def __init__(self): self._num_columns = 6 self.probes = GridBox([], layout=Layout( grid_template_columns='5ch 1fr 1fr 1fr 1fr 1fr')) def get_widget(self): return self.probes def update(self, probes_json): if probes_json is None: # TODO: Might be nice to have a `no data` sort of thing return p_list = [Label(value=v, style={'font_weight': 'bold'}) for v in ( 'state', 'name', 'hits', 'min', 'avg', 'max')] for d in probes_json: state = Button(button_style='danger', tooltip='Toggle Probe', icon='check-square' if d['state'] == 'on' else 'square', layout=Layout(width='5ch')) # We need to store which probe this button goes with, since the actual button will change with update, # but the class will remain const state.add_class(f'probe_idx_{d["index"]}') state.on_click(lambda button: monitor_write(button._dom_classes[-1][len("probe_idx_"):])) p_list += [state, Label(value=d['name']), Label(value=str(d['hits'])), Label( value=str(d['min'])), Label(value=str(d['avg'])), Label(value=str(d['max']))] self.probes.children = p_list def disable(self): state_buttons = self.probes.children[self._num_columns::self._num_columns] for button in state_buttons: button.disabled = True controls_view = tab_controls(self.namespace.name, self.options, self.args) globals_view = tab_globals() probes_view = tab_probes() # The Tab Structure tab_content = { "Controls": controls_view.get_widget(), "Globals": globals_view.get_widget(), "Probes": probes_view.get_widget() } tab = Tab(children=list(tab_content.values())) for i, k in enumerate(tab_content.keys()): tab.set_title(i, k) # Handle keyboard events within the widget keyboard_event = Event(source=tab, watched_events=['keydown']) def handle_keydown(event): if not p or p.poll() is not None: return if event['ctrlKey']: match event['key']: case 'c': monitor_write('quit') else: # This means we clicked a special key like 'backspace' or 'arrow' if len(event['key']) > 1: return # Write the new char to stdin try: p.write_to_stdin(event['key']) except BrokenPipeError: pass controls_view.stdin.value += event['key'] keyboard_event.on_dom_event(handle_keydown) self.kernel.display(tab) def update_widget_states(last_updated_monitor=0, monitor_files_owned = True): """Update the widgets, but only do so once every 0.5s (more frequent isn't needed for graphics)""" jso = dict() try: # We need read/write access to the procfs files. If running directly on the host these have no issues BUT # if running a container as root then the notebook (current) user in the container can't accesss these controls # so the first time we can do a read (monitor_files_owned is false but the file exists), we # chown them if SSH_DEST and not monitor_files_owned and os.path.exists(proc_path): files = ['monitor_control', 'monitor_status'] for f in files: subprocess.run(format_subprocess_args('chown', '--silent', f'{os.getuid()}:{os.getgid()}', f'{proc_path}/{f}'), stderr=subprocess.DEVNULL) monitor_files_owned = True with open(proc_path+"/monitor_status", 'r') as content: # We use json5 to allow for tailing commas in the json format jso = json5.load(content) except: pass # Update the internal copy of the globals, for use with python cells self.namespace.update_globals(jso.get("globals", None)) now = time.time() if now - last_updated_monitor < 0.5: return last_updated_monitor, monitor_files_owned # Update tabs content controls_view.update(jso.get("uptime", None), jso.get("memory", None)) globals_view.update(jso.get("globals", None)) probes_view.update(jso.get('probe_list', None)) return now, monitor_files_owned def write_to_output(content, output_disabled): """Write content (a list of line, stream pairs) to the stream (stdout or stderr). If output_disabled skip Returns True iff the output is disabled i.e the process is not running """ if output_disabled: return True for line, stream in content: s_line = line.decode() # Handle jupyter magic lines if s_line.startswith(JUPYTER_MAGIC): command = s_line[len(JUPYTER_MAGIC):].strip() if command == "hist_end": # Display the histogram and then clear the # internal repr (since while it exists, isystemtap assumes # it needs to be filled) self.hist.display_hist() self.hist = None continue elif command.startswith("hist_"): # The start of a histogram block is found # The format is hist_func:arg1:arg2:... hist_args = command[len("hist_"):].split(":") self.hist = JHistogram(self.kernel, *hist_args) continue # We have an active histogram so take that data and make it pretty if self.hist: # s_line is of the form #'value |-------------------------------------------------- count' s_split = s_line.strip().split(" ") # If we're not the heading, record that line if s_split[0] != 'value' and len(s_split) > 3: # FIXME: Looks like when using sprint* we lose the last count value, count = s_split[0], int(s_split[-1]) self.hist.record_entry(value, count) continue # If we get here, we just have a regular line so output it self.kernel.send_response(self.kernel.iopub_socket, 'stream', { 'name': stream, 'text': s_line}) return False output_disabled = False last_updated_monitor = time.time() # We only need to update so often monitor_files_owned = False # Start the main loop with ui_events(self.kernel) as ui_poll: while p.poll() is None: try: # Write any lines to stdout/err if any are ready output_disabled = write_to_output(p.get_lines(), output_disabled) # Get UI events (up to 10 at a time) # NB: Jupyter isn't designed to have UI elements be interactive while a cell is # running, so this polling is very important for the controls widgets ui_poll(10) # Update the widgets states (controls, globals and probes) & update the internal globals (for python usage) last_updated_monitor, monitor_files_owned = update_widget_states(last_updated_monitor, monitor_files_owned) except KeyboardInterrupt: # The kernel sent a sigint (I, I), so catch it and pass on to the child # to allow stap to gracefully terminate monitor_write('quit') # On that last line, don't hold back even if there is a partial result (not \n terminated) output_disabled = write_to_output(p.get_lines(retain_partial_lines=False), output_disabled) # Do our best to cleanup after ourselves try: p = subprocess.run(format_subprocess_args('rm', '-f', f'{self.namespace.name}.ko')) except OSError: pass # Disable the buttons now that we're done controls_view.disable() probes_view.disable() # Give a final update to make sure it's as up to date as we can make it update_widget_states() return p.returncode == 0 def _run_python(self): status = True try: old_stdout, old_stderr = sys.stdout.write, sys.stderr.write sys.stdout.write = lambda *args: self.kernel.send_response( self.kernel.iopub_socket, 'stream', {'name': "stdout", 'text': str(args)}) sys.stderr.write = lambda *args: self.kernel.send_response( self.kernel.iopub_socket, 'stream', {'name': "stderr", 'text': str(args)}) # Run the script in python with the systemtap globals defined # Also add in display and print exec(self.script, self.namespace.get_globals() | { "display": self.kernel.display, "print": self.kernel.print}) except Exception as e: self.kernel.error(e) status = False sys.stdout.write, sys.stderr.write = old_stdout, old_stderr return status def _run_help(self): self.kernel.print('ISystemtap') self.kernel.print( f'%%{CellExeMode.EDIT} [ NAMESPACE ] -[ OPTIONS ]\n\tA piece of a script in NAMESPACE') self.kernel.print( f'%%{CellExeMode.RUN} [ NAMESPACE ] -[ OPTIONS ]\n\tCombine and run the edit cells in NAMESPACE') self.kernel.print( f'%%{CellExeMode.SCRIPT} [ NAMESPACE ] -[ OPTIONS ] [ --args=(ARGUMENTS) ]\n\tRun an entire script. May be give command line args') self.kernel.print( f'%%{CellExeMode.PYTHON} [ NAMESPACE ]\n\tRun a python script using the globals from NAMESPACE') self.kernel.print( f'%%{CellExeMode.EXAMPLES}\n\tRun a python script using the globals from NAMESPACE') self.kernel.print( f'%%{CellExeMode.PROBES}\n\tList all available probe points matching the given single probe (See stap -L)') self.kernel.print(f'%%{CellExeMode.HELP}\n\tRefer to %%help for more information') self.kernel.print( f'!command [ ARGUMENTS ]\n\tRun command in a shell') self.kernel.print(f'Run !stap --help for more information on available options') def _run_examples(self): title = Text() # Query the DB for the possibilities con = None DB_PATH = STAP_PKGDATADIR + "/examples/metadatabase.db" try: con = sqlite3.connect(DB_PATH) except: self.kernel.error(f"Unable to connect to examples database: {DB_PATH}") return False res = con.execute('SELECT DISTINCT keywords, name from metavirt') keywords = set() # Possible keywords example_names = list() # Possible examples for k in res.fetchall(): keywords |= set(k[0].split(" ")) example_names.append(k[1]) keyword_picker = TagsInput( value=[], allowed_tags=list(keywords), allow_duplicates=False ) name = Combobox( placeholder='example_script.stp', options=example_names, ensure_option=True ) search_button = Button(button_style='info', tooltip='Search', icon='search') clear_button = Button(button_style='info', tooltip='Clear', icon='refresh') # The top control Box search_controls = VBox([ Label(value="Systemtap Example Search", style={ 'font_weight': 'bold', 'font_size': '1.5em'}), HBox([ Label(value="Name ", style={'font_weight': 'bold'}), name, Label(value="Title Contains", style={'font_weight': 'bold'}), title ]), HBox([ Label(value="Keywords", style={'font_weight': 'bold'}), keyword_picker, ]), HBox([ search_button, clear_button ]) ]) # The table, where the results are stored table = VBox(layout=Layout(width='50%')) # Holds the table and the output of the example (as well as the script viewer) side_by_side_viewer = HBox([table]) SQL_EXTRACTION = 'SELECT title, name, keywords, description, path FROM metavirt WHERE ' def make_row(title, name, keywords, description, path): out = Output(layout=Layout(border='solid 2px', width='50%')) full_path = f'{STAP_PKGDATADIR}/examples/{path}/{name}' # The controls for running an example run = Button(button_style='info', tooltip='Run', icon='play') back = Button(button_style='info',tooltip='Back', icon='times') options = TagsInput(value=[], allow_duplicates=True) args = TagsInput(value=[], allow_duplicates=True) controls = VBox([ HBox([run, back], layout=Layout(display='flex', flex_flow='row', align_items='flex-end')), HBox([Label(value="Options", style={ 'font_weight': 'bold'}), options]), HBox([Label(value="Arguments", style={ 'font_weight': 'bold'}), args]) ]) # The example code preview code_block = Code(filename=full_path, language="c") # TODO: In order to highlight the code we need a pygments lexer # class SystemtapLexer(RegexLexer): ... Will end up with the same logic as the codemirror regex highlighting # Left for now due to https://github.com/ipython/ipython/issues/11747 def handle_back(_): side_by_side_viewer.children = [table] back.on_click(handle_back) def handle_run(_): # Remove any old run outputs out.outputs = out.outputs[:2] # Just keep controls, code_block # out.outputs = () # out.append_display_data(controls) # out.append_display_data(code_block) with out, open(full_path, 'r') as example: c = JCell("examplecell", self.kernel) print("Executing") res = c.execute( f'%%script example_{name[:-4].replace("-", "_")} {" ".join(options.value)} { "" if args.value == [] else "--args=(" + ",".join(args.value) + ")" }\n{example.read()}') self.kernel.display( Valid(value=res['status'] == 'ok', readout="Execution Failure")) run.on_click(handle_run) preview = Button(button_style='info', tooltip='Preview example script', icon='eye') def handle_preview(_): out.outputs = () out.append_display_data(controls) out.append_display_data(code_block) side_by_side_viewer.children = [table, out] preview.on_click(handle_preview) row = VBox( children=[ Label(value=f'{name}: {title}', style={ 'font_weight': 'bold', 'font_size': '1.1em'}), HTML(description), # HTML wraps Label(value=keywords, style={'font_style': 'italic'}), preview ], layout=Layout( border='solid 2px', )) return row def handle_search(_): # SQLite objects created in a thread can only be used in that same thread con = sqlite3.connect(DB_PATH) res = None if name.value != '': # If given an exact script, just pull it up by name res = con.execute(SQL_EXTRACTION + 'name = ?', (name.value, )) else: # Otherwise we need to do a proper search CONDITON = " AND ".join( ['title LIKE ?'] + # The title is like the given substring # Each keyword given must be a substring of the one within the DB # Since keywords are 'foo bar baz'. So ex. we need to match keywords LIKE foo AND keywords like bar ['keywords LIKE ?'] * len(keyword_picker.value) ) params = tuple('%'+p+'%' for p in (title.value, )+tuple(keyword_picker.value)) res = con.execute(SQL_EXTRACTION + CONDITON, params) table.children = [make_row(*r) for r in res] side_by_side_viewer.children = [table] search_button.on_click(handle_search) name.on_submit(handle_search) title.on_submit(handle_search) def handle_clear(_): title.value = '' name.value = '' keyword_picker.value = [] table.children = [] side_by_side_viewer.children = [table] clear_button.on_click(handle_clear) self.kernel.display(VBox([search_controls, side_by_side_viewer])) def _run_probe_list(self): query = Text() search_button = Button(button_style='info', tooltip='Search', icon='search') clear_button = Button(button_style='info', tooltip='Clear', icon='refresh') results = VBox([]) def list_probes(_): # Just visual feedback since the loading can take a second. This serves no real purpose progress = IntProgress(value=2, min=0, max=5, step=1, bar_style='info', orientation='horizontal') results.children = [progress] rows = [] p = subprocess.run(format_subprocess_args("stap", '-L', query.value), capture_output=True, text=True, env=SUBPROCESS_ENV) progress.value = 4 # Again just a visual thing if p.returncode == 0: for line in str(p.stdout).split('\n'): pp_end = line.find(' ') if pp_end != -1: # There is a space i.e context variables probe_point, context_vars = line[:pp_end], line[pp_end+1:] else: probe_point, context_vars = line, "" rows.append(VBox([ Label(value=probe_point, style={ 'font_weight': 'bold', 'font_size': '1.1em'}), # We use HTML, since Labels render LaTex (so $arg: ... $arg2 is math mode causing issues) HTML(f'{context_vars}') ])) results.children = rows search_button.on_click(list_probes) query.on_submit(list_probes) def clear_list(_): query.value = "" results.children = [] clear_button.on_click(clear_list) self.kernel.display(VBox([ Label(value="Systemtap Probe List", style={ 'font_weight': 'bold', 'font_size': '1.5em'}), Label(value="List all available probe points (and context variables) matching the given single probe point. The pattern may include wildcards and aliases", style={'font_style': 'italic'}), HBox([Label(value="probe", style={'font_weight': 'bold'}), query]), HBox([search_button, clear_button]), results ])) def execute(self, code): if not self._load_script(code): status = 'error' else: status = 'ok' match self.mode: case CellExeMode.EDIT: actions = [self._validate_syntax, self._validate_symbols_and_types] case CellExeMode.RUN: actions = [self._run_namespace] case CellExeMode.PYTHON: actions = [self._run_python] case CellExeMode.SCRIPT: def add_to_ns(): # As a script there are no other cells to stitch, # so we want remove the previous scripts (if they exist) self.namespace.remove_all_cells() self.namespace.add_cell(self) return True actions = [add_to_ns, self._run_namespace] case CellExeMode.EXAMPLES: actions = [self._run_examples] case CellExeMode.PROBES: actions = [self._run_probe_list] case CellExeMode.HELP: actions = [self._run_help] case _: actions = [] for a in actions: if not a(): status = 'error' break return {'status': status, 'execution_count': self.kernel.execution_count, 'payload': [], 'user_expressions': {}, }