ssm-cli 1.0.0.dev0__tar.gz → 1.0.0.dev3__tar.gz

{ssm_cli-1.0.0.dev0/ssm_cli.egg-info → ssm_cli-1.0.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssm-cli
-Version: 1.0.0.dev0
+Version: 1.0.0.dev3
 Summary: CLI tool to help with SSM functionality, aimed at adminstrators
 Author-email: Simon Fletcher <simon.fletcher@lexisnexisrisk.com>
 License: MIT License

{ssm_cli-1.0.0.dev0 → ssm_cli-1.0.0.dev3}/ssm_cli/cli.py

@@ -1,7 +1,6 @@
 import sys
 import logging
 
-from rich_argparse import ArgumentDefaultsRichHelpFormatter
 
 import confclasses
 from ssm_cli.config import CONFIG
@@ -31,13 +30,7 @@ def cli(argv: list = None) -> int:
 
     logger.debug(f"CLI called with {argv}")
 
-    # Build the actual parser
-    parser = CliArgumentParser(
-        prog="ssm",
-        description="tool to manage AWS SSM",
-        formatter_class=ArgumentDefaultsRichHelpFormatter,
-    )
-    parser.add_global_argument("--profile", type=str, help="Which AWS profile to use")
+    parser = CliArgumentParser()
 
     for name, command in COMMANDS.items():
         command_parser = parser.add_command_parser(name, command.HELP)

{ssm_cli-1.0.0.dev0 → ssm_cli-1.0.0.dev3}/ssm_cli/cli_args.py

@@ -2,12 +2,15 @@ import argparse
 import sys
 from confclasses import fields, is_confclass
 from ssm_cli.config import CONFIG
+from rich_argparse import ArgumentDefaultsRichHelpFormatter
 import os
 
 # The long term aim is to move this module into the config module and "bind" config to cli arguments
 # This will need a rethink of where some of the arguments/config come from because right now they are in the commands modules
 
 class CliNamespace(argparse.Namespace):
+    global_args: "CliNamespace"
+
     def update_config(self):
         self._do_update_config(CONFIG, vars(self.global_args))
     
@@ -28,19 +31,20 @@ class CliNamespace(argparse.Namespace):
 ARGS = CliNamespace()
 
 class CliArgumentParser(argparse.ArgumentParser):
-    def __init__(self, *args, help_as_global=True, **kwargs):
+    def __init__(self):
         self.global_args_parser = argparse.ArgumentParser(add_help=False)
         self.global_args_parser_group = self.global_args_parser.add_argument_group("Global Options")
-        
-        self.help_as_global = help_as_global
-        if help_as_global:
-            kwargs['add_help'] = False
-            # we cannot use help action here because it will just return the global arguments
-            self.global_args_parser_group.add_argument('--help', '-h', action="store_true", help="show this help message and exit")
-
+        self.global_args_parser_group.add_argument("--profile", type=str, help="Which AWS profile to use")
+        self.global_args_parser_group.add_argument('--help', '-h', action="store_true", help="show this help message and exit")
         self.global_args_parser_group.add_argument('--version', '-v', action=VersionAction)
 
-        super().__init__(*args, **kwargs)
+        super().__init__(
+            prog="ssm",
+            description="tool to manage AWS SSM",
+            formatter_class=ArgumentDefaultsRichHelpFormatter,
+            add_help=False
+        )
+        
         self._command_subparsers = self.add_subparsers(title="Commands", dest="command", metavar="<command>", parser_class=argparse.ArgumentParser)
         self._command_subparsers_map = {}
 
@@ -57,12 +61,13 @@ class CliArgumentParser(argparse.ArgumentParser):
 
         if argv is None:
             argv = sys.argv[1:]
+
         global_args, unknown = self.global_args_parser.parse_known_args(argv, CliNamespace())
         
         super().parse_args(unknown, ARGS)
         ARGS.global_args = global_args
 
-        if self.help_as_global and global_args.help:
+        if global_args.help:
             if ARGS.command and ARGS.command in self._command_subparsers_map:
                 self._command_subparsers_map[ARGS.command].print_help()
                 self.exit()
@@ -77,12 +82,9 @@ class CliArgumentParser(argparse.ArgumentParser):
             delattr(global_args, 'help')
         
         return ARGS
-
-    def add_global_argument(self, *args, **kwargs):
-        self.global_args_parser_group.add_argument(*args, **kwargs)
     
     def add_command_parser(self, name, help):
-        parser = self._command_subparsers.add_parser(name, help=help, formatter_class=self.formatter_class, parents=[self.global_args_parser], add_help=not self.help_as_global)
+        parser = self._command_subparsers.add_parser(name, help=help, formatter_class=self.formatter_class, parents=[self.global_args_parser], add_help=False)
         self._command_subparsers_map[name] = parser
         return parser
 

ssm_cli-1.0.0.dev3/ssm_cli/commands/ssh_proxy/forwarding.py

@@ -0,0 +1,290 @@
+r"""
+This module is split into 2 parts, the proxy side and the manager side.
+
+The proxy side is the code that runs in the main process along side the ssh server, it is responsible for handling all the requests for port forwarding and starting the manager process.
+
+The manager side is the code that runs in a separate process and is responsible for starting and stopping the session-manager-plugin processes, including the clean up if things end unexpectedly.
+
+[ssh server] <--> [PortForwardingSession] <--> [PortForwardingSessionProcess] <--> [session-manager-plugin]
+    [ssh server] --> [PortForwardingSession] will send commands to us across many threads
+    [PortForwardingSession] --> [manager] is a pipe for ipc
+    [proxy] --> [session-manager-plugin] is a local socket on internal_port
+    [manager] <-/-> [session-manager-plugin] doesnt connect to session-manager-plugin, it just starts and stops them
+    [manager] --> [proxy] monitors the pipe and the process to see if cleanup is needed
+
+"""
+
+import socket
+from typing import Dict, Any, List
+import time
+import subprocess
+import multiprocessing
+import threading
+from multiprocessing.connection import PipeConnection
+
+from ssm_cli.aws import aws_client
+from ssm_cli.cli_args import ARGS
+from ssm_cli.config import CONFIG
+from ssm_cli.instances import Instance, SessionManagerPluginError, SessionManagerPluginPortError
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+#######
+# Proxy Side
+# Names should reflect both sides
+#######
+
+class PortForwardingSession():
+    """
+    This is the object that the user will interact with
+    """
+    def __init__(self, manager: "PortForwarding", session_id: str, internal_port: int):
+        self.manager = manager
+        self.session_id = session_id
+        self.internal_port = internal_port
+
+    def is_open(self):
+        return self.manager.is_open(self)
+    
+    def close(self):
+        self.manager.close_session(self)
+
+class PortForwarding():
+    """
+    Starts the manager process and creates the session objects.
+    """
+    session_cache: Dict[tuple, PortForwardingSession] # (host, port) -> session
+    instance: Instance
+    proxy_pipe: PipeConnection
+    pipe_lock: threading.Lock
+    manager_process: multiprocessing.Process
+
+    def __init__(self, instance):
+        self.session_cache = {}
+        self.instance = instance
+    
+    def start(self):
+        logger.debug("starting manager process")
+        self.proxy_pipe, manager_pipe = multiprocessing.Pipe()
+        self.manager_process = PortForwardingManagerProcess(manager_pipe, self.instance)
+        self.manager_process.start()
+
+        logger.debug("waiting for manager process to start")
+        self.pipe_lock = threading.Lock()
+        ready = self.recv()
+        if ready != "ready":
+            logger.error(f"manager process failed to start: 'ready' != '{ready}'")
+            self.manager_process.terminate()
+            self.proxy_pipe.close()
+            raise Exception("Manager process failed to start")
+
+    def open_session(self, host: str, remote_port: int) -> PortForwardingSession:
+        session = self.session_cache.get((host, remote_port))
+        if session is not None:
+            if self.is_open(session):
+                logger.debug(f"{session.session_id} still running, reusing")
+                return session
+            else:
+                logger.debug(f"{session.session_id} closed, opening new one")
+                del self.session_cache[(host, remote_port)]
+
+        session_id, internal_port = self.send_recv(("open_session", (host, remote_port)))
+        session = PortForwardingSession(self, session_id, internal_port)
+        self.session_cache[(host, remote_port)] = session
+        return session
+    
+    def close_session(self, session: PortForwardingSession):
+        self.proxy_pipe.send(("close_session", session.session_id))
+        del self.session_cache[(session.host, session.remote_port)]
+
+    def is_open(self, session: PortForwardingSession):
+        return self.send_recv(("is_open", session.session_id))
+
+    def is_alive(self):
+        return self.manager_process.is_alive()
+    
+    def send(self, obj: Any):
+        if not self.is_alive():
+            raise Exception("Manager process has ended")
+        with self.pipe_lock:
+            logger.debug(f"sending {obj} to manager")
+            self.proxy_pipe.send(obj)
+    
+    def recv(self) -> Any:
+        if not self.is_alive():
+            raise Exception("Manager process has ended")
+        with self.pipe_lock:
+            result = self.proxy_pipe.recv()
+            logger.debug(f"received {result} from manager")
+            return result
+        
+    def send_recv(self, obj: Any) -> Any:
+        if not self.is_alive():
+            raise Exception("Manager process has ended")
+        with self.pipe_lock:
+            logger.debug(f"sending {obj} to manager")
+            self.proxy_pipe.send(obj)
+            result = self.proxy_pipe.recv()
+            logger.debug(f"received {result} from manager")
+            return result
+
+#######
+# Manager Side
+# class suffix should be Process
+#######
+
+class PortForwardingSessionProcess():
+    """
+    Exposes open/close methods for the sessions, this will send messages to the manager process to do the actual work.
+    """
+    _open: bool = False
+    host: str
+    remote_port: int
+    internal_port: int
+    session_id: str
+    proc: subprocess.Popen
+    instance: Instance
+
+    def __init__(self, host: str, remote_port: int, instance: Instance):
+        self.host = host
+        self.remote_port = remote_port
+        self.instance = instance
+
+    def open(self):
+        # Retry because of rare race condition from get_free_port
+        for attempt in range(3):
+            try:
+                self.internal_port = get_free_port()
+                logger.debug(f"getting session for localhost:{self.internal_port} to {self.host}:{self.remote_port} over {self.instance.id} from aws")
+                session_id, proc = self.instance.start_port_forwarding_session_to_remote_host(self.host, self.remote_port, self.internal_port)
+                self.session_id = session_id
+                self.proc = proc
+                self._open = True
+                logger.info(f"{self.session_id} opened to {self.host}:{self.remote_port} on 127.0.0.1:{self.internal_port}, pid {self.proc.pid}")
+                return
+            except SessionManagerPluginPortError as e:
+                logger.warning(f"session-manager-plugin attempt {attempt} failed due to port clash, retrying: {e}")
+                time.sleep(0.1)
+
+        logger.error(f"session-manager-plugin failed to open session to {self.host}:{self.remote_port} after {attempt} attempts")
+        raise SessionManagerPluginError("Max retries hit") from e
+    
+    def close(self):
+        logger.info(f"{self.session_id} closing")
+        self._open = False
+        try:
+            logger.debug(f"{self.session_id} killing process {self.proc.pid}")
+            self.proc.terminate()
+            self.proc.wait()
+        except Exception as e:
+            logger.error(f"{self.session_id} failed to kill process: {e}")
+
+        try:
+            logger.debug(f"{self.session_id} terminating session")
+            with aws_client('ssm') as client:
+                client.terminate_session(SessionId=self.session_id)
+        except Exception as e:
+            logger.error(f"{self.session_id} to terminate session: {e}")
+
+    def is_open(self):
+        if self.proc.poll() is not None:
+            logger.debug(f"process for {self.host}:{self.remote_port} has exited, restarting")
+            self._open = False
+        # the process ends when aws terminates the session, no need to check that
+        return self._open
+
+
+class PortForwardingManagerProcess(multiprocessing.Process):
+    """
+    This is the process that will run the manager code, it is responsible for starting and stopping the session-manager-plugin processes.
+    As well as monitoring the proxy side and cleaning up.
+
+    This runs in a single thread, no need for all the locking and threading like the other class.
+    """
+
+    sessions: List[PortForwardingSessionProcess]
+    def __init__(self, pipe: PipeConnection, instance: Instance):
+        self.pipe = pipe
+        self.instance = instance
+        self.log_level = CONFIG.log.level
+        self.log_loggers = CONFIG.log.loggers
+        self.profile = ARGS.global_args.profile
+        super().__init__()
+    
+    def run(self):
+        # Rebuild some global state that ssm_cli.cli normally deals with, the manager process is a clean slate,
+        # We can be selective about what we rebuild
+        # when config/args are refactored, this should be taken into account.
+        from ssm_cli.logging import setup_logging, configure_log_level
+        setup_logging("manager")
+        configure_log_level(self.log_level)
+        for logger_name, level in self.log_loggers.items():
+            configure_log_level(level, name=logger_name)
+        
+        from ssm_cli.cli_args import ARGS, CliNamespace
+        ARGS.global_args = CliNamespace(profile=self.profile)
+        self.sessions = []
+        self.pipe.send("ready")
+        while True:
+            try:
+                msg, data = self.pipe.recv()
+                logger.debug(f"received {msg} {data} from proxy")
+                reply = None
+                if msg == "open_session":
+                    reply = self.open_session(*data)
+                elif msg == "close_session":
+                    self.close_session(data)
+                elif msg == "is_open":
+                    reply = self.is_open(data)
+                
+                if reply is not None:
+                    logger.debug(f"sending {reply} to proxy")
+                    self.pipe.send(reply)
+            except EOFError:
+                break
+
+    def open_session(self, host: str, remote_port: int):
+        session = None
+        for s in self.sessions:
+            if s.host == host and s.remote_port == remote_port:
+                logger.debug(f"{s.session_id} in cache for {host}:{remote_port}")
+                if s.is_open():
+                    logger.debug(f"{s.session_id} still running, reusing")
+                    return s
+                else:
+                    logger.debug(f"{s.session_id} closed, removing from cache")
+                    self.sessions.remove(s)
+
+        session = PortForwardingSessionProcess(host, remote_port, self.instance)
+        session.open()
+        self.sessions.append(session)
+        return session.session_id, session.internal_port
+    
+    def close_session(self, session_id: str):
+        for session in self.sessions:
+            if session.session_id == session_id:
+                session.close()
+                self.sessions.remove(session)
+
+    def is_open(self, session_id: str) -> bool:
+        for session in self.sessions:
+            if session.session_id == session_id:
+                if session.is_open():
+                    return True
+                else:
+                    self.sessions.remove(session)
+                    break
+        return False
+
+def get_free_port(bind_host="127.0.0.1"):
+    """
+    Ask OS for an ephemeral free port. Returns the port number, however it is not guaranteed that the port will remain free. A retry should be used.
+    """
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    s.bind((bind_host, 0))
+    port = s.getsockname()[1]
+    s.close()
+    return port

{ssm_cli-1.0.0.dev0 → ssm_cli-1.0.0.dev3}/ssm_cli/commands/ssh_proxy/server.py

@@ -8,8 +8,9 @@ import select
 from ssm_cli.commands.ssh_proxy.socket import StdIoSocket
 from ssm_cli.commands.ssh_proxy.shell import ShellThread
 from ssm_cli.commands.ssh_proxy.channels import Channels
+from ssm_cli.commands.ssh_proxy.forwarding import PortForwarding, PortForwardingSession
 from ssm_cli.xdg import get_ssh_hostkey
-from ssm_cli.instances import Instance, SessionManagerPluginError, SessionManagerPluginPortError
+from ssm_cli.instances import Instance
 
 import logging
 logger = logging.getLogger(__name__)
@@ -20,16 +21,16 @@ class SshServer(paramiko.ServerInterface):
     """
     event: threading.Event
     instance: Instance
-    connections: Dict[tuple, tuple] # (host, port) -> (internal_port, session)
     channels: Channels
     transport: paramiko.Transport
+    port_forwarding_manager: PortForwarding
     
     def __init__(self, instance: Instance):
         logger.debug("creating server")
         self.event = threading.Event()
         self.instance = instance
-        self.connections = {}
-    
+        self.port_forwarding_manager = PortForwarding(instance)
+
     def start(self):
         logger.info("starting server")
 
@@ -40,8 +41,9 @@ class SshServer(paramiko.ServerInterface):
         key_path = get_ssh_hostkey()
         host_key = paramiko.RSAKey(filename=key_path)
         logger.info("Loaded existing host key")
-        
         self.transport.add_server_key(host_key)
+
+        self.port_forwarding_manager.start()
         self.transport.start_server(server=self)
 
         self.event.wait()
@@ -83,53 +85,33 @@ class SshServer(paramiko.ServerInterface):
         logger.info(f"direct TCP/IP request: chan={chanid} origin={origin} destination={destination}")
         host = destination[0]
         remote_port = destination[1]
-
-        internal_port, session = None, None
-
-        if (host, remote_port) in self.connections:
-            internal_port, session = self.connections[(host, remote_port)]
-            if session.proc.poll() is not None:
-                logger.debug(f"process for {host}:{remote_port} has exited, restarting")
-                del self.connections[(host, remote_port)]
-                internal_port, session = None, None
-            else:
-                logger.debug(f"reusing existing connection to {host}:{remote_port} with internal port {internal_port} and process {session.proc.pid}")
         
-        if internal_port is None:
-            # Retry because of rare race condition from get_free_port
-            for attempt in range(3):
-                try:
-                    internal_port = get_free_port()
-                    session = self.instance.start_port_forwarding_session_to_remote_host(host, remote_port, internal_port)
-                    self.connections[(host, remote_port)] = (internal_port, session)
-                    break
-                except SessionManagerPluginPortError as e:
-                    logger.warning(f"session-manager-plugin attempt {attempt} failed due to port clash, retrying: {e}")
-                    time.sleep(0.1)
-                except SessionManagerPluginError as e:
-                    logger.error(f"session-manager-plugin failed: {e}")
-                    return paramiko.OPEN_FAILED_CONNECT_FAILED
-
-        logger.debug(f"connecting to session manager plugin on 127.0.0.1:{internal_port}")
+        try:
+            session = self.port_forwarding_manager.open_session(host, remote_port)
+        except Exception as e:
+            logger.error(f"failed to connect: {e}")
+            return paramiko.OPEN_FAILED_CONNECT_FAILED
+        
+        logger.debug(f"connecting to session manager plugin on 127.0.0.1:{session.internal_port}")
         # Even though we wait for the process to say its connected, we STILL need to wait for it
         for attempt in range(10):
             try:
-                if session.proc.poll() is not None:
-                    logger.error(f"session-manager-plugin has exited")
-                    raise RuntimeError("session-manager-plugin has exited")
-                sock = socket.create_connection(('127.0.0.1', internal_port))
-                logger.info(f"connected to 127.0.0.1:{internal_port}")
+                sock = socket.create_connection(('127.0.0.1', session.internal_port))
+                logger.info(f"connected to 127.0.0.1:{session.internal_port}")
                 break
             except Exception as e:
                 logger.warning(f"connection attempt {attempt} failed: {e}")
                 time.sleep(0.1)
-        
-        if not sock:
+                if not session.is_open():
+                    logger.error(f"session is closed")
+                    return paramiko.OPEN_FAILED_CONNECT_FAILED
+        else:
             logger.error("max retries reached, giving up")
             return paramiko.OPEN_FAILED_CONNECT_FAILED
         
 
         chunk_size = 1024
+
         # Start thread to open the channel and forward data
         def forwarding_thread():
             logger.info(f"starting forward thread chan={chanid}")
@@ -148,9 +130,9 @@ class SshServer(paramiko.ServerInterface):
                     if len(data) == 0:
                         break
                     sock.send(data)
-                  
-            del session
-            logger.info(f"forward thread chan={self.chanid} exiting")
+   
+            session.close()
+            logger.info(f"forward thread chan={chanid} exiting")
         
         t = threading.Thread(target=forwarding_thread)
         t.start()
@@ -160,15 +142,3 @@ class SshServer(paramiko.ServerInterface):
     
     def get_banner(self):
         return ("SSM CLI - SSH server\r\n", "en-US")
-
-
-def get_free_port(bind_host="127.0.0.1"):
-    """
-    Ask OS for an ephemeral free port. Returns the port number, however it is not guaranteed that the port will remain free. A retry should be used.
-    """
-    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    s.bind((bind_host, 0))
-    port = s.getsockname()[1]
-    s.close()
-    return port

{ssm_cli-1.0.0.dev0 → ssm_cli-1.0.0.dev3}/ssm_cli/config.py

@@ -15,7 +15,8 @@ class ActionsConfig:
 class LoggingConfig:
     level: str = "info"
     loggers: Dict[str, str] = {
-        "botocore": "warn"
+        "botocore": "warn",
+        "paramiko": "warn"
     }
     """key value dictionary to override log level on, some modules make a lot of noise, botocore for example"""
 

{ssm_cli-1.0.0.dev0 → ssm_cli-1.0.0.dev3}/ssm_cli/instances.py

@@ -4,7 +4,7 @@ import re
 import signal
 import subprocess
 import sys
-from typing import List
+from typing import List, Tuple
 
 from ssm_cli.selectors import SELECTORS
 from ssm_cli.config import CONFIG
@@ -17,7 +17,7 @@ class SessionManagerPluginError(Exception):
     """ A generic exception for any AWS errors """
     stdout = []
     returncode = 0
-    def __init__(self, message, stdout, returncode):
+    def __init__(self, message, stdout = None, returncode = None):
         super().__init__(message)
         self.stdout = stdout
         self.returncode = returncode
@@ -29,27 +29,6 @@ class SessionManagerPluginPortError(SessionManagerPluginError):
     """ A specific exception for a timeout error """
     pass
 
-
-class SessionManagerSession:
-    """ A class to manage an SSM session, helps with cleanup """
-    def __init__(self, session_id: str, proc: subprocess.Popen):
-        self.session_id = session_id
-        self.proc = proc
-    
-    def __del__(self):
-        logger.info(f"cleaning up session {self.session_id}")
-        try:
-            self.proc.terminate()
-            self.proc.wait()
-        except Exception as e:
-            logger.error(f"Failed to cleanup process {self.session_id} but continuing anyway: {e}")
-        try:
-            with aws_client('ssm') as client:
-                client.terminate_session(SessionId=self.session_id)
-        except Exception as e:
-            logger.error(f"Failed to cleanup session {self.session_id} but continuing anyway: {e}")
-
-
 class Instance:
     """
     Contains information about an EC2 instance and methods to handle sessions with them.
@@ -89,7 +68,18 @@ class Instance:
                 logger.error(f"Failed to connect to session: {result.stderr.decode()}")
                 raise RuntimeError(f"Failed to connect to session: {result.stderr.decode()}")
         
-    def start_port_forwarding_session_to_remote_host(self, host: str, remote_port: int, internal_port: int) -> SessionManagerSession:
+    def start_port_forwarding_session_to_remote_host(self, host: str, remote_port: int, internal_port: int) -> Tuple[str, subprocess.Popen]:
+        """
+        Start a port forwarding session to a remote host.
+
+        Args:
+            host: The remote host to forward to.
+            remote_port: The remote port to forward to.
+            internal_port: The local port use for forwarding.
+        
+        Returns:
+            A tuple containing the session id and the subprocess.
+        """
         logger.debug(f"start port forwarding between localhost:{internal_port} and {host}:{remote_port} via {self.id}")
         with aws_session(False) as session:
             client = session.client('ssm') # we need a fresh connection where session is the same as the client
@@ -124,18 +114,18 @@ class Instance:
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT
             )
-            session = SessionManagerSession(response["SessionId"], proc)
 
             # changes needed here:
-            # SessionManagerPluginPortError needs to be raised correctly
+            # SessionManagerPluginPortError needs to be raised when it applies
             # add a timeout for waiting on stdout
             # maybe split up stdout/stderr?
+            # validate the port in stdout matches the internal port
             output = b''
             for line in proc.stdout:
                 line = line.strip()
                 output += line + b'\n'
                 if line == b'Waiting for connections...':
-                    return session
+                    return (response["SessionId"], proc)
                 else:
                     logger.debug(f"Recieved from session-manager-plugin: {line}")
             

{ssm_cli-1.0.0.dev0 → ssm_cli-1.0.0.dev3}/ssm_cli/logging.py

@@ -5,11 +5,11 @@ from typing import Optional
 from ssm_cli.xdg import get_log_file, get_all_log_files
 
 
-def setup_logging():
+def setup_logging(name:str = "cli"):
     """Set up basic logging configuration with date-based rotation."""
     logging.basicConfig(
         level=logging.WARNING,
-        filename=get_log_file(),
+        filename=get_log_file(name),
         filemode='a',
         format='%(asctime)s - %(process)d [%(threadName)s] - %(name)s - %(levelname)s - %(message)s',
         datefmt='%Y-%m-%d %H:%M:%S'

{ssm_cli-1.0.0.dev0 → ssm_cli-1.0.0.dev3}/ssm_cli/xdg.py

@@ -26,15 +26,13 @@ def get_conf_file(check=True) -> Path:
         raise EnvironmentError(f"{path} missing, run `ssm setup` to create")
     return path
 
-def get_log_file(date: Optional[datetime] = None) -> Path:
-    if date is None:
-        date = datetime.now()
-    date_str = date.strftime('%Y-%m-%d')
-    path = get_state_root() / f"run.{date_str}.log"
+def get_log_file(name="cli") -> Path:
+    date_str = datetime.now().strftime('%Y-%m-%d')
+    path = get_state_root() / f"ssm-{name}.{date_str}.log"
     return path
 
 def get_all_log_files() -> str:
-    return get_state_root().glob('run.*.log')
+    return get_state_root().glob('ssm-*.*.log')
 
 def get_ssh_hostkey(check=True) -> Path:
     path = get_conf_root(check) / 'hostkey.pem'

{ssm_cli-1.0.0.dev0 → ssm_cli-1.0.0.dev3/ssm_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssm-cli
-Version: 1.0.0.dev0
+Version: 1.0.0.dev3
 Summary: CLI tool to help with SSM functionality, aimed at adminstrators
 Author-email: Simon Fletcher <simon.fletcher@lexisnexisrisk.com>
 License: MIT License

{ssm_cli-1.0.0.dev0 → ssm_cli-1.0.0.dev3}/ssm_cli.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ ssm_cli/commands/setup.py
 ssm_cli/commands/shell.py
 ssm_cli/commands/ssh_proxy/__init__.py
 ssm_cli/commands/ssh_proxy/channels.py
+ssm_cli/commands/ssh_proxy/forwarding.py
 ssm_cli/commands/ssh_proxy/server.py
 ssm_cli/commands/ssh_proxy/shell.py
 ssm_cli/commands/ssh_proxy/socket.py