multiSSH3 6.33__tar.gz → 6.34__tar.gz

{multissh3-6.33/multiSSH3.egg-info → multissh3-6.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multiSSH3
-Version: 6.33
+Version: 6.34
 Summary: Run commands on multiple hosts via SSH
 Home-page: https://github.com/yufei-pan/multiSSH3
 Author: Yufei Pan
@@ -336,6 +336,8 @@ When hostname need to be resolved, mssh will check in the following order:
 
 An alias's value is split into hosts as the hosts argument is (`,`, spaces, `;`, ...). An alias with an empty value (`eu=''`) stands for no hosts.
 
+A member can name its user: with `dbs="postgres@db1,db2"`, mssh logs in to db1 as postgres, and `-u` changes only db2's user. A user typed with the alias replaces it: `mssh root@dbs` logs in to both as root, as a user on the command line wins over ssh config's `User`.
+
 Inside its own expansion, directly or through other aliases, an alias's name is not expanded again but taken as a host name, as bash does with aliases: `web="web,web-b"` runs on the host `web` and on `web-b`. When no host has that name, mssh reports the loop and runs on the rest: `Error: alias loop through 'web' (web -> app -> web): 'web' is not a valid hostname or IP address!`
 
 
@@ -970,7 +972,7 @@ Option names count in full only: `--user` is not `--username` and `-c` is not `-
 
 Putting the command after `--` is no substitute for quotes: every word after the hosts is a command of its own, so `mssh web1 -- bash -c 'echo hi'` runs `bash`, `-c` and `echo hi` one after another (when each word is a single word, as in `mssh web1 -- ls -la`, mssh asks whether to join them).
 
-Below is a sample help message output from multiSSH3 6.33 @ 2026-10-14 (no config file, 120 columns; the lines after the options list the programs found on that machine)
+Below is a sample help message output from multiSSH3 6.34 @ 2026-10-16 (no config file, 120 columns; the lines after the options list the programs found on that machine)
 
 ```bash
 $ mssh -h

{multissh3-6.33 → multissh3-6.34}/README.md

@@ -310,6 +310,8 @@ When hostname need to be resolved, mssh will check in the following order:
 
 An alias's value is split into hosts as the hosts argument is (`,`, spaces, `;`, ...). An alias with an empty value (`eu=''`) stands for no hosts.
 
+A member can name its user: with `dbs="postgres@db1,db2"`, mssh logs in to db1 as postgres, and `-u` changes only db2's user. A user typed with the alias replaces it: `mssh root@dbs` logs in to both as root, as a user on the command line wins over ssh config's `User`.
+
 Inside its own expansion, directly or through other aliases, an alias's name is not expanded again but taken as a host name, as bash does with aliases: `web="web,web-b"` runs on the host `web` and on `web-b`. When no host has that name, mssh reports the loop and runs on the rest: `Error: alias loop through 'web' (web -> app -> web): 'web' is not a valid hostname or IP address!`
 
 
@@ -944,7 +946,7 @@ Option names count in full only: `--user` is not `--username` and `-c` is not `-
 
 Putting the command after `--` is no substitute for quotes: every word after the hosts is a command of its own, so `mssh web1 -- bash -c 'echo hi'` runs `bash`, `-c` and `echo hi` one after another (when each word is a single word, as in `mssh web1 -- ls -la`, mssh asks whether to join them).
 
-Below is a sample help message output from multiSSH3 6.33 @ 2026-10-14 (no config file, 120 columns; the lines after the options list the programs found on that machine)
+Below is a sample help message output from multiSSH3 6.34 @ 2026-10-16 (no config file, 120 columns; the lines after the options list the programs found on that machine)
 
 ```bash
 $ mssh -h

{multissh3-6.33 → multissh3-6.34}/mssh_complete.py

@@ -16,7 +16,7 @@ import sys
 import time
 from bisect import bisect_left
 
-version = '0.6'
+version = '0.7'
 __version__ = version
 PROTOCOL = 'MSSHC1'
 MSSH_NAMES = ('mssh', 'mssh3', 'multissh', 'multissh3', 'multiSSH3')
@@ -2577,12 +2577,9 @@ def _run_name(host, typed_user, line_user, own_user=''):
 	The name mssh gives a host in this run: what it records a failure under in unavailable_hosts.csv
 	and looks up to skip the host. The user typed with the host, else -u (line_user), else none.
 	own_user: the user an alias member is written with. -u does not replace it, a user typed with the
-	alias goes in front of it (for root@dbs with dbs=postgres@db1 mssh runs root@postgres@db1).
+	alias does (for root@dbs with dbs=postgres@db1 mssh runs root@db1).
 	'''
-	if own_user:
-		host = own_user + '@' + host
-		line_user = ''
-	user = typed_user or line_user
+	user = typed_user or own_user or line_user
 	return user + '@' + host if user else host
 
 # characters that can start an expansion the shell makes before mssh sees the word

{multissh3-6.33 → multissh3-6.34/multiSSH3.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multiSSH3
-Version: 6.33
+Version: 6.34
 Summary: Run commands on multiple hosts via SSH
 Home-page: https://github.com/yufei-pan/multiSSH3
 Author: Yufei Pan
@@ -336,6 +336,8 @@ When hostname need to be resolved, mssh will check in the following order:
 
 An alias's value is split into hosts as the hosts argument is (`,`, spaces, `;`, ...). An alias with an empty value (`eu=''`) stands for no hosts.
 
+A member can name its user: with `dbs="postgres@db1,db2"`, mssh logs in to db1 as postgres, and `-u` changes only db2's user. A user typed with the alias replaces it: `mssh root@dbs` logs in to both as root, as a user on the command line wins over ssh config's `User`.
+
 Inside its own expansion, directly or through other aliases, an alias's name is not expanded again but taken as a host name, as bash does with aliases: `web="web,web-b"` runs on the host `web` and on `web-b`. When no host has that name, mssh reports the loop and runs on the rest: `Error: alias loop through 'web' (web -> app -> web): 'web' is not a valid hostname or IP address!`
 
 
@@ -970,7 +972,7 @@ Option names count in full only: `--user` is not `--username` and `-c` is not `-
 
 Putting the command after `--` is no substitute for quotes: every word after the hosts is a command of its own, so `mssh web1 -- bash -c 'echo hi'` runs `bash`, `-c` and `echo hi` one after another (when each word is a single word, as in `mssh web1 -- ls -la`, mssh asks whether to join them).
 
-Below is a sample help message output from multiSSH3 6.33 @ 2026-10-14 (no config file, 120 columns; the lines after the options list the programs found on that machine)
+Below is a sample help message output from multiSSH3 6.34 @ 2026-10-16 (no config file, 120 columns; the lines after the options list the programs found on that machine)
 
 ```bash
 $ mssh -h

{multissh3-6.33 → multissh3-6.34}/multiSSH3.py

@@ -40,10 +40,10 @@ from itertools import count, product
 from pprint import pformat
 
 
-version = '6.33'
+version = '6.34'
 VERSION = version
 __version__ = version
-COMMIT_DATE = '2026-10-14'
+COMMIT_DATE = '2026-10-16'
 # TODO: Add terminal TUI
 
 # no current-directory entry: a cloned repo or unpacked archive could set any global (e.g. _sshPath),
@@ -2642,9 +2642,10 @@ def __expand_hostnames(hosts, hosts_only=False) -> dict:
 		if username:
 			# we expand the username
 			username = sorted(__expand_hostname(username,validate=False))
-			# we combine the username and hostname
+			# we combine the username and hostname: the typed user replaces the one an alias member
+			# is written with, as the command line wins over ssh config's User
 			for user in username:
-				[expandedhosts.update({f'{user}@{host}':ip}) for host,ip in zip(hostSetToAdd,iplist)]
+				[expandedhosts.update({f'{user}@{host.rpartition("@")[2]}':ip}) for host,ip in zip(hostSetToAdd,iplist)]
 		else:
 			[expandedhosts.update({host:ip}) for host,ip in zip(hostSetToAdd,iplist)]
 	return expandedhosts
@@ -2697,6 +2698,8 @@ def expand_hostnames_local(hosts):
 			else:
 				members = [(user, name, source, None)]
 			for member_user, member, member_source, _ in members:
+				# a typed user replaces a member's own, as in expand_hostnames
+				member_user = user or member_user
 				full = '{}@{}'.format(member_user, member) if member_user else member
 				expanded.add(full)
 				if member_source is None:
@@ -3325,15 +3328,19 @@ def _stopped_command_note(formatedCMD):
 	Only the local program ends: a command ssh runs on a host gets no signal (it has no terminal), it
 	runs on until it ends, or until it writes to the closed connection.
 	'''
-	program = formatedCMD[0] if formatedCMD else ''
-	if program == _binPaths.get('sshpass') and len(formatedCMD) > 2:
-		# sshpass -e program, or sshpass -p password program
-		program = formatedCMD[2] if formatedCMD[1] == '-e' else formatedCMD[3] if len(formatedCMD) > 3 else program
-	if program == _binPaths.get('ssh'):
+	# the program under sshpass, also in --copy_id's sh -c line
+	name = _sshpass_program(formatedCMD)
+	if not name:
+		program = str(formatedCMD[0]) if formatedCMD else ''
+		# known by the path mssh found it at (ssh.EXE on Windows)
+		name = next((known for known in ('ssh', 'rsync', 'scp') if program == _binPaths.get(known)), os.path.basename(program))
+	if name == 'ssh':
 		return 'ssh was stopped: the command may still run on the host'
-	name = os.path.basename(str(program))
-	if program in (_binPaths.get('rsync'), _binPaths.get('scp')):
+	if name in ('rsync', 'scp'):
 		return f'{name} was stopped: the copy may be incomplete'
+	if name == 'ssh-copy-id':
+		# after its clean-up it may say all keys were skipped as already there
+		return 'ssh-copy-id was stopped: the key may not be installed'
 	return f'{name} was stopped'
 
 def _ipmi_failure_should_wait(host, line_starts=(0, 0, 0)):
@@ -4225,9 +4232,7 @@ def _execute_command(host, formatedCMD, sem, timeout, retry_limit, passwords=(),
 							stopped = f'No output for {timeout} s, so {_stopped_command_note(formatedCMD)}.'
 							host.stderr.append(stopped)
 							host.output.append(stopped)
-							proc.send_signal(signal.SIGINT)
-							time.sleep(0.1)
-							proc.terminate()
+							_stop_command(proc, formatedCMD)
 							break
 						elif time.monotonic() - host.lastUpdateTime >  max(1, timeout // 2):
 							timeoutLine = f'Timeout in [{timeout - int(time.monotonic() - host.lastUpdateTime)}] seconds!'
@@ -4247,9 +4252,7 @@ def _execute_command(host, formatedCMD, sem, timeout, retry_limit, passwords=(),
 						host.stderr.append('Ctrl C detected, Emergency Stop!')
 						host.output.append('Ctrl C detected, Emergency Stop!')
 						stopped_by_ctrl_c = True
-						proc.send_signal(signal.SIGINT)
-						time.sleep(0.1)
-						proc.terminate()
+						_stop_command(proc, formatedCMD)
 						break
 					time.sleep(sleep_interval)  # avoid busy-waiting
 					if sleep_interval < 0.001:
@@ -4378,6 +4381,71 @@ def _execute_command(host, formatedCMD, sem, timeout, retry_limit, passwords=(),
 			retry_limit -= 1
 	return False, retry_limit, attempt_line_starts
 
+def _child_pids(pid):
+	'''The pids of pid's child processes; [] when neither /proc nor pgrep can list them.'''
+	try:
+		with open('/proc/{0}/task/{0}/children'.format(pid)) as children:
+			return [int(child) for child in children.read().split()]
+	except (OSError, ValueError):
+		pass
+	try:
+		listed = subprocess.run(['pgrep', '-P', str(pid)], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, timeout=1).stdout
+		return [int(child) for child in listed.split()]
+	except (OSError, ValueError, subprocess.SubprocessError):
+		return []
+
+def _sessions_below(pid):
+	'''
+	The processes below pid that lead a session of their own (sshpass makes its command one); each is
+	its process group. Never init's or mssh's own group: pgrep -P 0 lists init.
+	'''
+	if not isinstance(pid, int) or pid <= 1:
+		return []
+	leaders = []
+	seen = {pid}
+	pids = _child_pids(pid)
+	while pids:
+		child = pids.pop()
+		if child in seen or child <= 1:
+			continue
+		seen.add(child)
+		try:
+			if os.getsid(child) == child:
+				if child != os.getpgrp():
+					leaders.append(child)
+				continue
+		except OSError:
+			continue
+		pids.extend(_child_pids(child))
+	return leaders
+
+def _stop_command(proc, formatedCMD):
+	'''
+	Stop a command mssh gives up on (-t, Ctrl C) as Ctrl C at a terminal would, then as mssh always did.
+
+	sshpass runs its command as a session of its own on a terminal of its own, and passes SIGINT on as
+	a typed Ctrl C only once ssh has written there. While ssh is still connecting, any signal ends
+	sshpass at once and hangs up that terminal: ssh-copy-id, whose trap does not cover SIGHUP, then left
+	an empty ~/.ssh/ssh-copy-id.XXXXXXXXXX. So the command under sshpass gets the SIGINT first, as a
+	typed Ctrl C would give it, and a moment to end.
+	'''
+	if os.name == 'posix' and _sshpass_program(formatedCMD):
+		leaders = _sessions_below(proc.pid)
+		for leader in leaders:
+			try:
+				os.killpg(leader, signal.SIGINT)
+			except OSError:
+				pass
+		if leaders:
+			try:
+				proc.wait(timeout=1)
+			except subprocess.TimeoutExpired:
+				pass
+	if proc.poll() is None:
+		proc.send_signal(signal.SIGINT)
+		time.sleep(0.1)
+		proc.terminate()
+
 # sshpass's own exit codes: 5 ssh asked for the password again, 6 ssh asked whether to trust a host key it
 # does not know, 7 ssh warned that the key known for the host's IP address differs and asked whether to go on
 _SSHPASS_EXIT_CODES = (5, 6, 7)
@@ -5650,6 +5718,12 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 				host_window.noutrefresh()
 				host.lastPrintedUpdateTime = host.lastUpdateTime
 			hosts_to_display, host_stats,rearrangedHosts = _get_hosts_to_display(hosts, max_num_hosts,hosts_to_display, indexOffset)
+			# a host coming into a window is drawn whole: the lines noted for hosts without one would only
+			# pile up, one entry per line of their output
+			shown = set(hosts_to_display)
+			for host in hosts:
+				if host.lineNumToPrintSet and host not in shown:
+					host.lineNumToPrintSet = set()
 			if help_shown:
 				help_window.touchwin()
 				help_window.noutrefresh()

{multissh3-6.33 → multissh3-6.34}/tests/complete_shell_harness.py

@@ -17,6 +17,22 @@ import pytest
 
 REPO = Path(__file__).resolve().parents[1]
 ENGINE = [sys.executable, '-I', str(REPO / 'mssh_complete.py')]
+# 2026-10-13 00:00 UTC, when the histories these tests write were given their fixed times (1790000000 on)
+WRITTEN = 1791849600
+
+def aged(stamp):
+	'''
+	A fixed time from before WRITTEN, moved to be as old now as it was then. The engine weighs history
+	by its age on the real clock (a use halves its weight every week), so fixed times would rank
+	differently as the days pass: a suggestion the tests do not expect appeared 24 days on.
+	'''
+	stamp = int(stamp)
+	return stamp + max(0, int(time.time()) - WRITTEN) if stamp < WRITTEN else stamp
+
+def _aged_line(line):
+	'''An mssh history line with its time aged.'''
+	stamp, tab, rest = line.partition('\t')
+	return '{}\t{}'.format(aged(stamp), rest) if tab and stamp.isdigit() else line
 
 def require_shell(name):
 	'''The path of shell name; skip the test if it is missing, unless MSSH_REQUIRE_SHELLS lists it.'''
@@ -30,7 +46,7 @@ def require_shell(name):
 
 def make_home(tmp_path, history_lines=()):
 	'''
-	A private HOME and XDG_RUNTIME_DIR holding the given mssh history. Returns (env, home).
+	A private HOME and XDG_RUNTIME_DIR holding the given mssh history, its fixed times aged. Returns (env, home).
 
 	The prober's lock is taken, so no prober runs (no DNS, no ping): tests that want answers about
 	hosts write host-state.tsv themselves. An mssh config in HOME keeps this machine's /etc/hosts and
@@ -43,7 +59,7 @@ def make_home(tmp_path, history_lines=()):
 	runtime.mkdir(mode=0o700)
 	(runtime / 'multiSSH3').mkdir(mode=0o700)
 	(runtime / 'multiSSH3' / 'probe.lock').write_text('')
-	(home / '.mssh_history').write_text(''.join(line + '\n' for line in history_lines))
+	(home / '.mssh_history').write_text(''.join(_aged_line(line) + '\n' for line in history_lines))
 	(home / '.multiSSH3.config.json').write_text(json.dumps({'DEFAULT_HOST_FILE': str(home / 'hosts'),
 		'DEFAULT_ENV_FILES': [path for path in multiSSH3.DEFAULT_ENV_FILES if path.startswith('~')]}))
 	env = {

{multissh3-6.33 → multissh3-6.34}/tests/test_complete_diagnose.py

@@ -895,9 +895,10 @@ def test_unreachable_members_of_an_alias_with_a_user(skipping, line, word):
 	# a member written with its user keeps it, -u is for the others
 	('mssh -u root dbs uptime', ['postgres@db1', 'root@node02'], 'db1, node02'),
 	('mssh -u root dbs uptime', ['root@db1'], None),
-	# a user typed with the alias goes in front of the member's: mssh runs root@postgres@db1
-	('mssh root@dbs uptime', ['root@postgres@db1'], 'db1'),
-	('mssh root@dbs uptime', ['root@db1'], None),
+	# a user typed with the alias replaces the member's: mssh runs root@db1
+	('mssh root@dbs uptime', ['root@db1'], 'db1'),
+	('mssh root@dbs uptime', ['postgres@db1'], None),
+	('mssh root@dbs uptime', ['root@postgres@db1'], None),
 ])
 def test_unreachable_members_of_an_alias_written_with_users(skipping, tmp_path, line, failed, down):
 	# dbs=postgres@db1,node02 in an env file

{multissh3-6.33 → multissh3-6.34}/tests/test_complete_keys.py

@@ -13,7 +13,7 @@ import time
 import pytest
 
 import mssh_complete as mc
-from complete_shell_harness import (ENGINE, bash_session, blesh_session, build_index, fish_session, make_home,
+from complete_shell_harness import (ENGINE, aged, bash_session, blesh_session, build_index, fish_session, make_home,
 	require_shell, without_command, zsh_session)
 
 HISTORY = ['17900000{:02d}\t/x/multiSSH3.py\t-su\tgpu[01-16]\t"nvidia-smi"'.format(number) for number in range(6)] + [
@@ -1845,7 +1845,7 @@ def test_fish_ignores_the_operators_functions(home, where):
 	# lines only fish's own history has: a local command, and an mssh line
 	data = home / '.local' / 'share' / 'fish'
 	data.mkdir(parents=True)
-	(data / 'fish_history').write_text('- cmd: echo three\n  when: 1790000000\n- cmd: mssh zzq9 fishonly\n  when: 1790000001\n')
+	(data / 'fish_history').write_text('- cmd: echo three\n  when: {}\n- cmd: mssh zzq9 fishonly\n  when: {}\n'.format(aged(1790000000), aged(1790000001)))
 	config = home / '.config' / 'fish'
 	(config / 'completions').mkdir(parents=True)
 	(config / 'completions' / 'mssh.fish').write_text(mc.render_glue('fish', ENGINE))

{multissh3-6.33 → multissh3-6.34}/tests/test_complete_shells.py

@@ -10,7 +10,7 @@ import time
 import pytest
 
 import mssh_complete as mc
-from complete_shell_harness import (ENGINE, REPO, bash_session, build_index, fish_complete, fish_session, make_home,
+from complete_shell_harness import (ENGINE, REPO, aged, bash_session, build_index, fish_complete, fish_session, make_home,
 	require_shell, without_command, zsh_session)
 
 HISTORY = [
@@ -315,7 +315,7 @@ def test_fish_without_timeout_shows_nothing_but_the_completion(setup, tmp_path,
 	# more shell history than a pipe holds: the slow engine never reads it, and fish must not wait to write it
 	history = home / '.local' / 'share' / 'fish'
 	history.mkdir(parents=True)
-	(history / 'fish_history').write_text(''.join('- cmd: echo {} {}\n  when: {}\n'.format(number, 'x' * 300, 1790000000 + number) for number in range(1000)))
+	(history / 'fish_history').write_text(''.join('- cmd: echo {} {}\n  when: {}\n'.format(number, 'x' * 300, aged(1790000000 + number)) for number in range(1000)))
 	if engine == 'answering':
 		command, typed, expected = ENGINE, 'mssh gp', 'mssh gpu\\[01-16\\] '
 	else:

{multissh3-6.33 → multissh3-6.34}/tests/test_curses_event_loop.py

@@ -727,3 +727,31 @@ def test_curses_print_too_small_keeps_the_keys_typed_for_the_display(stub_curses
 	# the resize redraws; the keys typed meanwhile, the Esc after text among them, come back in their order
 	assert len(displays) == 2 and displays[1][2:] == TOO_SMALL[:6] + ("new config",)
 	assert ungot == [27, ord("y")]
+
+
+def test_hosts_without_a_window_keep_no_lines_to_draw(stub_curses_harness, fake_host, monkeypatch):
+	# a host coming into a window is drawn whole: the lines noted while it had none were never drawn,
+	# and held one entry per line of its output until it came in
+	shown, hidden = _running_host(fake_host), _running_host(fake_host)
+	shown.name, hidden.name = "mock-a", "mock-b"
+	hidden.output = ["line {}".format(number) for number in range(1000)]
+	hidden.lineNumToPrintSet = set(range(1000))
+	polls = []
+
+	def finish_on_second_poll():
+		polls.append(None)
+		if len(polls) == 2:
+			shown.returncode = hidden.returncode = 0
+		return -1
+
+	monkeypatch.setattr(stub_curses_harness.window, "getch", finish_on_second_poll)
+	monkeypatch.setattr(multiSSH3.time, "perf_counter", lambda: 1.0)
+	monkeypatch.setattr(multiSSH3.time, "sleep", lambda seconds: None)
+
+	# room for one host window
+	multiSSH3.__generate_display(stub_curses_harness.window, [shown, hidden], min_char_len=80, min_line_len=20)
+
+	drawn = [arg for window in stub_curses_harness.windows for method, args, kwargs in window.calls
+		for arg in args if method == "addnstr" and isinstance(arg, str)]
+	assert any("mock-a" in text for text in drawn) and not any("mock-b" in text for text in drawn)
+	assert hidden.lineNumToPrintSet == set()

{multissh3-6.33 → multissh3-6.34}/tests/test_expand_hostnames.py

@@ -466,6 +466,21 @@ def test_an_alias_inside_itself_is_the_host_of_that_name(env_aliases, capsys):
 	assert capsys.readouterr().err == ""
 
 
+def test_a_user_typed_with_an_alias_replaces_the_user_a_member_is_written_with(env_aliases, capsys):
+	# root@postgres@db1 made ssh log in to db1 as the user "root@postgres": a failed login on every
+	# such host. Typed on the command line, root wins, as it does over ssh config's User.
+	known = env_aliases('dbs="postgres@db1,db2"\n', dns=["db1", "db2"])
+
+	assert multiSSH3.expand_hostnames(["root@dbs"]) == {"root@db1": known["db1"], "root@db2": known["db2"]}
+	assert multiSSH3.expand_hostnames(["u[1-2]@dbs"]) == {
+		"u1@db1": known["db1"], "u2@db1": known["db1"], "u1@db2": known["db2"], "u2@db2": known["db2"]}
+	assert multiSSH3.expand_hostnames(["dbs"]) == {"postgres@db1": known["db1"], "db2": known["db2"]}
+	# without DNS the same names
+	assert multiSSH3.expand_hostnames_local(["root@dbs"])[0] == ["root@db1", "root@db2"]
+	assert multiSSH3.expand_hostnames_local(["dbs"])[0] == ["db2", "postgres@db1"]
+	assert capsys.readouterr().err == ""
+
+
 def test_alias_values_are_split_like_the_hosts_argument(env_aliases, monkeypatch, capsys):
 	monkeypatch.setattr(multiSSH3, "_no_env", False)
 	monkeypatch.setenv("MSSH_TEST_SPACED", "127.0.0.7 127.0.0.8")

multissh3-6.34/tests/test_stopped_commands.py

@@ -0,0 +1,287 @@
+"""
+-t and Ctrl C stop only mssh's local ssh (or rsync, scp, ...): the remote command gets no signal and
+may run on. -t fires after that many seconds without output. A host mssh stopped says so, and what
+stopping it left; one stopped by Ctrl C is never a success (sshpass exits 0 when interrupted). The
+command sshpass runs gets the SIGINT first, as Ctrl C at a terminal gives it: ssh-copy-id cleans up.
+"""
+import io
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+import threading
+import time
+
+import pytest
+
+import multiSSH3
+
+
+class RunningProc:
+	"""A command that runs until it is terminated."""
+	def __init__(self):
+		# no process: none to look for below it
+		self.pid = None
+		self.stdout = io.BytesIO()
+		self.stderr = io.BytesIO()
+		self.stdin = io.BytesIO()
+		self.returncode = None
+		self.signals = []
+
+	def poll(self):
+		return self.returncode
+
+	def communicate(self, *args, **kwargs):
+		return b"", b""
+
+	def send_signal(self, sig):
+		self.signals.append(sig)
+
+	def terminate(self):
+		self.returncode = -15
+
+
+class EndedProc(RunningProc):
+	"""A command that has already ended when mssh looks."""
+	def __init__(self, returncode, stderr=b""):
+		super().__init__()
+		self.returncode = returncode
+		self.stderr = io.BytesIO(stderr)
+
+
+def _run(fake_host, monkeypatch, proc, timeout=0, passwds=None, ctrl_c=False, **host_kwargs):
+	monkeypatch.setattr(multiSSH3, "_binPaths", {"ssh": "/usr/bin/ssh", "sshpass": "/usr/bin/sshpass", "rsync": "/usr/bin/rsync", "scp": "/usr/bin/scp"})
+	monkeypatch.setattr(multiSSH3, "_emo", False)
+
+	def start(*args, **kwargs):
+		# with ctrl_c, Ctrl C comes once the command runs (one pressed before would keep it from starting)
+		if ctrl_c:
+			multiSSH3._emo = True
+		return proc
+	monkeypatch.setattr(multiSSH3.subprocess, "Popen", start)
+	host = fake_host("mock-a", **host_kwargs)
+	# the command starts at 0 and is silent from then on
+	ticks = iter([0.0, 2.0])
+	monkeypatch.setattr(multiSSH3.time, "monotonic", lambda: next(ticks, 2.0))
+	monkeypatch.setattr(multiSSH3.time, "sleep", lambda seconds: None)
+	multiSSH3.run_command(host, threading.Semaphore(1), timeout, passwds)
+	return host
+
+
+def test_a_timeout_says_the_command_may_still_run_on_the_host(fake_host, monkeypatch):
+	host = _run(fake_host, monkeypatch, RunningProc(), timeout=1, command="sleep 100")
+
+	assert host.returncode == 124
+	assert host.stderr == ["Timeout!", "No output for 1 s, so ssh was stopped: the command may still run on the host."]
+	assert "No output for 1 s, so ssh was stopped: the command may still run on the host." in host.output
+
+
+def test_a_timeout_with_a_password_names_ssh_not_sshpass(fake_host, monkeypatch):
+	host = _run(fake_host, monkeypatch, RunningProc(), timeout=1, passwds="pw", command="sleep 100")
+
+	assert host.stderr[-1] == "No output for 1 s, so ssh was stopped: the command may still run on the host."
+
+
+def test_a_copy_that_timed_out_may_be_incomplete(fake_host, monkeypatch):
+	# scp: a failed rsync may be tried again with scp
+	host = _run(fake_host, monkeypatch, RunningProc(), timeout=1, command="/tmp/dest", files=["/tmp/a"], scp=True)
+
+	assert host.returncode == 124
+	assert host.stderr == ["Timeout!", "No output for 1 s, so scp was stopped: the copy may be incomplete."]
+
+
+def test_ctrl_c_while_the_command_runs(fake_host, monkeypatch):
+	proc = RunningProc()
+
+	host = _run(fake_host, monkeypatch, proc, command="sleep 100", ctrl_c=True)
+
+	assert proc.signals == [multiSSH3.signal.SIGINT]
+	assert host.returncode == 130
+	assert host.stderr == ["Ctrl C detected, Emergency Stop!", "ssh was stopped: the command may still run on the host."]
+
+
+def test_ctrl_c_that_reached_ssh_first(fake_host, monkeypatch):
+	# the terminal's Ctrl C reaches ssh as well as mssh: ssh ends before mssh stops it, saying only
+	# "Killed by signal 2." (hidden)
+
+	host = _run(fake_host, monkeypatch, EndedProc(255, b"Killed by signal 2.\n"), command="sleep 100", ctrl_c=True)
+
+	assert host.returncode == 130
+	assert host.stderr == ["Ctrl C detected, Emergency Stop!", "ssh was stopped: the command may still run on the host."]
+
+
+def test_ctrl_c_with_sshpass_is_not_a_success(fake_host, monkeypatch):
+	# sshpass exits 0 when Ctrl C stops it
+
+	host = _run(fake_host, monkeypatch, EndedProc(0), passwds="pw", command="sleep 100", ctrl_c=True)
+
+	assert host.returncode == 130
+	assert host.stderr[-1] == "ssh was stopped: the command may still run on the host."
+
+
+def test_a_command_that_ends_on_its_own_keeps_its_result(fake_host, monkeypatch):
+	host = _run(fake_host, monkeypatch, EndedProc(3, b"real error\n"), timeout=1, command="false")
+
+	assert host.returncode == 3
+	assert host.stderr == ["real error"]
+
+
+def test_the_timeout_help_says_it_counts_time_without_output():
+	help_text = next(action.help for action in multiSSH3.get_parser()._actions if "--timeout" in action.option_strings)
+
+	assert "without output" in help_text
+	assert "Timeout for each command" not in help_text
+
+
+posix_only = pytest.mark.skipif(os.name != "posix", reason="sessions and terminals are POSIX")
+
+# sshpass 1.10 while ssh has written nothing to sshpass's terminal yet: the command runs as a session
+# leader on a new terminal, and SIGINT or SIGTERM ends sshpass at once, which hangs up that terminal
+FAKE_SSHPASS = """#!{python}
+import os, pty, signal, sys
+pid, master = pty.fork()
+if pid == 0:
+	os.execv(sys.argv[2], sys.argv[2:])
+signal.signal(signal.SIGINT, lambda *_: os._exit(0))
+signal.signal(signal.SIGTERM, lambda *_: os._exit(0))
+while True:
+	try:
+		if not os.read(master, 1024):
+			break
+	except OSError:
+		break
+_, status = os.waitpid(pid, 0)
+sys.exit(status >> 8)
+"""
+
+# ssh-copy-id's scratch directory and the trap that removes it (not on SIGHUP); sleep is ssh connecting
+FAKE_SSH_COPY_ID = """#!/bin/sh
+SCRATCH_DIR=$(mktemp -d ~/.ssh/ssh-copy-id.XXXXXXXXXX)
+trap 'rm -rf "$SCRATCH_DIR"; echo cleaned >> ~/cleaned' EXIT TERM INT QUIT
+sleep 30
+"""
+
+
+def _tool(path, text):
+	path.write_text(text)
+	path.chmod(0o755)
+	return str(path)
+
+
+@pytest.fixture
+def copy_id_that_hangs(monkeypatch, tmp_path):
+	home = tmp_path / "home"
+	(home / ".ssh").mkdir(parents=True)
+	monkeypatch.setenv("HOME", str(home))
+	bins = tmp_path / "bin"
+	bins.mkdir()
+	monkeypatch.setattr(multiSSH3, "_binPaths", {
+		"sh": "/bin/sh",
+		"ssh": str(bins / "ssh"),
+		"sshpass": _tool(bins / "sshpass", FAKE_SSHPASS.format(python=sys.executable)),
+		"ssh-copy-id": _tool(bins / "ssh-copy-id", FAKE_SSH_COPY_ID),
+	})
+	monkeypatch.setattr(multiSSH3, "getIP", lambda hostname, local=False: "127.0.0.1")
+	monkeypatch.setattr(multiSSH3, "_ssh_config_values", lambda hostname: {"proxyjump": "none", "proxycommand": "none"})
+	monkeypatch.setattr(multiSSH3, "_unavailable_hosts_file_path", lambda create=True: str(tmp_path / "unavailable.csv"))
+	monkeypatch.setattr(multiSSH3, "__mainReturnCode", 0)
+	monkeypatch.setattr(multiSSH3, "__failedHosts", set())
+	return home
+
+
+@posix_only
+def test_a_timed_out_ssh_copy_id_under_sshpass_cleans_up_after_itself(copy_id_that_hangs):
+	# sshpass ended at once and hung up ssh-copy-id, whose trap does not cover SIGHUP: every host that
+	# timed out left an empty ~/.ssh/ssh-copy-id.XXXXXXXXXX
+	home = copy_id_that_hangs
+	start = time.monotonic()
+
+	hosts = multiSSH3.run_command_on_hosts(hosts="mock-a", copy_id=True, password="pw", timeout=1,
+		no_watch=True, quiet=True, no_history=True, called=True, will_update_unreachable_hosts=False)
+
+	assert [host.returncode for host in hosts] == [124]
+	deadline = time.monotonic() + 5
+	while not (home / "cleaned").exists() and time.monotonic() < deadline:
+		time.sleep(0.05)
+	assert list((home / ".ssh").glob("ssh-copy-id.*")) == []
+	assert (home / "cleaned").exists()
+	# stopped, not left to sleep out its 30 s
+	assert time.monotonic() - start < 10
+
+
+@posix_only
+def test_ssh_copy_id_under_sshpass_stopped_by_ctrl_c_cleans_up_after_itself(copy_id_that_hangs, monkeypatch):
+	home = copy_id_that_hangs
+	monkeypatch.setattr(multiSSH3, "_emo", False)
+	monkeypatch.setattr(multiSSH3, "_stopping", False)
+	# the first Ctrl C, once ssh-copy-id is waiting for ssh
+	threading.Timer(0.5, lambda: setattr(multiSSH3, "_emo", True)).start()
+
+	hosts = multiSSH3.run_command_on_hosts(hosts="mock-a", copy_id=True, password="pw",
+		no_watch=True, quiet=True, no_history=True, called=True, will_update_unreachable_hosts=False)
+
+	assert [host.returncode for host in hosts] == [130]
+	deadline = time.monotonic() + 5
+	while not (home / "cleaned").exists() and time.monotonic() < deadline:
+		time.sleep(0.05)
+	assert list((home / ".ssh").glob("ssh-copy-id.*")) == []
+
+
+@posix_only
+@pytest.mark.skipif(not shutil.which("pgrep"), reason="pgrep is the fallback")
+def test_child_processes_are_found_without_proc_children_files(monkeypatch):
+	child = subprocess.Popen(["sleep", "30"])
+	try:
+		def no_children_file(path, *args, **kwargs):
+			raise FileNotFoundError(path)
+		monkeypatch.setattr(multiSSH3, "open", no_children_file, raising=False)
+		assert child.pid in multiSSH3._child_pids(os.getpid())
+	finally:
+		child.kill()
+		child.wait()
+
+
+@posix_only
+def test_sessions_below_a_process_are_found(tmp_path):
+	# sh -> python (setsid) -> sleep: the python process leads a session, as sshpass's command does
+	ready = tmp_path / "ready"
+	script = 'import os, time; os.setsid(); open({!r}, "w").close(); time.sleep(30)'.format(str(ready))
+	proc = subprocess.Popen(["/bin/sh", "-c", "{} -c {}; true".format(shlex.quote(sys.executable), shlex.quote(script))])
+	try:
+		deadline = time.monotonic() + 5
+		while not ready.exists() and time.monotonic() < deadline:
+			time.sleep(0.02)
+		leaders = multiSSH3._sessions_below(proc.pid)
+		assert len(leaders) == 1 and leaders[0] != proc.pid
+		assert os.getsid(leaders[0]) == leaders[0]
+	finally:
+		for leader in multiSSH3._sessions_below(proc.pid):
+			os.killpg(leader, 9)
+		proc.kill()
+		proc.wait()
+
+
+def test_a_copy_id_that_timed_out_names_ssh_copy_id(monkeypatch):
+	# --copy_id runs sshpass in an sh -c line: the note named sh. Stopped, ssh-copy-id cleans up and goes
+	# on, saying "All keys were skipped because they already exist on the remote system."
+	monkeypatch.setattr(multiSSH3, "_binPaths", {"sh": "/bin/sh", "sshpass": "/usr/bin/sshpass", "ssh-copy-id": "/usr/bin/ssh-copy-id"})
+	line = ["/bin/sh", "-c", "/usr/bin/sshpass -e /usr/bin/ssh-copy-id -o ConnectTimeout=30 bob@mock-a"]
+
+	assert multiSSH3._stopped_command_note(line) == "ssh-copy-id was stopped: the key may not be installed"
+
+
+@posix_only
+def test_no_session_is_looked_for_below_init_or_no_process():
+	# pgrep -P 0 lists init: its group must never get mssh's SIGINT
+	assert multiSSH3._sessions_below(0) == []
+	assert multiSSH3._sessions_below(1) == []
+	assert multiSSH3._sessions_below(None) == []
+
+
+def test_a_timed_out_ssh_found_under_another_name_is_still_ssh(monkeypatch):
+	# Windows finds ssh as ...\ssh.EXE: mssh knows it by the path it found
+	monkeypatch.setattr(multiSSH3, "_binPaths", {"ssh": "/opt/openssh/ssh.EXE", "scp": "/opt/openssh/scp.EXE"})
+
+	assert multiSSH3._stopped_command_note(["/opt/openssh/ssh.EXE", "mock-a", "uptime"]) == "ssh was stopped: the command may still run on the host"
+	assert multiSSH3._stopped_command_note(["/opt/openssh/scp.EXE", "a", "mock-a:b"]) == "scp was stopped: the copy may be incomplete"

multissh3-6.33/tests/test_stopped_commands.py

@@ -1,123 +0,0 @@
-"""
--t and Ctrl C stop only mssh's local ssh (or rsync, scp, ...): the remote command gets no signal and
-may run on. -t fires after that many seconds without output. A host mssh stopped says so, and what
-stopping it left; one stopped by Ctrl C is never a success (sshpass exits 0 when interrupted).
-"""
-import io
-import threading
-
-import multiSSH3
-
-
-class RunningProc:
-	"""A command that runs until it is terminated."""
-	def __init__(self):
-		self.stdout = io.BytesIO()
-		self.stderr = io.BytesIO()
-		self.stdin = io.BytesIO()
-		self.returncode = None
-		self.signals = []
-
-	def poll(self):
-		return self.returncode
-
-	def communicate(self, *args, **kwargs):
-		return b"", b""
-
-	def send_signal(self, sig):
-		self.signals.append(sig)
-
-	def terminate(self):
-		self.returncode = -15
-
-
-class EndedProc(RunningProc):
-	"""A command that has already ended when mssh looks."""
-	def __init__(self, returncode, stderr=b""):
-		super().__init__()
-		self.returncode = returncode
-		self.stderr = io.BytesIO(stderr)
-
-
-def _run(fake_host, monkeypatch, proc, timeout=0, passwds=None, ctrl_c=False, **host_kwargs):
-	monkeypatch.setattr(multiSSH3, "_binPaths", {"ssh": "/usr/bin/ssh", "sshpass": "/usr/bin/sshpass", "rsync": "/usr/bin/rsync", "scp": "/usr/bin/scp"})
-	monkeypatch.setattr(multiSSH3, "_emo", False)
-
-	def start(*args, **kwargs):
-		# with ctrl_c, Ctrl C comes once the command runs (one pressed before would keep it from starting)
-		if ctrl_c:
-			multiSSH3._emo = True
-		return proc
-	monkeypatch.setattr(multiSSH3.subprocess, "Popen", start)
-	host = fake_host("mock-a", **host_kwargs)
-	# the command starts at 0 and is silent from then on
-	ticks = iter([0.0, 2.0])
-	monkeypatch.setattr(multiSSH3.time, "monotonic", lambda: next(ticks, 2.0))
-	monkeypatch.setattr(multiSSH3.time, "sleep", lambda seconds: None)
-	multiSSH3.run_command(host, threading.Semaphore(1), timeout, passwds)
-	return host
-
-
-def test_a_timeout_says_the_command_may_still_run_on_the_host(fake_host, monkeypatch):
-	host = _run(fake_host, monkeypatch, RunningProc(), timeout=1, command="sleep 100")
-
-	assert host.returncode == 124
-	assert host.stderr == ["Timeout!", "No output for 1 s, so ssh was stopped: the command may still run on the host."]
-	assert "No output for 1 s, so ssh was stopped: the command may still run on the host." in host.output
-
-
-def test_a_timeout_with_a_password_names_ssh_not_sshpass(fake_host, monkeypatch):
-	host = _run(fake_host, monkeypatch, RunningProc(), timeout=1, passwds="pw", command="sleep 100")
-
-	assert host.stderr[-1] == "No output for 1 s, so ssh was stopped: the command may still run on the host."
-
-
-def test_a_copy_that_timed_out_may_be_incomplete(fake_host, monkeypatch):
-	# scp: a failed rsync may be tried again with scp
-	host = _run(fake_host, monkeypatch, RunningProc(), timeout=1, command="/tmp/dest", files=["/tmp/a"], scp=True)
-
-	assert host.returncode == 124
-	assert host.stderr == ["Timeout!", "No output for 1 s, so scp was stopped: the copy may be incomplete."]
-
-
-def test_ctrl_c_while_the_command_runs(fake_host, monkeypatch):
-	proc = RunningProc()
-
-	host = _run(fake_host, monkeypatch, proc, command="sleep 100", ctrl_c=True)
-
-	assert proc.signals == [multiSSH3.signal.SIGINT]
-	assert host.returncode == 130
-	assert host.stderr == ["Ctrl C detected, Emergency Stop!", "ssh was stopped: the command may still run on the host."]
-
-
-def test_ctrl_c_that_reached_ssh_first(fake_host, monkeypatch):
-	# the terminal's Ctrl C reaches ssh as well as mssh: ssh ends before mssh stops it, saying only
-	# "Killed by signal 2." (hidden)
-
-	host = _run(fake_host, monkeypatch, EndedProc(255, b"Killed by signal 2.\n"), command="sleep 100", ctrl_c=True)
-
-	assert host.returncode == 130
-	assert host.stderr == ["Ctrl C detected, Emergency Stop!", "ssh was stopped: the command may still run on the host."]
-
-
-def test_ctrl_c_with_sshpass_is_not_a_success(fake_host, monkeypatch):
-	# sshpass exits 0 when Ctrl C stops it
-
-	host = _run(fake_host, monkeypatch, EndedProc(0), passwds="pw", command="sleep 100", ctrl_c=True)
-
-	assert host.returncode == 130
-	assert host.stderr[-1] == "ssh was stopped: the command may still run on the host."
-
-
-def test_a_command_that_ends_on_its_own_keeps_its_result(fake_host, monkeypatch):
-	host = _run(fake_host, monkeypatch, EndedProc(3, b"real error\n"), timeout=1, command="false")
-
-	assert host.returncode == 3
-	assert host.stderr == ["real error"]
-
-
-def test_the_timeout_help_says_it_counts_time_without_output():
-	help_text = next(action.help for action in multiSSH3.get_parser()._actions if "--timeout" in action.option_strings)
-
-	assert "without output" in help_text
-	assert "Timeout for each command" not in help_text