#!/usr/bin/python3 # vim: tabstop=4 shiftwidth=4 softtabstop=4 # Copyright 2015 Lenovo # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import atexit import asyncio import base64 import optparse import os import shlex import subprocess import sys path = os.path.dirname(os.path.realpath(__file__)) path = os.path.realpath(os.path.join(path, '..', 'lib', 'python')) if path.startswith('/opt'): sys.path.append(path) import confluent.asynclient as client import confluent.client as synclient import confluent.sortutil as sortutil import confluent.logreader as logreader import confluent.vnc as vnc import enum import time import select import signal import socket import re import queue import threading import tty import termios import fcntl import confluent.screensqueeze as sq try: from PIL import Image, ImageDraw, ImageFont except ImportError: Image = None try: # sixel is optional, attempt to import but stub out if unavailable import io import sixel class DumbWriter(sixel.SixelWriter): def restore_position(self, output): return except ImportError: class DumbWriter(): def draw(self, imgfile): sys.stderr.write("PySixel not detected, Sixel format display not supported\n") expecting_cpr = False # cursor position report current_cursor = (1, 1) confettypath = os.path.join(os.path.dirname(sys.argv[0]), 'confetty') argparser = optparse.OptionParser( usage="Usage: %prog [options] [kill][-- [passthroughoptions]]", epilog="Command sequences are available while connected to a console, hit " "ctrl-'e', then release ctrl, then 'c', then '?' for a full list. " "For example, ctrl-'e', then 'c', then '.' will exit the current " "console") argparser.add_option('-a', '--automation', type='string', default=None, help='Specify an automation script') argparser.add_option('-t', '--tile', action='store_true', default=False, help='Tile console windows in the terminal') argparser.add_option('-e', '--headless', action='store_true', default=False, help='Run in headless mode, which is designed for use with ' 'automation scripts and disables interactive features') argparser.add_option('-l', '--log', action='store_true', default=False, help='Enter log replay mode instead of showing a live console') argparser.add_option('-T', '--Timestamp', action='store_true', default=False, help= 'Dump log in stdout with timestamps') argparser.add_option('-s', '--screenshot', action='store_true', default=False, help='Attempt to grab screenshot and render using kitty image protocol') argparser.add_option('-i', '--interval', type='float', help='Interval in seconds to redraw the screenshot. Currently only ' 'works for one node') argparser.add_option('-v', '--video', action='store_true', default=False, help='Attempt to continuously stream video from nodes that support streaming console via confluent') argparser.add_option('-o', '--outputfile', type='string', default=None, help='Record VNC mode output to the specified video file. When ' 'multiple nodes are recorded, use a confluent attribute ' 'expression (e.g. "{node}.mp4") to make the filename unique ' 'for each node. If multiple nodes specified but not an expression, node name will be inserted.') argparser.add_option('-w','--windowed', action='store_true', default=False, help='Open terminal windows for each node. The ' 'environment variable NODECONSOLE_WINDOWED_COMMAND ' 'should be set, which should be a text string corresponding ' 'to a command that can be used to open a windowed console,' ' omitting the "nodeconsole " part of the ' 'command, for example, to open a set of consoles for a ' 'range of nodes in separate xterm windows, set ' 'NODECONSOLE_WINDOWED_COMMAND to "xterm -e". To open a ' 'set of consoles for a range of nodes in separate ' 'GNOME Terminal windows with a size of 100 columns and ' '31 rows, set NODECONSOLE_WINDOWED_COMMAND ' 'to "gnome-terminal --geometry 100x31 --" or in a WSL ' 'environment, to open a set of consoles for a range of ' 'nodes in separate Windows Terminal windows, with the ' 'title set for each node, set NODECONSOLE_WINDOWED_COMMAND' ' to "wt.exe wsl.exe -d AlmaLinux-8 ' '--shell-type login". If the NODECONSOLE_WINDOWED_COMMAND ' 'environment variable isn\'t set, xterm will be used by ' 'default.') (options, args) = argparser.parse_args() automation_args = [] if options.automation: automation_args = ['-a', options.automation] if options.headless: automation_args += ['--headless'] oldtcattr = None oldfl = None streaming = False class ModifiedKey: def __init__(self, key, modifierstate=None): self.key = key self.modifierstate = modifierstate class SpecialKeys(enum.Enum): F1 = 0xffbe F2 = 0xffbf F3 = 0xffc0 F4 = 0xffc1 F5 = 0xffc2 F6 = 0xffc3 F7 = 0xffc4 F8 = 0xffc5 F9 = 0xffc6 F10 = 0xffc7 F11 = 0xffc8 F12 = 0xffc9 UP = 0xff52 DOWN = 0xff54 LEFT = 0xff51 RIGHT = 0xff53 ALT = 0xffe9 CTRL = 0xffe4 SHIFT = 0xffe1 BACKSPACE = 0xff08 TAB = 0xff09 ENTER = 0xff0d SYSRQ = 0xff15 DELETE = 0xffff INSERT = 0xff63 PAGE_UP = 0xff55 PAGE_DOWN = 0xff56 HOME = 0xff50 END = 0xff57 ESC = 0xff1b WIN = 0xffeb extratextbynode = {} focustext = '' async def do_power_action(action, setboot=None): targnodes = list(focused_nodes) if not targnodes: return for node in targnodes: extratextbynode[node] = 'Power action: ' redraw() try: paclient = client.Command() if setboot: noderange = ','.join(targnodes) async for res in paclient.update(f'/noderange/{noderange}/boot/nextdevice', {'nextdevice': setboot, 'mode': 'uefi'}): if 'error' in res: for node in targnodes: extratextbynode[node] += 'Failed to set boot device: {0}'.format(res['error']) return for node in res.get('databynode', {}): extratextbynode[node] += 'set boot device to: ' + res['databynode'][node].get('nextdevice', {}).get('value', 'Unknown') + ', ' noderange = ','.join(targnodes) async for res in paclient.update(f'/noderange/{noderange}/power/state', {'state': action}): if 'error' in res: for node in targnodes: extratextbynode[node] += 'Failed to power ' + action + ': {0}'.format(res['error']) return for node in res.get('databynode', {}): extratextbynode[node] += res['databynode'][node].get('state', {}).get('value', 'Unknown') finally: redraw() await asyncio.sleep(5) for node in targnodes: extratextbynode[node] = '' redraw() def set_extra_text(text): global focustext if focustext == text: return # noop focustext = text redraw() inhandler = None def clean_exit(): sys.stdout.write('\x1b[?1006l') # Disable SGR extended mode for mouse sys.stdout.write('\x1b[?1003l') # Disable mouse movement tracking sys.stdout.write('\x1b[?1000l') # Disable mouse click tracking sys.stdout.flush() if inhandler: # consume pending mouse actions rather than inflicting them on the prompt inhandler.drain_input() sys.exit(0) async def watch_input(): global focustext focustext = 'Hit Ctrl-E for command mode' global inhandler inhandler = await InputHandler.create() while not console_direct_mode: # wait for direct mode to activate before triggering mouse notifications await asyncio.sleep(0.1) sys.stdout.write('\x1b[?1000h') # Enable mouse click tracking sys.stdout.write('\x1b[?1003h') # Enable mouse movement tracking sys.stdout.write('\x1b[?1006h') # Enable SGR extended mode for mouse # 1016 isn't as ubiquitous as the other mouse tracking modes, see if 1006 is good enough for now # Notably, Konsole seems to bug out and revert to ambiguous mouse release with 1016 sys.stdout.flush() while True: await asyncio.sleep(5) if focustext == 'Hit Ctrl-E for command mode': focustext = '' redraw() class InputHandler: ss3keys = { 'P': SpecialKeys.F1, 'Q': SpecialKeys.F2, 'R': SpecialKeys.F3, 'S': SpecialKeys.F4, 'M': SpecialKeys.ENTER, } csikeys = { '[H': SpecialKeys.HOME, '[F': SpecialKeys.END, '[1;3': False, # Stub to detect alt-arrow '[2~': SpecialKeys.INSERT, '[3~': SpecialKeys.DELETE, '[5~': SpecialKeys.PAGE_UP, '[6~': SpecialKeys.PAGE_DOWN, '[11~': SpecialKeys.F1, '[12~': SpecialKeys.F2, '[13~': SpecialKeys.F3, '[14~': SpecialKeys.F4, '[15~': SpecialKeys.F5, '[17~': SpecialKeys.F6, '[18~': SpecialKeys.F7, '[19~': SpecialKeys.F8, '[20~': SpecialKeys.F9, '[21~': SpecialKeys.F10, '[23~': SpecialKeys.F11, '[24~': SpecialKeys.F12, '[A': SpecialKeys.UP, '[B': SpecialKeys.DOWN, '[C': SpecialKeys.RIGHT, '[D': SpecialKeys.LEFT } @classmethod async def create(cls): self = cls() self.buffer = '' self.modkeys = None self.inputcontext = None currloop = asyncio.get_running_loop() self.fd = sys.stdin.fileno() self.seqtimeout = None self.pendinginput = asyncio.Queue() self.inputconsumer = asyncio.create_task(self.consume_input()) currloop.add_reader(self.fd, self.handle_input) return self def handle_input(self): data = os.read(self.fd, 1) if not data: return self.pendinginput.put_nowait(data) def drain_input(self): asyncio.get_running_loop().remove_reader(self.fd) while select.select([self.fd], [], [], 0.5)[0]: os.read(self.fd, 1) async def consume_input(self): # One consumer, so a keystroke that blocks relaying cannot be overtaken # by the next one, and the sequence buffer is only touched by one task while True: data = await self.pendinginput.get() try: await self.process_input(data) except Exception as e: sys.stderr.write("Error processing input: " + str(e) + "\n") async def timeout_sequence(self, timeout=3, flushbuffer=False): await asyncio.sleep(timeout) if flushbuffer: if self.buffer == '\x05': await relay_keypresses('e', modifiers=[SpecialKeys.CTRL]) elif self.buffer == '\x1bO': await relay_keypresses('O', modifiers=[SpecialKeys.ALT, SpecialKeys.SHIFT]) else: await relay_keypresses(self.buffer) self.reset_input_context() def reset_input_context(self, escmode=False): self.inputcontext = None self.buffer = '' self.modkeys = None if not escmode: set_extra_text('') global focus_pending if focus_pending: focus_pending = False redraw() async def process_input(self, data): if self.inputcontext is None: # no escape or command sequence if data == b'\x05': # Ctrl-E set_extra_text('Ctrl-E pressed, release Ctrl and hit "c" to enter command mode, Ctrl-E again to send Ctrl-E') # clear any previous command sequence text if self.seqtimeout: self.seqtimeout.cancel() self.seqtimeout = asyncio.create_task(self.timeout_sequence(flushbuffer=True)) self.inputcontext = 'command_sequence' self.buffer = '\x05' return elif data == b'\x1b': # ESC if self.seqtimeout: self.seqtimeout.cancel() self.seqtimeout = asyncio.create_task(self.timeout_sequence(0.2, flushbuffer=True)) self.inputcontext = 'escape_sequence' self.buffer = '\x1b' return if data[0] == 0x7f: # Backspace await relay_keypresses(SpecialKeys.BACKSPACE) elif data[0] == 0x09: # Tab await relay_keypresses(SpecialKeys.TAB) elif data[0] == 0x0d: # Enter await relay_keypresses(SpecialKeys.ENTER) elif data[0] == 0: await relay_keypresses(' ', modifiers=[SpecialKeys.CTRL]) # Ctrl-Space) elif data[0] < 0x20: # other control characters, this is ambiguous, but assume letters await relay_keypresses(chr(data[0] + 0x60), modifiers=[SpecialKeys.CTRL]) else: await relay_keypresses(data.decode('utf-8', errors='ignore')) return elif self.inputcontext == 'escape_sequence': await self.handle_esc_sequence(data) elif self.inputcontext == 'command_sequence': await self.handle_command_sequence(data) valid_commands = ('\x05cb', # send sysrq '\x05cpo', # power off system '\x05cps', # shutdown system gracefully '\x05cpb\r', # reboot system '\x05cpbs', # boot system to setup '\x05cpbn', # boot system to network '\x05c.', # exit console '\x05cq', # exit console alias '\x05c?', # help '\x05cfa', # toggle focus all '\x05c\x1b[A', '\x05c\x1b[B', '\x05c\x1b[C', '\x05c\x1b[D', # move focus with arrow keys '\x05cf\x1b[A', '\x05cf\x1b[B', '\x05cf\x1b[C', '\x05cf\x1b[D', # move focus with arrow keys '\x05ck\x1b[3~', # Delete key ) def starts_valid_command(self): for cmd in self.valid_commands: if cmd.startswith(self.buffer): return True return False async def handle_command_sequence(self, data): if self.seqtimeout: self.seqtimeout.cancel() self.buffer += data.decode('utf-8', errors='ignore') if '\x1b' == self.buffer[-1:]: # user hit escape, or arrow key.. # give it a short timeout for arrows.. self.seqtimeout = asyncio.create_task(self.timeout_sequence(0.2)) return if '\x03' == self.buffer[-1:]: # Ctrl-C, abort command sequence immediately self.reset_input_context() return if self.buffer == '\x05\x05': # double ctrl-e, send a single ctrl-e to the console await relay_keypresses('e', modifiers=[SpecialKeys.CTRL]) self.reset_input_context() return if len(self.buffer) < 2: raise Exception('Command sequence buffer should have at least 2 characters') if not self.buffer.startswith('\x05c'): # not a command await relay_keypresses('e', modifiers=[SpecialKeys.CTRL]) await relay_keypresses(self.buffer[1:]) self.reset_input_context() if self.buffer == '\x05c': set_extra_text('Commands: q:exit, p:power, f:input focus, b:sysrq, k:keystroke, ^c:abort') self.seqtimeout = asyncio.create_task(self.timeout_sequence(10)) # extend timeout to navigate options return elif self.buffer == '\x05ck': set_extra_text('Keystrokes: : Ctrl-Alt-Delete, w: Win, 1: Ctrl-Alt-F1, 2: Ctrl-Alt-F2, 3: Ctrl-Alt-F3, 4: Ctrl-Alt-F4,') self.seqtimeout = asyncio.create_task(self.timeout_sequence(10)) # extend timeout to navigate options elif self.buffer == '\x05ck1': await relay_keypresses(SpecialKeys.F1, modifiers=[SpecialKeys.CTRL, SpecialKeys.ALT]) # Ctrl-Alt-F1 self.reset_input_context() elif self.buffer == '\x05ck2': await relay_keypresses(SpecialKeys.F2, modifiers=[SpecialKeys.CTRL, SpecialKeys.ALT]) # Ctrl-Alt-F2 self.reset_input_context() elif self.buffer == '\x05ck3': await relay_keypresses(SpecialKeys.F3, modifiers=[SpecialKeys.CTRL, SpecialKeys.ALT]) # Ctrl-Alt-F3 self.reset_input_context() elif self.buffer == '\x05ck4': await relay_keypresses(SpecialKeys.F4, modifiers=[SpecialKeys.CTRL, SpecialKeys.ALT]) # Ctrl-Alt-F4 self.reset_input_context() elif self.buffer == '\x05ck\x1b[3~': await relay_keypresses(SpecialKeys.DELETE, modifiers=[SpecialKeys.CTRL, SpecialKeys.ALT]) # Ctrl-Alt-Delete self.reset_input_context() elif self.buffer == '\x05ckw': await relay_keypresses(SpecialKeys.WIN) # Ctrl-Alt-Win self.reset_input_context() elif '\x05cb' == self.buffer: # send break # but we need to know more, so wait for the next key set_extra_text('Enter sysrq command key (or to abort)') self.seqtimeout = asyncio.create_task(self.timeout_sequence()) elif len(self.buffer) == 4 and self.buffer.startswith('\x05cb'): # Ctrl-E, then c, then b await relay_keypresses(self.buffer[3:], modifiers=[SpecialKeys.ALT, SpecialKeys.SYSRQ]) self.reset_input_context() elif self.buffer == '\x05c.' or self.buffer == '\x05cq': # Ctrl-E, then . or q set_extra_text('Exiting...') asyncio.get_running_loop().call_soon(clean_exit) return elif self.buffer == '\x05cf': # Ctrl-E, then c, then f set_extra_text('Focus commands: ⇅⇄:move focus, a:toggle focus all') self.seqtimeout = asyncio.create_task(self.timeout_sequence(10)) elif self.buffer == '\x05cfa': # toggle focus ... toggle_focus_all() self.reset_input_context() elif self.buffer == '\x05cp': set_extra_text('Power commands: o:power off, s:shutdown, b:boot') self.seqtimeout = asyncio.create_task(self.timeout_sequence(10)) elif self.buffer == '\x05cpb': set_extra_text('Boot options: : normal boot, s:boot to setup, n:boot to network, ^c to abort') self.seqtimeout = asyncio.create_task(self.timeout_sequence(10)) elif self.buffer == '\x05cpo': # Ctrl-E, then power off await do_power_action('off') return self.reset_input_context() elif self.buffer == '\x05cps': # Ctrl-E, then shutdown await do_power_action('shutdown') return self.reset_input_context() elif self.buffer == '\x05cpb\r': # Ctrl-E, then reboot await do_power_action('boot') return self.reset_input_context() elif self.buffer == '\x05cpbs': # Ctrl-E, then boot to setup await do_power_action('boot', 'setup') return self.reset_input_context() elif self.buffer == '\x05cpbn': # Ctrl-E, then boot to network await do_power_action('boot', 'network') return self.reset_input_context() elif self.buffer == '\x05c?': # Ctrl-E, then c? set_extra_text('q:exit,⇅⇄:focus,po:power off,ps:shutdown,pb:reboot,pbs:boot setup,pbn:boot network,fa:(un)focus all,bX:sysrq, then X') self.buffer = '\x05c' # go back to let the user enter stuff based on text self.seqtimeout = asyncio.create_task(self.timeout_sequence(10)) return elif self.buffer[-3:] in ('\x1b[A', '\x1b[B', '\x1b[C', '\x1b[D'): # Ctrl-E, then cursor keys arrowkey_map = {'A': 'Up', 'B': 'Down', 'C': 'Right', 'D': 'Left'} arrowkey = arrowkey_map.get(self.buffer[-1], self.buffer[-1]) global focus_pending focus_pending = True move_focus(arrowkey) self.buffer = '\x05c' self.seqtimeout = asyncio.create_task(self.timeout_sequence()) elif self.starts_valid_command(): self.seqtimeout = asyncio.create_task(self.timeout_sequence()) elif len(self.buffer) > 2: # unknown command sequence, abort self.reset_input_context() async def handle_esc_sequence(self, data): global current_cursor, expecting_cpr if self.seqtimeout: self.seqtimeout.cancel() self.buffer += data.decode('utf-8', errors='ignore') # Shift-enter if len(self.buffer) >= 2 and self.buffer.startswith('\x1b['): #CSI if self.buffer.endswith(';3~'): self.buffer = self.buffer.replace(';3~', '~') self.modkeys = [SpecialKeys.ALT] if '1;3' in self.buffer: self.buffer = self.buffer.replace('1;3', '') self.modkeys = [SpecialKeys.ALT] if self.buffer[1:] in self.csikeys: await relay_keypresses(self.csikeys[self.buffer[1:]], modifiers=self.modkeys) self.reset_input_context(escmode=True) return if self.buffer[1:] == '[Z': # Backtab (Shift+Tab) await relay_keypresses(SpecialKeys.TAB, modifiers=[SpecialKeys.SHIFT]) self.reset_input_context(escmode=True) return if expecting_cpr: # dsr is '\x1b[;R' if self.buffer.endswith('R'): expecting_cpr = False try: _, pos = self.buffer.split('[', 1) row, col = pos[:-1].split(';') current_cursor = (int(col), int(row)) except ValueError: pass self.reset_input_context(escmode=True) return cprdata = self.buffer[2:] if (cprdata.count(';') <= 1 and all(char == ';' or '0' <= char <= '9' for char in cprdata)): # This may be a partial cursor-position response. self.seqtimeout = asyncio.create_task(self.timeout_sequence(0.2)) return self.reset_input_context(escmode=True) return if self.buffer.startswith('\x1b[<'): # Mouse event sequence if self.buffer.endswith('M') or self.buffer.endswith('m'): if self.buffer.endswith('M'): event_type = 'press' else: event_type = 'release' seqdata = self.buffer[3:-1] # Strip the '\x1b[<' prefix and the trailing 'M' or 'm' try: evt, col, row = seqdata.split(';') except ValueError: self.reset_input_context(escmode=True) # ignore malformed sequence, konsole sometimes tosses # a weird stray with two values return evt = int(evt) col = int(col) row = int(row) button = evt & 3 if evt & 64: # move button to 4, 5 for scroll up/down button += 4 if button == 3: button = None # button is not pressed else: button += 1 movement = evt & 32 modifiers = [] if evt & 16: modifiers.append(SpecialKeys.CTRL) if evt & 4: modifiers.append(SpecialKeys.SHIFT) if evt & 8: modifiers.append(SpecialKeys.ALT) # Mouse coordinates are one-based; tile positions are # zero-based, and the first tile row is its title bar. toprow = current_cursor[1] for node, (tilecol, tilerow) in nodepositions.items(): x = col - tilecol - 1 y = row - tilerow - 1 - toprow if 0 <= x < cwidth and 0 <= y < cheight - 1: geometry = imagegeometrybynode.get(node) if geometry: canvaswidth, canvasheight, imagewidth, imageheight, cellwidth, cellheight = geometry # aim for the middle of the cell with 0.5, converting for actual image x = ((x + 0.5) * canvaswidth / cellwidth - 2) / imagewidth y = ((y + 0.5) * canvasheight / cellheight - 2) / imageheight x = min(1, max(0, x)) y = min(1, max(0, y)) else: x = x / cwidth y = y / (cheight - 1) if node not in focused_nodes: if button == 1: if SpecialKeys.CTRL not in modifiers: focused_nodes.clear() focused_nodes[node] = True redraw() break for node in focused_nodes: vnclient = vncclientsbynode.get(node) if vnclient: await vnclient.send_pointer_event(button, x, y, event_type, modifierkeys=modifiers) break elif 0 <= x < cwidth and y == -1: if node in focused_nodes: if button == 1 and event_type == 'release': if SpecialKeys.CTRL in modifiers: focused_nodes.pop(node, None) else: focused_nodes.clear() focused_nodes[node] = True redraw() else: if button == 1 and event_type == 'release': if SpecialKeys.CTRL not in modifiers: focused_nodes.clear() focused_nodes[node] = True redraw() break else: if button == 1: focused_nodes.clear() redraw() self.reset_input_context(escmode=True) return self.seqtimeout = asyncio.create_task(self.timeout_sequence(0.2)) else: for cand in self.csikeys: if cand.startswith(self.buffer[1:]): # continue to wait for more input to disambiguate self.seqtimeout = asyncio.create_task(self.timeout_sequence(0.2)) break else: self.reset_input_context(escmode=True) elif len(self.buffer) >= 2 and self.buffer.startswith('\x1bO'): #SS3 if len(self.buffer) == 3: if self.buffer[2:] in self.ss3keys: await relay_keypresses(self.ss3keys[self.buffer[2:]]) self.reset_input_context(escmode=True) return if len(self.buffer) == 2: self.seqtimeout = asyncio.create_task(self.timeout_sequence(0.2)) return elif len(self.buffer) >= 2: # ESC-key is a way to do alt await relay_keypresses(self.buffer[1:], modifiers=[SpecialKeys.ALT]) self.reset_input_context(escmode=True) vncclientsbynode = {} async def timeout_cpr(): global expecting_cpr await asyncio.sleep(0.5) expecting_cpr = False coordtimeouttask = None def get_coords(): global current_cursor global expecting_cpr global coordtimeouttask direct_console() current_cursor = (1, 1) sys.stdout.write('\x1b[6n') # sys.stdout.flush() coordtimeouttask = asyncio.create_task(timeout_cpr()) expecting_cpr = True #sys.stdout.write('\x1b[{}:{}H'.format(*coords)) console_direct_mode = False def direct_console(): global console_direct_mode global oldtcattr global oldfl if console_direct_mode: return False if not sys.stdin.isatty(): # Nothing to put in raw mode, which is fine for output only usage such # as reporting an error from a screenshot request return False console_direct_mode = True oldtcattr = termios.tcgetattr(sys.stdin.fileno()) oldfl = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL) tty.setraw(sys.stdin.fileno()) #fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, oldfl | os.O_NONBLOCK) return True def indirect_console(): global console_direct_mode global oldtcattr global oldfl if not console_direct_mode: return False console_direct_mode = False #fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, oldfl & ~os.O_NONBLOCK) termios.tcsetattr(sys.stdin.fileno(), termios.TCSANOW, oldtcattr) return True def determine_tile_size(numnodes): # for now, smash everything to a common aspect ratio. 16:11 # is pretty much wrong for everything, making 4:3 a bit too wide # and 16:9 significantly too narrow, but it is serviceable # An improvement could come with us owning the scaling # instead of delegating to Kitty, which says if we specify both, # we get stretching. In theory we should be able to get aspect correct # from kitty by omitting, but: # then we don't know how much to move the cursor left after draw_image # Konsole won't scale at all with only partial scaling specified directed = direct_console() cheight, cwidth, pixwidth, pixheight = sq.get_screengeom(escfallback=True) if directed: indirect_console() # 16:12 is to roughly account for the 'titles' of the tiles ratio = (pixwidth / 16) / (pixheight / 12) bestdeviation = None bestdims = [] for i in range(1, numnodes + 1): number = numnodes while number % i != 0: number += 1 columns = i rows = number // i deviation = abs(ratio - (columns / rows)) if bestdeviation is None: bestdeviation = deviation bestdims = [columns, rows] elif deviation < bestdeviation: bestdeviation = deviation bestdims = [columns, rows] # ok, the above algorithm can still pick things like # 1 2 3 # 4 # So we will let it pick the number of rows, and # then see if we can chop columns and still fit while (bestdims[0] - 1) * bestdims[1] >= numnodes: bestdims[0] = bestdims[0] - 1 cellswide = cwidth // bestdims[0] cellshigh = cheight // bestdims[1] tilewidth = cellswide * pixwidth / cwidth tileheight = cellshigh * pixheight / cheight if tilewidth > (tileheight * 16 / 11): tilewidth = tileheight * 16 / 11 cellswide = int(tilewidth // (pixwidth / cwidth)) if tileheight > (tilewidth * 11 /16): tileheight = tilewidth * 11 / 16 cellshigh = int(tileheight // (pixheight / cheight)) bestdims = bestdims + [cellswide, cellshigh, cellshigh * bestdims[1]] # incur any scrolling we might get. This allows us to accurately # save/restore cursor or even get coordinates without scrolling fouling # the desired target sys.stdout.write('\n' * bestdims[4]) sys.stdout.flush() cursor_up(bestdims[4]) return bestdims cursor_saved = False def sticky_cursor(): global cursor_saved # get cursor restore_position directed = False if sys.stdin.isatty() and not cursor_saved: try: directed = direct_console() sys.stdout.write('\x1b7') cursor_saved = True finally: if directed: indirect_console() elif cursor_saved: try: directed = direct_console() sys.stdout.write('\x1b8') finally: if directed: indirect_console() def cursor_up(count=1): sys.stdout.write(f'\x1b[{count}A') def cursor_down(count=1): sys.stdout.write(f'\x1b[{count}B') def cursor_right(count=1): sys.stdout.write(f'\x1b[{count}C') def cursor_left(count=1): sys.stdout.write(f'\x1b[{count}D') def cursor_save(): sys.stdout.write('\x1b7') def cursor_restore(): sys.stdout.write('\x1b8') def cursor_hide(): sys.stdout.write('\x1b[?25l') def cursor_show(): sys.stdout.write('\x1b[?25h') def get_pix_dimensions(width, height): directed = direct_console() cheight, cwidth, pixwidth, pixheight = sq.get_screengeom(escfallback=True) if directed: indirect_console() imgwidth = int(pixwidth / cwidth * width) imgheight = int(pixheight / cheight * height) return imgwidth, imgheight def draw_text(text, width, height): if Image: maxfntsize = 256 imgwidth, imgheight = get_pix_dimensions(width, height) nerr = Image.new(mode='RGB', size=(imgwidth, imgheight), color='green') nd = ImageDraw.Draw(nerr) for txtpiece in text.split('\n'): fntsize = 8 scalefont = True try: txtfont = ImageFont.truetype('DejaVuSans.ttf', size=fntsize) except OSError: scalefont = False txtfont = ImageFont.load_default(fntsize) while scalefont and nd.textlength(txtpiece, font=txtfont) < int(imgwidth * 0.90): fntsize += 1 try: txtfont = ImageFont.truetype('DejaVuSans.ttf', size=fntsize) except OSError: txtfont = ImageFont.load_default(fntsize) fntsize -= 1 if fntsize < maxfntsize: maxfntsize = fntsize hmargin = int(imgwidth * 0.05) vmargin = int(imgheight * 0.10) nd.text((hmargin, vmargin), text, font=txtfont) nd.rectangle((0, 0, nerr.width - 1, nerr.height -1), outline='white') outfile = io.BytesIO() nerr.save(outfile, format='PNG') draw_image(outfile.getvalue(), width, height, doscale=False) else: sys.stdout.write(text) cursor_left(len(text)) def draw_image(bindata, width, height, doscale=True, node=None): if not bindata: return imageformat = os.environ.get('CONFLUENT_IMAGE_PROTOCOL', 'kitty') if doscale and Image and width: binfile = io.BytesIO() binfile.write(bindata) binfile.seek(0) try: img = Image.open(binfile) except Exception as e: errstr = 'Error rendering image:\n' + str(e) return draw_text(errstr, width, height) canvaswidth, canvasheight = get_pix_dimensions(width, height) imgwidth, imgheight = canvaswidth, canvasheight nimg = Image.new(mode='RGBA', size=(canvaswidth, canvasheight)) imgwidth -= 4 imgheight -= 4 hscalefact = imgwidth / img.width vscalefact = imgheight / img.height if hscalefact < vscalefact: rzwidth = imgwidth rzheight = int(img.height * hscalefact) else: rzwidth = int(img.width * vscalefact) rzheight = imgheight if node is not None: imagegeometrybynode[node] = (canvaswidth, canvasheight, rzwidth, rzheight, width, height) img = img.resize((rzwidth, rzheight)) nd = ImageDraw.Draw(nimg) nd.rectangle((1, 1, rzwidth + 2, rzheight + 2), outline='black') nd.rectangle((0, 0, rzwidth + 3, rzheight + 3), outline='white') nimg.paste(img, box=(2, 2)) outfile = io.BytesIO() nimg.save(outfile, format='PNG') bindata = outfile.getvalue() if imageformat == 'sixel': sixel_draw(bindata) elif imageformat == 'iterm': iterm_draw(bindata, width, height) else: kitty_draw(bindata, width, height) def sixel_draw(bindata): binfile = io.BytesIO() binfile.write(bindata) binfile.seek(0) DumbWriter().draw(binfile) def iterm_draw(bindata, width, height): data = base64.b64encode(bindata) if not height: height = 'auto' if not width: width = 'auto' datalen = len(bindata) sys.stdout.write( '\x1b]1337;File=inline=1;width={};height={};size={}:'.format(width,height,datalen)) sys.stdout.write(data.decode('utf8')) sys.stdout.write('\a') sys.stdout.flush() def kitty_draw(bindata, width, height): data = base64.b64encode(bindata) preamble = '\x1b_Ga=T,f=100,z=-1,q=2' if height: preamble += f',r={height},c={width}' #sys.stdout.write(repr(preamble)) #sys.stdout.write('\xb[{}D'.format(len(repr(preamble)))) #return first = True while data: chunk, data = data[:4096], data[4096:] m = 1 if data else 0 if first: sys.stdout.write('{},m={};'.format(preamble, m)) else: sys.stdout.write('\x1b_Gm={};'.format(m)) sys.stdout.write(chunk.decode('utf8')) sys.stdout.write('\x1b\\') sys.stdout.flush() pass_through_args = [] killcon = False try: noderange = args[0] if len(args) > 1: if args[1] == 'kill': killcon = True pass_through_args = args[1:] args = args[:1] except IndexError: argparser.print_help() sys.exit(1) if len(args) != 1: argparser.print_help() sys.exit(1) if options.log: logname = args[0] if not os.path.exists(logname) and logname[0] != '/': logname = os.path.join('/var/log/confluent/consoles', logname) if not os.path.exists(logname): sys.stderr.write('Unable to locate {0} on local system\n'.format(logname)) sys.exit(1) logreader.replay_to_console(logname) sys.exit(0) if options.Timestamp: logname = args[0] if not os.path.exists(logname) and logname[0] != '/': logname = os.path.join('/var/log/confluent/consoles', logname) if not os.path.exists(logname): sys.stderr.write('Unable to locate {0} on local system\n'.format(logname)) sys.exit(1) logreader.dump_to_console(logname) sys.exit(0) def prep_node_tile(node): currcolcell, currrowcell = nodepositions[node] if currcolcell: cursor_right(currcolcell) if currrowcell: cursor_down(currrowcell) titletext = node if extratextbynode.get(node, None): titletext += ' ' + extratextbynode[node] if node in focused_nodes: if focustext and not extratextbynode.get(node, None): titletext += ' ' + focustext if focus_pending: sys.stdout.write('\x1b[43m') else: sys.stdout.write('\x1b[44m') titlebar = f'▏{titletext:<{cwidth - 1}}' if len(titlebar) > cwidth: titlebar = titlebar[:cwidth - 1] + '…' sys.stdout.write(titlebar) if node in focused_nodes: sys.stdout.write('\x1b[0m') cursor_left(len(titlebar)) cursor_down() def reset_cursor(node): currcolcell, currrowcell = nodepositions[node] if currcolcell: cursor_left(currcolcell) cursor_up(currrowcell + 1) nodepositions = {} numrows = 0 cwidth = 0 cheight = 0 imagedatabynode = {} imagegeometrybynode = {} firstnodename = None # Terminal drawing is offloaded to a single worker thread so slow image # encoding/output doesn't stall the asyncio loop. The lock keeps the worker # from interleaving output with redraw() on the main thread. draw_lock = threading.Lock() draw_queue = queue.Queue() def redraw(): with draw_lock: for node in imagedatabynode: imgdata = imagedatabynode[node] if node in nodepositions: prep_node_tile(node) cursor_save() else: if options.interval is not None: if node != firstnodename: sys.stderr.write('Multiple nodes not supported for interval') sys.exit(1) sticky_cursor() sys.stdout.write('{}: '.format(node)) # one row is used by our own name, so cheight - 1 for that allowance draw_image(imgdata, cwidth, cheight - 1 if cheight else cheight, node=node) if node in nodepositions: cursor_restore() reset_cursor(node) else: sys.stdout.write('\n') sys.stdout.flush() inputwatcher = None def do_resize(nodelist, winch=False): global current_cursor if winch: # on a window resize, clear the old stuff current_cursor = (1, 1) sys.stdout.write('\x1bc') if console_direct_mode: sys.stdout.write('\x1b[?1000h') # Enable mouse click tracking sys.stdout.write('\x1b[?1003h') # Enable mouse movement tracking sys.stdout.write('\x1b[?1006h') # Enable SGR extended mode for mouse global numrows global cwidth global cheight cols, rows, cwidth, cheight, numrows = determine_tile_size(len(nodelist)) if streaming and not winch: get_coords() currcol = 1 currcolcell = 0 currrowcell = 0 for node in nodelist: nodepositions[node] = currcolcell, currrowcell if streaming: init_focus(node) if currcol < cols: currcol += 1 currcolcell += cwidth else: currcol = 1 currcolcell = 0 currrowcell += cheight async def do_screenshot(): global streaming global numrows global firstnodename global inputwatcher sess = client.Command() if streaming: direct_console() inputwatcher = asyncio.create_task(watch_input()) if options.tile: imageformat = os.environ.get('CONFLUENT_IMAGE_PROTOCOL', 'kitty') if imageformat not in ('kitty', 'iterm'): sys.stderr.write('Tiled screenshots only supported with kitty or iterm protocol') sys.exit(1) allnodes = [] numnodes = 0 async for res in sess.read('/noderange/{}/nodes/'.format(args[0])): allnodes.append(res['item']['href'].replace('/', '')) numnodes += 1 def handle_resize(signum, sigframe): if signum is not None: draw_queue.put_nowait(ResizeEvent(allnodes)) do_resize(allnodes) signal.signal(signal.SIGWINCH, handle_resize) elif options.interval is not None: sys.stdout.write('\x1bc') firstnodename = None dorefresh = True vnconly = set([]) if streaming: doexit = 0 async for res in sess.read('/noderange/{}/console/ikvm_methods'.format(args[0])): for node in res.get('databynode', {}): methods = res['databynode'][node].get('ikvm_methods', []) if 'vnc' not in methods and 'openbmc' not in methods: sys.stderr.write(f'Node {node} does not support video via confluent\n') doexit = 1 vnconly.add(node) if doexit: sys.exit(1) while dorefresh: if not streaming: async for res in sess.read('/noderange/{}/console/ikvm_screenshot'.format(args[0])): for node in res.get('databynode', {}): errorstr = '' if not firstnodename: firstnodename = node error = res['databynode'][node].get('error') if error and 'vnc available' in error: vnconly.add(node) continue elif error: errorstr = error imgdata = res['databynode'][node].get('image', {}).get('imgdata', None) if imgdata: if len(imgdata) < 32: # We were subjected to error errorstr = 'Unable to get screenshot' if errorstr or imgdata: # A node may report an error with no image at all, and # there is nothing to decode in that case imgdata = base64.b64decode(imgdata) if imgdata else None draw_node(node, imgdata, errorstr, firstnodename, cwidth, cheight) urlbynode = {} for node in vnconly: async for res in sess.update(f'/nodes/{node}/console/ikvm', {'method': 'unix'}): url = res.get('item', {}).get('href') if url: urlbynode[node] = url await grab_vncs(urlbynode) if options.interval is None: dorefresh = False else: dorefresh = True await asyncio.sleep(options.interval) sys.exit(0) async def grab_vncs(urlbynode): global streaming tasks = [] directed = False try: if streaming: directed = direct_console() outputbynode = {} if options.outputfile: expr = options.outputfile if '{' in expr: # Let the server evaluate the expression to a unique name per node sess = client.Command() noderange = ','.join(urlbynode) async for res in sess.create( '/noderange/{}/attributes/expression'.format(noderange), {'expression': expr}): for node in res.get('databynode', {}): outputbynode[node] = res['databynode'][node]['value'] else: for node in urlbynode: if len(urlbynode) > 1: base, ext = os.path.splitext(options.outputfile) outputbynode[node] = '{}-{}{}'.format(base, node, ext) else: outputbynode[node] = expr for node in urlbynode: url = urlbynode[node] tasks.append(asyncio.create_task( do_vnc(node, url, outputbynode.get(node)))) await asyncio.gather(*tasks) except Exception as e: sys.stderr.write(f"Error in grab_vncs: {e}\n") finally: if directed: indirect_console() conserversequence = '\05c' async def relay_keypresses(keys, modifiers=None): if focus_pending: return if hasattr(keys, 'value'): keys = [keys] if isinstance(keys, str): keys = list(bytearray(keys.encode('utf-8'))) shifted = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ~!@#$%^&*()_+{}|:"<>?' for i in range(len(keys)): if not isinstance(keys[i], int): continue if chr(keys[i]) in shifted: if modifiers: modifiers.append(SpecialKeys.SHIFT) else: modifiers = [SpecialKeys.SHIFT] if keys[0] == 0x1b: keys[0] = SpecialKeys.ESC for node in focused_nodes: vnclient = vncclientsbynode.get(node) if not vnclient: #sys.stderr.write(f"No VNC client for node {node}, unable to relay keypress\n") continue try: await vnclient.send_keypresses(keys, modifiers) except Exception as e: sys.stderr.write(f"Error relaying keypress to VNC client: {e}\n") continue single_focus_node = None focused_nodes = {} def init_focus(node): global single_focus_node if not focused_nodes: focused_nodes[node] = True single_focus_node = node focus_pending = False def move_focus(direction): global single_focus_node # Implement the logic to move focus in the specified direction currcolcell, currrowcell = nodepositions[single_focus_node] if direction == 'Up': target = (currcolcell, currrowcell - cheight) elif direction == 'Down': target = (currcolcell, currrowcell + cheight) elif direction == 'Left': target = (currcolcell - cwidth, currrowcell) elif direction == 'Right': target = (currcolcell + cwidth, currrowcell) else: sys.stderr.write("Invalid direction for focus movement: {}\n".format(direction)) return for node, pos in nodepositions.items(): if pos == target: focused_nodes.clear() focused_nodes[node] = True single_focus_node = node redraw() return def toggle_focus_all(): # Implement the logic to toggle focus all if len(focused_nodes) < 2: for node in nodepositions: focused_nodes[node] = True return for node in list(focused_nodes): if node == single_focus_node: continue del focused_nodes[node] async def do_vnc(node, url, outputfile=None): global streaming keeprunning = True retries = 5 if os.path.abspath(url) and 'ssh://' in os.environ.get('CONFLUENT_HOST', ''): if not os.path.exists(url): localpath = os.path.join(os.environ['XDG_RUNTIME_DIR'], 'confluent', 'vinz', os.path.basename(url)) os.makedirs(os.path.dirname(localpath), exist_ok=True, mode=0o700) if os.path.exists(localpath): try: rdr, writer = await asyncio.open_unix_connection(localpath) writer.close() except Exception: os.unlink(localpath) if not os.path.exists(localpath): sshhost = os.environ.get('CONFLUENT_HOST')[6:].split('/', 1)[0] # would do '-fNT' like elsewhere, but the video tunnel exiting on close # is nice, since we end up with another port forward for each node sshproc = await asyncio.create_subprocess_exec( 'ssh', '-fT', '-o', 'StreamLocalBindUnlink=yes', '-L', localpath + ':' + url, sshhost, 'sleep', '30', stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.DEVNULL) await sshproc.wait() url = localpath while keeprunning: try: async with await vnc.VNCClient.create(url, outputfile=outputfile) as client: vncclientsbynode[node] = client while True: # Retrieve pixels as a 3D numpy array while not draw_queue.empty(): await asyncio.sleep(0.05) try: # replace the stock screenshot function with our own # ask for a video refresh, then do reads until the video is complete # stock screenshot function discards data, # or we just patch the screenshot instead.... image = await client.get_screenshot() except asyncio.TimeoutError: # need a better closed connection detector, a static screen triggers timeouts too # without the timeout, we lose track of proxmox reset # with the timeout, we falsely assume dead on stale break except vnc.VNCReceiverTerminated: # The VNC receiver task has terminated unexpectedly draw_node(node, None, 'Video not connected', '', cwidth, cheight) break retries = 5 # Save as PNG using PIL/pillow outfile = io.BytesIO() image.save(outfile, format='PNG') imgdata = outfile.getvalue() if imgdata: draw_node(node, imgdata, '', '', cwidth, cheight) else: keeprunning = False break if not streaming: keeprunning = False break except Exception as e: draw_node(node, None, str(e), '', cwidth, cheight) if not streaming: retries -= 1 if retries <= 0: keeprunning = False #sys.stderr.write(f'VNC connection for node {node} failed with error: {e}\n') await asyncio.sleep(1) def draw_node(node, imgdata, errorstr, firstnodename, cwidth, cheight): # Queue the frame for the drawing thread; frames arriving mid-draw wait here draw_queue.put((node, imgdata, errorstr, firstnodename, cwidth, cheight)) class ResizeEvent: def __init__(self, nodelist): self.nodelist = nodelist def _draw_worker(): itemsbynode = {} while True: itemsbynode.clear() queuedresize = None item = draw_queue.get() if isinstance(item, ResizeEvent): queuedresize = item elif item is None: break elif item[0] not in itemsbynode: itemsbynode[item[0]] = item while not draw_queue.empty(): item = draw_queue.get() if isinstance(item, ResizeEvent): queuedresize = item elif item is None: break elif item[0] not in itemsbynode: itemsbynode[item[0]] = item if item is None: break if queuedresize: do_resize(queuedresize.nodelist, winch=True) redraw() # skip rendering frames with stale geometry continue for item in itemsbynode.values(): node, imgdata, errorstr, firstnodename, cwidth, cheight = item with draw_lock: _draw_node(node, imgdata, errorstr, firstnodename, cwidth, cheight) def _draw_node(node, imgdata, errorstr, firstnodename, cwidth, cheight): oldimgdata = imagedatabynode.get(node) if oldimgdata == imgdata: # skip redundant screen update return imagedatabynode[node] = imgdata if node in nodepositions: prep_node_tile(node) cursor_save() else: if options.interval is not None: if node != firstnodename: sys.stderr.write('Multiple nodes not supported for interval') sys.exit(1) sticky_cursor() sys.stdout.write('{}: '.format(node)) # one row is used by our own name, so cheight - 1 for that allowance if errorstr: draw_text(errorstr, cwidth, cheight -1 if cheight else cheight) else: draw_image(imgdata, cwidth, cheight - 1 if cheight else cheight, node=node) if node in nodepositions: cursor_restore() reset_cursor(node) else: sys.stdout.write('\n') sys.stdout.flush() draw_thread = threading.Thread(target=_draw_worker, daemon=True) draw_thread.start() def close_draw_thread(): global draw_thread if not draw_thread: return mythread = draw_thread draw_thread = None if mythread.is_alive(): draw_queue.put(None) mythread.join(15) atexit.register(close_draw_thread) if options.screenshot or options.video: if not sys.stdout.isatty(): sys.stderr.write( 'Screenshot and video rendering need a terminal to draw in\n') sys.exit(1) streaming = options.video try: cursor_hide() asyncio.run(do_screenshot()) except KeyboardInterrupt: pass finally: cursor_show() cursor_down(numrows) sys.stdout.write('\n') sys.exit(0) async def kill(noderange): sess = client.Command() envstring=os.environ.get('NODECONSOLE_WINDOWED_COMMAND') if not envstring: envstring = 'xterm' nodes = [] async for res in sess.read('/noderange/{0}/nodes/'.format(noderange)): node = res.get('item', {}).get('href', '/').replace('/', '') if not node: sys.stderr.write(res.get('error', repr(res)) + '\n') sys.exit(1) nodes.append(node) for node in nodes: command = "ps auxww | grep {0} | grep console | egrep '\\b{1}\\b' | grep -v grep | awk '{{print $2}}'".format(envstring, node) process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = process.communicate() try: process_id = stdout.decode('utf-8').split()[0] except IndexError: sys.stderr.write(node + ": console window not found \n") continue subprocess.Popen(["kill", process_id], stdout=subprocess.PIPE, stderr=subprocess.PIPE) sys.exit(0) def handle_geometry(envlist, sizegeometry, side_pad=0, top_pad=0, first=False): if '-geometry' in envlist: g_index = envlist.index('-geometry') elif '-g' in envlist: g_index = envlist.index('-g') else: g_index = 0 if g_index: if first: envlist[g_index+1] = '{0}+{1}+{2}'.format(envlist[g_index+1],side_pad, top_pad) else: envlist[g_index+1] = '{0}+{1}+{2}'.format(sizegeometry,side_pad, top_pad) else: envlist.insert(1, '-geometry') envlist.insert(2, '{0}+{1}+{2}'.format(sizegeometry,side_pad, top_pad)) g_index = 1 return envlist # add funcltionality to close/kill all open consoles if killcon: asyncio.run(kill(noderange)) #added functionality for wcons if options.windowed: result=subprocess.Popen(['xwininfo', '-root'], stdout=subprocess.PIPE) rootinfo=result.communicate()[0] result.wait() for line in rootinfo.decode('utf-8').split('\n'): if 'Width' in line: screenwidth = int(line.split(':')[1]) if 'Height' in line: screenheight = int(line.split(':')[1]) envstring=os.environ.get('NODECONSOLE_WINDOWED_COMMAND') if not envstring: sizegeometry='100x31' corrected_x, corrected_y = (13,84) envlist = handle_geometry(['xterm'] + pass_through_args + ['-e'],sizegeometry, first=True) #envlist=['xterm', '-bg', 'black', '-fg', 'white', '-geometry', '{sizegeometry}+0+0'.format(sizegeometry=sizegeometry), '-e'] else: envlist=os.environ.get('NODECONSOLE_WINDOWED_COMMAND').split(' ') if envlist[0] == 'xterm': if '-geometry' in envlist: g_index = envlist.index('-geometry') elif '-g' in envlist: g_index = envlist.index('-g') else: g_index = 0 if g_index: envlist[g_index+1] = envlist[g_index+1] + '+0+0' else: envlist.insert(1, '-geometry') envlist.insert(2, '100x31+0+0') g_index = 1 nodes = [] sess = synclient.Command() for res in sess.read('/noderange/{0}/nodes/'.format(args[0])): node = res.get('item', {}).get('href', '/').replace('/', '') if not node: sys.stderr.write(res.get('error', repr(res)) + '\n') sys.exit(1) nodes.append(node) if options.tile and not envlist[0] == 'xterm': sys.stderr.write('[ERROR] UNSUPPORTED OPTIONS. \nWindowed and tiled consoles are only supported when using xterm \n') sys.exit(1) firstnode=nodes[0] nodes.pop(0) with open(os.devnull, 'wb') as devnull: xopen=subprocess.Popen(envlist + [confettypath, '-c', '/tmp/controlpath-{0}'.format(firstnode)] + automation_args + ['-m', '5', 'start', '/nodes/{0}/console/session'.format(firstnode)] , stdin=devnull) time.sleep(2) s=socket.socket(socket.AF_UNIX) winid='' try: s.connect('/tmp/controlpath-{firstnode}'.format(firstnode=firstnode)) s.recv(64) s.send(b'GETWINID') winid=s.recv(64).decode('utf-8') except: time.sleep(2) # try to get id of first panel/xterm window using name win=subprocess.Popen(['xwininfo', '-tree', '-root'], stdout=subprocess.PIPE) wintr=win.communicate()[0] for line in wintr.decode('utf-8').split('\n'): if 'console: {firstnode}'.format(firstnode=firstnode) in line or 'confetty' in line: win_obj = [ele for ele in line.split(' ') if ele.strip()] winid = win_obj[0] if winid: firstnode_window=subprocess.Popen(['xwininfo', '-id', '{winid}'.format(winid=winid)], stdout=subprocess.PIPE) xinfo=firstnode_window.communicate()[0] xinfl = xinfo.decode('utf-8').split('\n') for line in xinfl: if 'Absolute upper-left X:' in line: side_pad = int(line.split(':')[1]) elif 'Absolute upper-left Y:' in line: top_pad = int(line.split(':')[1]) elif 'Width:' in line: window_width = int(line.split(':')[1]) elif 'Height' in line: window_height = int(line.split(':')[1]) elif '-geometry' in line: l = re.split(' |x|-|\\+', line) l_nosp = [ele for ele in l if ele.strip()] wmxo = int(l_nosp[1]) wmyo = int(l_nosp[2]) sizegeometry = str(wmxo) + 'x' + str(wmyo) else: pass window_width += side_pad*2 window_height += side_pad+top_pad screenwidth -= wmxo screenheight -= wmyo currx = window_width curry = 0 for node in sortutil.natural_sort(nodes): if options.tile and envlist[0] == 'xterm': corrected_x = currx corrected_y = curry xgeometry = '{0}+{1}+{2}'.format(sizegeometry, corrected_x, corrected_y) currx += window_width if currx + window_width >= screenwidth: currx=0 curry += window_height if curry > screenheight: curry =top_pad if not envstring: envlist= handle_geometry(envlist, sizegeometry, corrected_x, corrected_y) else: if g_index: envlist[g_index+1] = xgeometry elif envlist[0] == 'xterm': envlist=handle_geometry(envlist, sizegeometry, side_pad, top_pad) side_pad+=(side_pad+1) top_pad+=(top_pad+30) else: pass with open(os.devnull, 'wb') as devnull: xopen=subprocess.Popen(envlist + [confettypath, '-c', '/tmp/controlpath-{0}'.format(node)] + automation_args + ['-m', '5', 'start', '/nodes/{0}/console/session'.format(node)] , stdin=devnull) sys.exit(0) #end of wcons if options.tile: null = open('/dev/null', 'w') nodes = [] sess = synclient.Command() for res in sess.read('/noderange/{0}/nodes/'.format(args[0])): node = res.get('item', {}).get('href', '/').replace('/', '') if not node: sys.stderr.write(res.get('error', repr(res)) + '\n') sys.exit(1) nodes.append(node) initial = True in_tmux = False pane = 0 sessname = 'nodeconsole_{0}'.format(os.getpid()) if os.environ.get("TMUX"): initial = False in_tmux = True subprocess.call(['tmux', 'rename-session', sessname]) for node in sortutil.natural_sort(nodes): panename = '{0}:{1}'.format(sessname, pane) if initial: initial = False confetty_cmd = [confettypath] + automation_args + ['-m', '5', 'start', '/nodes/{0}/console/session'.format(node)] subprocess.call( ['tmux', 'new-session', '-d', '-s', sessname, '-x', '800', '-y', '800', ' '.join(shlex.quote(arg) for arg in confetty_cmd)]) else: subprocess.call(['tmux', 'select-pane', '-t', sessname]) subprocess.call(['tmux', 'set-option', '-t', panename, 'pane-border-status', 'top'], stderr=null) confetty_cmd = [confettypath] + automation_args + ['-m', '5', 'start', '/nodes/{0}/console/session'.format(node)] subprocess.call( ['tmux', 'split', '-h', '-t', sessname, ' '.join(shlex.quote(arg) for arg in confetty_cmd)]) subprocess.call(['tmux', 'select-layout', '-t', sessname, 'tiled'], stdout=null) pane += 1 subprocess.call(['tmux', 'select-pane', '-t', sessname]) subprocess.call(['tmux', 'set-option', '-t', panename, 'pane-border-status', 'top'], stderr=null) if not in_tmux: os.execlp('tmux', 'tmux', 'attach', '-t', sessname) else: execl_args = [confettypath] + automation_args + ['start', '/nodes/{0}/console/session'.format(args[0])] os.execl(confettypath, *execl_args)