mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-16 13:08:25 +00:00
410 lines
21 KiB
Python
410 lines
21 KiB
Python
#!/usr/bin/env python
|
|
# License: GPL v3 Copyright: 2026, Kovid Goyal <kovid at kovidgoyal.net>
|
|
|
|
|
|
from kitty.fast_data_types import Screen
|
|
from kitty.os_window_size import WindowSize, WindowSizes, initial_window_size_func
|
|
from kitty.session import get_os_window_sizing_data, parse_session
|
|
|
|
from .base import BaseTest, parse_bytes
|
|
|
|
|
|
class TestSessions(BaseTest):
|
|
def test_session_size_overrides_remembered_size(self) -> None:
|
|
opts = self.set_options({'remember_window_size': True})
|
|
with_size, without_size = parse_session('os_window_size 1180 760\nlaunch\nnew_os_window\nlaunch', opts)
|
|
remembered = {'window-size': (900, 600)}
|
|
sd = get_os_window_sizing_data(opts, with_size)
|
|
self.ae((sd.remember_window_size, sd.initial_window_sizes), (False, WindowSizes(WindowSize(1180, 'px'), WindowSize(760, 'px'))))
|
|
for session in (without_size, None):
|
|
sd = get_os_window_sizing_data(opts, session)
|
|
self.assertTrue(sd.remember_window_size)
|
|
self.ae(initial_window_size_func(sd, remembered)(10, 20, 72, 72, 1, 1), (900, 600))
|
|
|
|
def test_session_os_window_geometry(self) -> None:
|
|
from kitty.fast_data_types import WINDOW_FULLSCREEN, WINDOW_MAXIMIZED, WINDOW_NORMAL
|
|
from kitty.tabs import os_window_geometry_as_session
|
|
|
|
opts = self.set_options()
|
|
first, second = parse_session('os_window_position -1200x80\nlaunch\nnew_os_window\nlaunch', opts)
|
|
self.ae((first.os_window_position, second.os_window_position), ((-1200, 80), None))
|
|
with self.assertRaises(ValueError):
|
|
tuple(parse_session('os_window_position 100\nlaunch', opts))
|
|
|
|
g = {'x': -1200, 'y': 80, 'width': 1180, 'height': 760, 'state': WINDOW_MAXIMIZED}
|
|
lines = os_window_geometry_as_session(g)
|
|
self.ae(lines, ['os_window_size 1180 760', 'os_window_position -1200x80', 'os_window_state maximized'])
|
|
self.ae(os_window_geometry_as_session(g, include_position=False), [lines[0], lines[2]])
|
|
(s,) = parse_session('\n'.join(lines + ['launch']), opts)
|
|
size = WindowSizes(WindowSize(1180, 'px'), WindowSize(760, 'px'))
|
|
self.ae((s.os_window_size, s.os_window_position, s.os_window_state), (size, (-1200, 80), 'maximized'))
|
|
for state, name in ((WINDOW_FULLSCREEN, 'fullscreen'), (WINDOW_NORMAL, 'normal')):
|
|
self.ae(os_window_geometry_as_session({**g, 'state': state})[-1], f'os_window_state {name}')
|
|
|
|
def test_scrollback_for_restore(self) -> None:
|
|
from kitty.logout_session import sanitize_restored_output, scrollback_for_restore
|
|
from kitty.window import as_text
|
|
|
|
def restore(data: bytes, cols: int = 10, lines: int = 4, scrollback: int = 20) -> Screen:
|
|
s = self.create_screen(cols=cols, lines=lines, scrollback=scrollback)
|
|
s.restore_scrollback(sanitize_restored_output(data.decode()).encode())
|
|
return s
|
|
|
|
def text(s: Screen) -> list[str]:
|
|
return as_text(s, add_history=True).rstrip('\n').splitlines()
|
|
|
|
src = self.create_screen(cols=10, lines=4, scrollback=20)
|
|
parse_bytes(
|
|
src, b''.join(b'line %d\r\n' % i for i in range(8)) + b'\x1b[31mred\x1b[m 0123456789abcdef\r\n\x1b]8;;https://x.org\x1b\\link\x1b]8;;\x1b\\'
|
|
)
|
|
expected, expected_ansi = text(src), as_text(src, as_ansi=True, add_history=True).rstrip('\n')
|
|
# Output on the alternate screen, such as from a full screen program, is not restored
|
|
parse_bytes(src, b'\x1b[?1049hfull screen program')
|
|
data = scrollback_for_restore(src)
|
|
self.assertNotIn(b'full screen program', data)
|
|
self.assertFalse(data.endswith(b'\r\n'))
|
|
same_width = restore(data)
|
|
self.ae(text(same_width), expected)
|
|
self.ae(as_text(same_width, as_ansi=True, add_history=True).rstrip('\n'), expected_ansi)
|
|
# Wrapped lines are re-wrapped to the width of the new screen
|
|
wider = restore(data, cols=30)
|
|
self.ae(text(wider)[-2:], ['red 0123456789abcdef', 'link'])
|
|
self.assertTrue(any(url.endswith('https://x.org') for url, hyperlink_id in wider.hyperlinks_as_set()))
|
|
|
|
# The scrollback pager history is not saved, so at most scrollback + lines lines are restored
|
|
src = self.create_screen(cols=10, lines=4, scrollback=5)
|
|
parse_bytes(src, b'\r\n'.join(b'%d' % i for i in range(30)))
|
|
self.ae(text(restore(scrollback_for_restore(src), scrollback=50)), [str(i) for i in range(21, 30)])
|
|
|
|
# The shell prompt the cursor is at is not restored, since the restored shell shows a new one
|
|
def restored_lines(data: bytes, lines: int = 6) -> list[str]:
|
|
src = self.create_screen(cols=20, lines=lines, scrollback=50)
|
|
parse_bytes(src, data)
|
|
return text(restore(scrollback_for_restore(src), cols=20, lines=lines, scrollback=50))
|
|
|
|
prompt, output = b'\x1b]133;A\x07', b'\x1b]133;C\x07'
|
|
self.ae(restored_lines(prompt + b'$ ls\r\n' + output + b'a\r\nb\r\n' + prompt + b'$ partial'), ['$ ls', 'a', 'b'])
|
|
two_line_prompt = prompt + b'~/project on main\r\n$ '
|
|
self.ae(restored_lines(two_line_prompt + b'ls\r\n' + output + b'a\r\n' + two_line_prompt), ['~/project on main', '$ ls', 'a'])
|
|
many = b''.join(b'%d\r\n' % i for i in range(10))
|
|
self.ae(restored_lines(prompt + b'$ seq\r\n' + output + many + prompt + b'$ ', lines=4), ['$ seq'] + [str(i) for i in range(10)])
|
|
# A running command is restored with all its output
|
|
self.ae(restored_lines(prompt + b'$ tail -f log\r\n' + output + b'a\r\nb'), ['$ tail -f log', 'a', 'b'])
|
|
|
|
# Shell integration marks are not restored, so restored output is not treated as the output of a command
|
|
src = self.create_screen(cols=20, lines=6, scrollback=50)
|
|
parse_bytes(src, prompt + b'$ ls\r\n' + output + b'a\r\n' + prompt + b'$ ')
|
|
data = scrollback_for_restore(src)
|
|
self.assertIn(b'\x1b]133;C', data)
|
|
self.assertNotIn('\x1b]133;', sanitize_restored_output(data.decode()))
|
|
|
|
# Output larger than the parser buffer
|
|
big = self.create_screen(cols=80, lines=4, scrollback=20)
|
|
big.restore_scrollback(b''.join(b'%05d %s\r\n' % (i, b'x' * 70) for i in range(16000)))
|
|
self.ae(text(big)[-1], '15999 ' + 'x' * 70)
|
|
|
|
# Restoring scrollback while the child is writing to the screen raises instead of crashing
|
|
s = self.create_screen()
|
|
s.test_create_write_buffer()
|
|
with self.assertRaises(RuntimeError):
|
|
s.restore_scrollback(b'x')
|
|
|
|
def test_sanitize_restored_output(self) -> None:
|
|
from kitty.logout_session import sanitize_restored_output as s
|
|
|
|
sgr, link, link_end, sized = '\x1b[1;38:2:1:2:3m', '\x1b]8;id=1;https://x.org\x1b\\', '\x1b]8;;\x07', '\x1b]66;s=2;big\x1b\\'
|
|
text = f'{sgr}bold\x1b[m {link}link{link_end} {sized}\ttab\r\n'
|
|
self.ae(s(text), text)
|
|
for unsafe, expected in (
|
|
('\x1b]52;c;aGVsbG8=\x07', 'ab'),
|
|
('\x1b]133;A\x1b\\', 'ab'),
|
|
('\x1b]99;;notification\x1b\\', 'ab'),
|
|
('\x1bP@kitty-cmd{"cmd":"ls"}\x1b\\', 'ab'),
|
|
('\x1b_Gf=100;AAAA\x1b\\', 'ab'),
|
|
('\x1b[2J', 'ab'),
|
|
('\x1b[?1049h', 'ab'),
|
|
('\x1bc', 'ab'),
|
|
('\x07\x08\x0c', 'ab'),
|
|
('\x1b', 'a'), # ESC followed by a character is an escape code
|
|
('\x9b2J', 'a2Jb'), # C1 control codes are removed, leaving harmless text
|
|
('\x1b]0;title', 'a'), # an unterminated OSC consumes the rest of the text
|
|
):
|
|
with self.subTest(unsafe=unsafe):
|
|
self.ae(s(f'a{unsafe}b'), expected)
|
|
|
|
def test_logout_snapshots(self) -> None:
|
|
from .crypto import is_rlimit_memlock_too_low
|
|
|
|
if is_rlimit_memlock_too_low():
|
|
self.skipTest('RLIMIT_MEMLOCK is too low')
|
|
import json
|
|
import os
|
|
import shlex
|
|
import shutil
|
|
import stat
|
|
import tempfile
|
|
import time
|
|
from unittest.mock import patch
|
|
|
|
from kitty.constants import unserialize_launch_flag
|
|
from kitty.fast_data_types import Secret
|
|
from kitty.logout_session import (
|
|
LOGOUT_CONFIRMATION_TIMEOUT,
|
|
ProcessState,
|
|
claim_snapshots,
|
|
delete_snapshot,
|
|
finish_restore,
|
|
is_logout_in_progress,
|
|
load_snapshot,
|
|
lock_snapshot_for_saver,
|
|
new_key_id,
|
|
read_key_id,
|
|
release_saver_lock,
|
|
remove_all_snapshots,
|
|
remove_orphaned_keys,
|
|
remove_stale_snapshots,
|
|
restore_snapshots,
|
|
save_snapshot,
|
|
)
|
|
from kitty.utils import log_error
|
|
|
|
class FakeKeyStore:
|
|
def __init__(self) -> None:
|
|
self.keys: dict[str, Secret] = {}
|
|
self.fail = False
|
|
|
|
def store(self, key_id: str, key: Secret) -> None:
|
|
if self.fail:
|
|
raise OSError('User interaction is not allowed')
|
|
self.keys[key_id] = key
|
|
|
|
def read(self, key_id: str) -> Secret | None:
|
|
if self.fail:
|
|
raise OSError('User interaction is not allowed')
|
|
return self.keys.get(key_id)
|
|
|
|
def delete(self, key_id: str) -> None:
|
|
self.keys.pop(key_id, None)
|
|
|
|
def list_ids(self) -> list[str]:
|
|
if self.fail:
|
|
raise OSError('User interaction is not allowed')
|
|
return list(self.keys)
|
|
|
|
errors: list[str] = []
|
|
log_error.redirect = errors.append
|
|
self.addCleanup(delattr, log_error, 'redirect')
|
|
opts = self.set_options()
|
|
tdir = tempfile.mkdtemp()
|
|
self.addCleanup(shutil.rmtree, tdir, True)
|
|
base = os.path.join(tdir, 'saved-at-logout')
|
|
state = ProcessState(('--config', 'other.conf'), tdir, {'SECRET_VAR': 'value'}, 0)
|
|
session = shlex.join(['launch', unserialize_launch_flag + json.dumps({'id': 7})])
|
|
ks = FakeKeyStore()
|
|
|
|
def save(pid: int, argv: tuple[str, ...] = state.argv) -> str:
|
|
return save_snapshot(base, pid, session, {7: b'\x1b]52;c;eA==\x07seven', 8: b'eight'}, state._replace(argv=argv), ks)
|
|
|
|
def mode(path: str) -> int:
|
|
return stat.S_IMODE(os.stat(path).st_mode)
|
|
|
|
def raw(path: str, name: str) -> bytes:
|
|
with open(os.path.join(path, name), 'rb') as f:
|
|
return f.read()
|
|
|
|
# The saved state is readable only by the user and is encrypted with a key in the key store
|
|
path = save(11)
|
|
self.ae((mode(base), mode(path), mode(os.path.join(path, 'scrollback', '7')), mode(os.path.join(path, 'process.json'))), (0o700, 0o700, 0o600, 0o600))
|
|
self.ae(list(ks.keys), [read_key_id(path)])
|
|
for name, plaintext in (('process.json', b'SECRET_VAR'), ('session.kitty-session', b'launch'), ('scrollback/7', b'seven')):
|
|
self.assertNotIn(plaintext, raw(path, name))
|
|
# Snapshots from before this instance was started are from an earlier logout and were never restored, their keys are deleted
|
|
stale = save(10)
|
|
day_ago = time.time() - 86400
|
|
os.utime(stale, (day_ago, day_ago))
|
|
remove_stale_snapshots(base, time.time() - 3600, ks)
|
|
self.ae((os.listdir(base), list(ks.keys)), (['11'], [read_key_id(path)]))
|
|
# Nothing is saved if the key cannot be stored, for example because the keychain needs user interaction
|
|
ks.fail = True
|
|
with self.assertRaises(OSError):
|
|
save(12)
|
|
ks.fail = False
|
|
self.ae(os.listdir(base), ['11'])
|
|
|
|
# Snapshots claimed by a running kitty instance are not claimed again, but those claimed by an instance that died are
|
|
alive = {99}
|
|
os.rename(path, os.path.join(base, '11.claimed-by-99'))
|
|
self.ae(claim_snapshots(base, 1, ks, alive.__contains__), [])
|
|
alive.clear()
|
|
(snapshot,) = claim_snapshots(base, 1, ks, alive.__contains__)
|
|
self.ae((snapshot.path, snapshot.process_state[:3]), (os.path.join(base, '11.claimed-by-1'), state[:3]))
|
|
(s,) = load_snapshot(snapshot.path, opts, ks)
|
|
# The scrollback is restored, without unsafe escape codes, followed by a line showing when it was saved
|
|
restored = s.tabs[0].windows[0].restored_scrollback
|
|
self.assertTrue(restored.startswith(b'seven\r\n'), restored)
|
|
self.assertIn(b'Restored from', restored)
|
|
# A snapshot that repeatedly fails to be restored, for example, because kitty crashes, is deleted, with its key
|
|
self.ae(len(claim_snapshots(base, 2, ks, alive.__contains__)), 1)
|
|
self.ae(claim_snapshots(base, 3, ks, alive.__contains__), [])
|
|
self.ae((os.listdir(base), ks.keys), ([], {}))
|
|
self.assertTrue(errors)
|
|
|
|
# Snapshots that cannot be decrypted are deleted: key not in the keychain, keychain needs user interaction, modified or
|
|
# swapped files
|
|
def modify(path: str) -> None:
|
|
data = bytearray(raw(path, 'process.json'))
|
|
data[-1] ^= 1
|
|
with open(os.path.join(path, 'process.json'), 'wb') as f:
|
|
f.write(data)
|
|
|
|
def swap(path: str) -> None:
|
|
os.replace(os.path.join(path, 'session.kitty-session'), os.path.join(path, 'process.json'))
|
|
|
|
for name, damage, num_errors in (
|
|
('missing key', lambda path: ks.keys.clear(), 1),
|
|
# both reading the key and listing keys to remove orphans fail
|
|
('keychain needs interaction', lambda path: setattr(ks, 'fail', True), 2),
|
|
('modified', modify, 1),
|
|
('swapped', swap, 1),
|
|
):
|
|
with self.subTest(name):
|
|
errors.clear()
|
|
damage(save(13))
|
|
self.ae(claim_snapshots(base, 1, ks, alive.__contains__), [])
|
|
ks.fail = False
|
|
self.ae((os.listdir(base), len(errors)), ([], num_errors))
|
|
|
|
# Keys of snapshots deleted by something other than kitty are deleted, but not the keys of existing snapshots or keys
|
|
# not created by kitty
|
|
path = save(15)
|
|
orphan, foreign = new_key_id(), 'some-other-item'
|
|
ks.keys[orphan] = ks.keys[foreign] = ks.keys[read_key_id(path)]
|
|
remove_orphaned_keys(base, ks)
|
|
self.ae(sorted(ks.keys), sorted((read_key_id(path), foreign)))
|
|
# Orphans are removed when saving and claiming, and all keys when all snapshots are removed
|
|
ks.keys[orphan] = ks.keys[foreign]
|
|
remove_stale_snapshots(base, 0, ks)
|
|
self.assertNotIn(orphan, ks.keys)
|
|
ks.keys[orphan] = ks.keys[foreign]
|
|
self.ae(len(claim_snapshots(base, 1, ks, alive.__contains__)), 1)
|
|
self.assertNotIn(orphan, ks.keys)
|
|
# Failing to list the keys is logged, not raised
|
|
errors.clear()
|
|
ks.fail = True
|
|
remove_orphaned_keys(base, ks)
|
|
ks.fail = False
|
|
self.ae(len(errors), 1)
|
|
shutil.rmtree(base)
|
|
ks.keys.clear()
|
|
|
|
# Files are bound to their names, so swapping the scrollback of two windows is detected
|
|
path = save(14)
|
|
os.rename(os.path.join(path, 'scrollback', '7'), os.path.join(path, 'scrollback', 'x'))
|
|
os.rename(os.path.join(path, 'scrollback', '8'), os.path.join(path, 'scrollback', '7'))
|
|
with self.assertRaises(Exception):
|
|
load_snapshot(path, opts, ks)
|
|
shutil.rmtree(base)
|
|
ks.keys.clear()
|
|
|
|
# The snapshot of a kitty instance that is still running, for example, because the logout was cancelled, is not claimed,
|
|
# even if a process with its pid is running, since pids are reused
|
|
import kitty.logout_session as ls
|
|
|
|
path = save(16)
|
|
lock_snapshot_for_saver(path)
|
|
alive.add(16)
|
|
self.ae(claim_snapshots(base, 1, ks, alive.__contains__), [])
|
|
release_saver_lock(os.path.join(base, 'other'))
|
|
self.ae(claim_snapshots(base, 1, ks, alive.__contains__), [])
|
|
release_saver_lock(path)
|
|
self.ae(len(claim_snapshots(base, 1, ks, alive.__contains__)), 1)
|
|
alive.clear()
|
|
# Deleting the snapshot of this instance, as when the logout is cancelled, releases its lock
|
|
path = save(17)
|
|
lock_snapshot_for_saver(path)
|
|
delete_snapshot(path)
|
|
self.assertIsNone(ls.saver_lock)
|
|
shutil.rmtree(base)
|
|
ks.keys.clear()
|
|
|
|
# Without a key store, as on Linux, snapshots are not encrypted and are readable only by the user
|
|
path = save_snapshot(base, 31, session, {7: b'seven'}, state, None)
|
|
self.ae((read_key_id(path), mode(path), mode(os.path.join(path, 'process.json'))), ('', 0o700, 0o600))
|
|
self.assertIn(b'SECRET_VAR', raw(path, 'process.json'))
|
|
(snapshot,) = claim_snapshots(base, 1, None, alive.__contains__)
|
|
self.ae(snapshot.process_state[:3], state[:3])
|
|
(s,) = load_snapshot(snapshot.path, opts, None)
|
|
self.assertTrue(s.tabs[0].windows[0].restored_scrollback.startswith(b'seven\r\n'))
|
|
finish_restore(snapshot.path)
|
|
# An encrypted snapshot cannot be read without a key store and an unencrypted one is not accepted when there is a key store
|
|
errors.clear()
|
|
save_snapshot(base, 32, session, {}, state, None)
|
|
self.ae(claim_snapshots(base, 1, ks, alive.__contains__), [])
|
|
save(33)
|
|
self.ae(claim_snapshots(base, 1, None, alive.__contains__), [])
|
|
self.ae((os.listdir(base), len(errors)), ([], 2))
|
|
remove_orphaned_keys(base, ks)
|
|
self.ae(ks.keys, {})
|
|
shutil.rmtree(base)
|
|
ks.keys.clear()
|
|
|
|
# The snapshot of the kitty instance with the same command line is restored in this instance, others in new instances
|
|
save(21, ('a',)), save(22, ('b',))
|
|
started: list[str] = []
|
|
with (
|
|
patch('kitty.logout_session.snapshots_dir', return_value=base),
|
|
patch('kitty.logout_session.get_key_store', return_value=ks),
|
|
patch('kitty.logout_session.start_instance_for_snapshot', side_effect=lambda s: started.append(s.path)),
|
|
):
|
|
r = restore_snapshots(opts, ('b',))
|
|
assert r is not None
|
|
self.ae((os.path.basename(r.path), len(r.sessions)), (f'22.claimed-by-{os.getpid()}', 1))
|
|
self.ae([os.path.basename(x) for x in started], [f'21.claimed-by-{os.getpid()}'])
|
|
# Snapshots and their keys are deleted only once they have been restored
|
|
self.assertTrue(os.path.exists(r.path))
|
|
self.ae(len(ks.keys), 2)
|
|
finish_restore(r.path)
|
|
self.ae((os.listdir(base), list(ks.keys)), ([os.path.basename(started[0])], [read_key_id(started[0])]))
|
|
self.assertIsNone(restore_snapshots(opts, ('b',)))
|
|
remove_all_snapshots()
|
|
self.assertFalse(os.path.exists(base))
|
|
self.ae(ks.keys, {})
|
|
self.assertIsNone(restore_snapshots(opts, ('b',)))
|
|
|
|
# On Linux, the snapshot is saved when the desktop portal says the session is about to end and is deleted if the logout is
|
|
# cancelled
|
|
from types import SimpleNamespace
|
|
|
|
from kitty.boss import Boss
|
|
from kitty.logout_session import DESKTOP_SESSION_ENDING, DESKTOP_SESSION_QUERY_END, DESKTOP_SESSION_RUNNING
|
|
|
|
boss = SimpleNamespace(snapshot_saved_for_logout='', save_session_at_logout=lambda: save_snapshot(base, 41, session, {}, state, None))
|
|
for new_state, expected in (
|
|
(DESKTOP_SESSION_QUERY_END, ['41']),
|
|
(DESKTOP_SESSION_RUNNING, []),
|
|
(DESKTOP_SESSION_QUERY_END, ['41']),
|
|
(DESKTOP_SESSION_ENDING, ['41']),
|
|
):
|
|
Boss.on_desktop_session_state_changed(boss, new_state) # type: ignore[arg-type]
|
|
self.ae(os.listdir(base), expected)
|
|
shutil.rmtree(base)
|
|
|
|
# Restored instances get variables that refer to the login session, such as the display, from the current login session and
|
|
# never get single use startup tokens
|
|
from kitty.logout_session import environment_for_snapshot
|
|
|
|
self.ae(
|
|
environment_for_snapshot(
|
|
{'HOME': '/h', 'WAYLAND_DISPLAY': 'wayland-1', 'XAUTHORITY': '/old', 'DISPLAY': ':1', 'XDG_ACTIVATION_TOKEN': 'x'},
|
|
{'HOME': '/other', 'DISPLAY': ':0', 'XAUTHORITY': '/new', 'XDG_ACTIVATION_TOKEN': 'y'},
|
|
),
|
|
{'HOME': '/h', 'DISPLAY': ':0', 'XAUTHORITY': '/new'},
|
|
)
|
|
|
|
# A quit confirmed long after the OS asked kitty to quit for a logout is an ordinary quit
|
|
for requested_at, now, expected in ((-1, 10, False), (5, 10, True), (5, 6 + LOGOUT_CONFIRMATION_TIMEOUT, False)):
|
|
with (
|
|
patch('kitty.logout_session.application_logout_requested_at', return_value=requested_at),
|
|
patch('kitty.logout_session.monotonic', return_value=now),
|
|
):
|
|
self.ae(is_logout_in_progress(), expected)
|