prim-ctrl 0.8.0__tar.gz → 0.8.2__tar.gz

{prim_ctrl-0.8.0 → prim_ctrl-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prim-ctrl
-Version: 0.8.0
+Version: 0.8.2
 Summary: Primitive Ctrl - Remote control of your phone's Primitive FTPd Android SFTP server and optionally Tailscale VPN.
 License-Expression: Apache-2.0
 License-File: LICENSE

{prim_ctrl-0.8.0 → prim_ctrl-0.8.2}/prim_ctrl/__main__.py

@@ -37,7 +37,7 @@ class LevelFormatter(logging.Formatter):
 
     def __init__(self, fmts: dict[int, str], fmt: str, **kwargs):
         super().__init__()
-        self.formatters = dict({level: logging.Formatter(fmt, **kwargs) for level, fmt in fmts.items()})
+        self.formatters = {level: logging.Formatter(fmt, **kwargs) for level, fmt in fmts.items()}
         self.default_formatter = logging.Formatter(fmt, **kwargs)
 
     def format(self, record: logging.LogRecord) -> str:
@@ -132,7 +132,7 @@ class SignalFence():
         if self.on_deferred_signal is not None:
             try:
                 self.on_deferred_signal(signum, frame)
-            except:
+            except: # NOSONAR(S5754)
                 pass
 
     def disable(self) -> None:
@@ -151,11 +151,11 @@ class SignalFence():
                 self.deferred_signal = None
                 logger.debug("Handling deferred signal %d", self.signum)
                 if isinstance(self.original_handler, signal.Handlers):
-                    if self.original_handler is signal.Handlers.SIG_IGN:
-                        pass
-                    elif self.original_handler is signal.Handlers.SIG_DFL:
+                    if self.original_handler == signal.Handlers.SIG_DFL:
                         signal.signal(self.signum, signal.SIG_DFL)
                         os.kill(os.getpid(), self.signum)
+                    # elif self.original_handler == signal.Handlers.SIG_IGN:
+                    #     pass
                 elif callable(self.original_handler):
                     self.original_handler(*deferred_signal)
 
@@ -193,7 +193,7 @@ class Subprocess:
     #         return result.returncode == 0
 
     @staticmethod
-    async def ping(host, packets: int = 1, timeout: float = 1):
+    async def ping(host, packets: int = 1, timeout: float = 1): # NOSONAR(S7483)
         if platform.system().lower() == 'windows':
             command = ['ping', '-n', str(packets), '-w', str(int(timeout*1000)), host]
             # don't use text=True, the async version will raise ValueError("text must be False"), who knows why
@@ -214,7 +214,7 @@ class Subprocess:
         try:
             proc = await asyncio.create_subprocess_exec(*command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE, creationflags=creationflags)
         except FileNotFoundError as e:
-            e.add_note(f"Please check that Tailscale is installed properly")
+            e.add_note("Please check that Tailscale is installed properly")
             raise
         stdout, stderr = await proc.communicate()
         return proc.returncode == 0, stdout.decode(), stderr.decode()
@@ -225,12 +225,10 @@ class Subprocess:
 # Note: aiohttp's AsyncResolver can't be used when asyncio.create_subprocess_exec is used
 #       aiohttp's AsyncResolver uses aiodns, that needs a SelectorEventLoop on Windows, and that's loop.subprocess_exec is not implemented, but required by asyncio.create_subprocess_exec
 class ExternalDnsResolver(DnsResolver):
-    EXTERNAL_DNS = '1.1.1.1'
-
-    def __init__(self, where: str = EXTERNAL_DNS):
+    def __init__(self, where: str):
         self.where = where
         self.dns_resolver = None
-        self.cache = dict[tuple[str, int, socket.AddressFamily], tuple[float, list[ResolveResult]]]()
+        self.cache: dict[tuple[str, int, socket.AddressFamily], tuple[float, list[ResolveResult]]] = {}
 
     async def resolve(self, host: str, port: int = 0, family: socket.AddressFamily = socket.AF_UNSPEC) -> list[ResolveResult]:
         logger.debug("Resolving DNS at %s for %s:%i (%s)", self.where, host, port, "ipv6" if family == socket.AF_INET6 else "ipv4")
@@ -250,8 +248,8 @@ class ExternalDnsResolver(DnsResolver):
                 self.dns_resolver = await dns.asyncresolver.make_resolver_at(self.where)
             answer = await self.dns_resolver.resolve(host, rdtype=dns.rdatatype.AAAA if family == socket.AF_INET6 else dns.rdatatype.A)
         except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer) as e:
-            msg = e.args[1] if len(e.args) >= 1 else "DNS lookup failed"
-            exc = OSError(None, msg)
+            msg = '; '.join(e.args) if len(e.args) else "DNS lookup failed"
+            exc = LookupError(msg)
             # this is captured in a TaskGroup that drops traceback information from "from e"
             exc.add_note(repr(e))
             raise exc from None
@@ -271,7 +269,7 @@ class ExternalDnsResolver(DnsResolver):
                 )
             )
         if not hosts:
-            raise OSError(None, "DNS lookup failed")
+            raise LookupError("DNS lookup failed")
 
         self.cache[key] = (answer.expiration, hosts)
         return hosts
@@ -293,7 +291,7 @@ class Pingable(ABC):
     def get_state_name(available: bool):
         return 'up' if available else 'down'
 
-    async def wait_for(self, available: bool, timeout: float):
+    async def wait_for(self, available: bool, timeout: float): # NOSONAR(S7483)
         logger.debug("Waiting for %s to be %s (timeout is %ds)", LazyStr(self.get_class_name), LazyStr(Pingable.get_state_name, available), int(timeout))
         async with asyncio.timeout(timeout):
             while await self.ping(available) != available:
@@ -317,7 +315,7 @@ class Manageable(Pingable):
         super().__init__()
         self.manager = manager
 
-    async def _set_state(self, available: bool, repeat: float, timeout: float):
+    async def _set_state(self, available: bool, repeat: float, timeout: float): # NOSONAR(S7483)
         action_name = LazyStr(lambda: 'Starting' if available else 'Stopping')
         class_name = LazyStr(self.get_class_name)
         available_name = LazyStr(Pingable.get_state_name, available)
@@ -346,10 +344,10 @@ class Manageable(Pingable):
         logger.info("%s is %s", LazyStr(self.get_class_name), LazyStr(Pingable.get_state_name, available))
         return available
 
-    async def start(self, repeat: float, timeout: float):
+    async def start(self, repeat: float, timeout: float): # NOSONAR(S7483)
         return await self._set_state(True, repeat, timeout)
 
-    async def stop(self, repeat: float, timeout: float):
+    async def stop(self, repeat: float, timeout: float): # NOSONAR(S7483)
         return await self._set_state(False, repeat, timeout)
 
 class Service(Manageable):
@@ -369,11 +367,11 @@ class Service(Manageable):
             writer.close()
             await writer.wait_closed()
 
-    async def _ping(self, availability_hint: bool | None = None):
+    async def _ping(self, availability_hint: bool | None = None): # NOSONAR(S1172)
         logger.debug("Pinging %s (%s:%s)", LazyStr(self.get_class_name), str(self.host), str(self.port))
         await self._connect(self.host, self.port)
 
-    async def ping(self, availability_hint: bool | None = None):
+    async def ping(self, availability_hint: bool | None = None): # NOSONAR(S3776)
         try:
             await self._ping(availability_hint)
             return True
@@ -428,9 +426,9 @@ class SshService(Service):
             asyncssh.connect(host, port, options=asyncssh.SSHClientConnectionOptions(
                 host_key_alias=self.host_name,
                 client_keys=_client_key(),
-                connect_timeout=self._connect_timeout)) as conn
+                connect_timeout=self._connect_timeout))
         ):
-            pass
+            pass # NOSONAR(S108)
 
 class Device(Manageable):
     def __init__(self, host: str, manager: Manager):
@@ -460,7 +458,7 @@ class StateSerializer:
     @staticmethod
     def loads(s: str):
         try:
-            return dict({k: StateSerializer.load_value(v) for k, v in [s.split('=') for s in s.split(',')]})
+            return {k: StateSerializer.load_value(v) for k, v in [s.split('=') for s in s.split(',')]}
         except ValueError as e:
             e.add_note("Missing '=' in state")
             raise
@@ -470,7 +468,7 @@ class PhoneState(ABC):
     PFTPD = 'pftpd'
 
     @abstractmethod
-    async def get(self, repeat: float, timeout: float) -> dict:
+    async def get(self, repeat: float, timeout: float) -> dict: # NOSONAR(S7483)
         pass
 
 ########
@@ -532,7 +530,7 @@ class ServiceResolver:
         self.zeroconf = zeroconf
         self.service_type = service_type
 
-    async def get(self, service_name: str, timeout: float = 3):
+    async def get(self, service_name: str, timeout: float = 3): # NOSONAR(S7483)
         service_info = await self.zeroconf.async_get_service_info(self.service_type, f"{service_name}.{self.service_type}", timeout=int(timeout*1000))
         if not service_info or not service_info.port:
             raise TimeoutError("Unable to resolve zeroconf (DNS-SD) service information")
@@ -649,6 +647,7 @@ class PftpdServiceListener(ServiceListener):
             logger.debug(" (ServiceListener) Resolved %s to %s:%d", service_name, host, port)
 
     def del_service(self, service_name: str):
+        # we intentionally do not remove anything from the cache
         pass
 
 class RemotePftpd(SshService):
@@ -704,14 +703,14 @@ class Tailscale():
 class Funnel(Pingable):
     LOCAL_HOST = '127.0.0.1'
 
-    def __init__(self, tailscale: Tailscale, machine_name: str, local_port: int, local_path: str, external_port: int, dns_resolver: DnsResolver, local_tailscale: LocalTailscale):
+    def __init__(self, tailscale: Tailscale, machine_name: str, local_port: int, local_path: str, external_port: int, local_tailscale: LocalTailscale):
         self.machine_name = machine_name
         self.local_port = local_port
         self.external_name = f'{machine_name}.{tailscale.tailnet}'
         self.external_port = external_port
         self.external_url = f'https://{machine_name}.{tailscale.tailnet}:{external_port}{local_path}'
-        self.external_public_dns_resolver = dns_resolver
         self.local_tailscale = local_tailscale
+        self.external_public_dns_resolver = None
         self.external_tailscale_dns_resolver = None
 
     async def wait_for(self, available: bool, timeout: float):
@@ -720,15 +719,17 @@ class Funnel(Pingable):
 
     async def ping(self, availability_hint: bool | None = None):
         logger.debug("Resolving DNS for %s (%s:%s)", LazyStr(self.get_class_name), self.external_name, self.external_port)
-        if self.external_tailscale_dns_resolver is None:
-            self.external_tailscale_dns_resolver = ExternalDnsResolver(await self.local_tailscale.external_dns_resolver())
         # first try at Tailscale's DNS, if it doesn't know, we should not resolve at a public DNS and cache nxdomain for 5 minutes
+        if self.external_tailscale_dns_resolver is None:
+            self.external_tailscale_dns_resolver = ExternalDnsResolver(await self.local_tailscale.external_tailscale_dns_resolver())
         try:
             _answer = await self.external_tailscale_dns_resolver.resolve(self.external_name, self.external_port)
         except Exception as e:
             logger.debug("Resolving at Tailscale's external DNS has failed: %s", LazyStr(repr, e))
             return False
         # then try at a public DNS
+        if self.external_public_dns_resolver is None:
+            self.external_public_dns_resolver = ExternalDnsResolver(await self.local_tailscale.external_public_dns_resolver())
         try:
             _answer = await self.external_public_dns_resolver.resolve(self.external_name, self.external_port)
         except Exception as e:
@@ -791,7 +792,7 @@ class LocalTailscale(Manageable):
         self._is_started_now = start_result
         if start_result and not self._checked_fresh_start and self.machine_name:
             self._checked_fresh_start = True
-            max_last_seen_age = 3600
+            max_last_seen_age = 7200
             wait_on_fresh_start = 5
             difference = datetime.now(timezone.utc).replace(microsecond=0) - device_info.last_seen if device_info.last_seen else None
             difference_sec = difference.total_seconds() if difference else None
@@ -803,16 +804,23 @@ class LocalTailscale(Manageable):
                 await asyncio.sleep(wait_on_fresh_start)
         return start_result
 
-    async def external_dns_resolver(self):
-        logger.debug("Getting external DNS resolver of %s for ts.net", LazyStr(self.get_class_name))
+    async def _tailscale_dns_status(self):
         success, stdout, stderr = await Subprocess.tailscale(['dns', 'status', '--json'])
         if not success:
             exc = RuntimeError("Failed to get local DNS status from local Tailscale")
             exc.add_note(stderr.rstrip().replace("\n", "; "))
             raise exc
-        status = json.loads(stdout)
-        external_dns_resolver = next(addr['Addr'] for addr in status['SplitDNSRoutes']['ts.net.'] if ':' not in addr['Addr'])
-        return str(external_dns_resolver)
+        return json.loads(stdout)
+
+    async def external_public_dns_resolver(self):
+        logger.debug("Getting external public DNS resolver of %s", LazyStr(self.get_class_name))
+        status = await self._tailscale_dns_status()
+        return str(status['SystemDNS']['Nameservers'][0])
+
+    async def external_tailscale_dns_resolver(self):
+        logger.debug("Getting external Tailscale DNS resolver of %s for ts.net", LazyStr(self.get_class_name))
+        status = await self._tailscale_dns_status()
+        return str(next(addr['Addr'] for addr in status['SplitDNSRoutes']['ts.net.'] if ':' not in addr['Addr']))
 
 class StatSeen(ABC):
     @abstractmethod
@@ -854,7 +862,7 @@ class Webhooks:
     def __init__(self, host: str, port: int):
         self.host = host
         self.port = port
-        self.variables = dict[str, asyncio.Queue[str]]()
+        self.variables: dict[str, asyncio.Queue[str]] = {}
 
     @staticmethod
     def get_ping_path():
@@ -865,7 +873,7 @@ class Webhooks:
         return f'/{Webhooks.VARIABLE_PATH}/{variable}'
 
     async def _start(self):
-        async def _ping(request: web.Request):
+        async def _ping(request: web.Request): # NOSONAR(S7503)
             return web.Response(text='pong')
         async def _receive_variable(request: web.Request):
             queue = self.variables.get(request.match_info['name'])
@@ -892,7 +900,7 @@ class Webhooks:
     def unsubscribe_variable(self, variable: str):
         self.variables.pop(variable)
 
-    async def get_variable(self, variable: str, timeout: float):
+    async def get_variable(self, variable: str, timeout: float): # NOSONAR(S7483)
         queue = self.variables.get(variable)
         if not queue:
             raise ValueError(f"The {variable} is unknown")
@@ -906,6 +914,7 @@ class Webhooks:
     def __enter__(self):
         raise TypeError("Use async with instead")
     def __exit__(self, exc_type, exc_value, exc_tb):
+        # can't be called
         pass
     async def __aenter__(self):
         await self._start()
@@ -929,7 +938,7 @@ class Automate:
             "payload": f"prim-ctrl;{time.time()};" + message
         }
         logger.debug("Messaging Automate with: %s", message)
-        async with self.session.post(f'https://llamalab.com/automate/cloud/message', json=data) as response:
+        async with self.session.post('https://llamalab.com/automate/cloud/message', json=data) as response:
             await response.text()
 
 class AutomatePftpdManager(Manager):
@@ -991,12 +1000,12 @@ class ExternalWebhookPing(WebhookPing):
 class AutomatePhoneState(PhoneState):
     VARIABLE_STATE = 'state'
 
-    def __init__(self, general_session: aiohttp.ClientSession, external_dns_session: aiohttp.ClientSession, webhooks: Webhooks, automate: Automate, funnel: Funnel, local_tailscale: LocalTailscale):
+    def __init__(self, general_session: aiohttp.ClientSession, external_public_dns_session: aiohttp.ClientSession, webhooks: Webhooks, automate: Automate, funnel: Funnel, local_tailscale: LocalTailscale):
         self.webhooks = webhooks
         self.automate = automate
         self.funnel = funnel
         self.local_webhook_ping = WebhookPing(general_session, funnel)
-        self.external_webhook_ping = ExternalWebhookPing(external_dns_session, funnel, local_tailscale)
+        self.external_webhook_ping = ExternalWebhookPing(external_public_dns_session, funnel, local_tailscale)
 
     async def get(self, repeat: float, timeout: float):
         logger.info("Getting Phone state...")
@@ -1065,9 +1074,9 @@ class WideHelpFormatter(argparse.RawTextHelpFormatter):
 
 async def gather_with_taskgroup(*coros):
     try:
-        async with asyncio.TaskGroup() as tg:
+        async with asyncio.TaskGroup() as tg: # NOSONAR(S7513)
             tasks = [tg.create_task(coro) for coro in coros]
-        return tuple([task.result() for task in tasks])
+        return tuple(task.result() for task in tasks)
     except ExceptionGroup as eg:
         exc = eg.exceptions[0]
         # this can be captured in another TaskGroup that drops traceback information from "from e"
@@ -1104,6 +1113,7 @@ class Control:
 
     @staticmethod
     def setup_parser_options(parser):
+        # no options
         pass
 
     @staticmethod
@@ -1138,12 +1148,12 @@ class Control:
         self.phone = phone
         self.keyboard_interrupt = keyboard_interrupt
 
-    async def _stop(self, restore_state: dict | None, stop_only_started: bool = False):
+    async def _stop(self, restore_state: dict | None, stop_only_started: bool = False): # NOSONAR(S3776)
         with self.keyboard_interrupt.protect():
             async def _suppress(coro, default: bool):
                 try:
                     return await coro
-                except:
+                except: # NOSONAR(S5754)
                     return default
             if self.local.vpn and self.phone.vpn and self.phone.remote_sftp and await _suppress(self.local.vpn.test(), True) and await _suppress(self.phone.vpn.test(), True):
                 if (restore_state is None or not restore_state.get(Control.PHONE_SFTP, stop_only_started)) and await _suppress(self.phone.remote_sftp.test(), True):
@@ -1169,7 +1179,7 @@ class Control:
                     except Exception as e:
                         logger.exception_or_error(e)
 
-    async def run(self):
+    async def run(self): # NOSONAR(S3776)
         match self.args.intent:
             case 'test':
                 if self.local.vpn and self.phone.vpn and self.phone.remote_sftp and self.phone.state:
@@ -1181,7 +1191,7 @@ class Control:
                     await self.phone.zeroconf_sftp.test()
             case 'start':
                 if self.local.vpn and self.phone.vpn and self.phone.remote_sftp:
-                    state = dict()
+                    state = {}
                     try:
                         # gather local state info
                         local_vpn_state = await self.local.vpn.test()
@@ -1201,7 +1211,7 @@ class Control:
                             state[Control.PHONE_VPN] = phone_vpn_state
                             state[Control.PHONE_SFTP] = phone_state[PhoneState.PFTPD]
                             if not state[Control.PHONE_WIFI] and not self.args.accept_cellular:
-                                raise RuntimeError(f"Phone is not on Wi-Fi network")
+                                raise RuntimeError("Phone is not on Wi-Fi network")
                         else:
                             state[Control.PHONE_VPN] = phone_vpn_state = await self.phone.vpn.test()
                             if phone_vpn_state:
@@ -1252,7 +1262,7 @@ class Control:
                             raise RuntimeError(f"Even when {self.phone.vpn.get_class_name()} and {self.phone.remote_sftp.get_class_name()} is started, {self.phone.remote_sftp.get_class_name()} is still not accessible")
                         # print out result on stdout
                         if not self.args.backup_state:
-                            state = dict()
+                            state = {}
                         state[Control.CONNECTED] = Control.ZEROCONF if zeroconf_accessible else Control.REMOTE
                         print(StateSerializer.dumps(state))
                     except:
@@ -1342,15 +1352,11 @@ class AutomateControl(Control):
     async def runner(args: argparse.Namespace) -> None:
         AutomateControl.prepare(args)
 
-        external_dns_resolver = ExternalDnsResolver()
         async with (
             aiohttp.ClientSession() as general_session,
             aiohttp.ClientSession(
                 # Automate messaging server prefers closing connections
                 connector=aiohttp.TCPConnector(force_close=True)) as force_close_session,
-            aiohttp.ClientSession(
-                # Uses external DNS to access Funnel TCP forwarder servers instead of local MagicDNS route
-                connector=aiohttp.TCPConnector(resolver=external_dns_resolver)) as external_dns_session,
             AsyncZeroconf() as zeroconf
         ):
             service_cache = ServiceCache(Cache(Cache.PRIM_SYNC_APP_NAME))
@@ -1385,14 +1391,20 @@ class AutomateControl(Control):
             tailscale = Tailscale(secrets, general_session, _tailscale_tailnet(), _tailscale_secretfile()) if args.tailscale else None
             local_tailscale = LocalTailscale(tailscale, _funnel_local_machine_name_or_none(), LocalTailscaleManager()) if tailscale else None
             remote_tailscale = RemoteTailscale(tailscale, _tailscale_remote_machine_name(), AutomateTailscaleManager(automate)) if tailscale else None
-            funnel = Funnel(tailscale, _funnel_local_machine_name(), _funnel_local_port(), _funnel_local_path(), _funnel_external_port(), external_dns_resolver, local_tailscale) if tailscale and local_tailscale and args.funnel else None
+            funnel = Funnel(tailscale, _funnel_local_machine_name(), _funnel_local_port(), _funnel_local_path(), _funnel_external_port(), local_tailscale) if tailscale and args.funnel and local_tailscale else None
             pftpd_manager = AutomatePftpdManager(automate)
             zeroconf_pftpd = ZeroconfPftpd(args.server_name, service_cache, service_resolver, args.keyfile, pftpd_manager)
             remote_pftpd = RemotePftpd(remote_tailscale.host, _tailscale_sftp_port(), args.server_name, args.keyfile, pftpd_manager) if remote_tailscale else None
 
-            async with Webhooks(Funnel.LOCAL_HOST, funnel.local_port) if funnel else nullcontext() as webhooks:
+            async with (
+                aiohttp.ClientSession(
+                    # Uses external DNS to access Funnel TCP forwarder servers instead of local MagicDNS route
+                    connector=aiohttp.TCPConnector(resolver=funnel.external_public_dns_resolver)
+                    ) if funnel else nullcontext() as external_public_dns_session,
+                Webhooks(Funnel.LOCAL_HOST, funnel.local_port) if funnel else nullcontext() as webhooks
+            ):
                 local = Local(local_tailscale)
-                automate_phone_state = AutomatePhoneState(general_session, external_dns_session, webhooks, automate, funnel, local_tailscale) if local_tailscale and funnel and webhooks else None
+                automate_phone_state = AutomatePhoneState(general_session, external_public_dns_session, webhooks, automate, funnel, local_tailscale) if external_public_dns_session and webhooks and funnel and local_tailscale else None
                 phone = Phone(zeroconf_pftpd, remote_tailscale, remote_pftpd, automate_phone_state)
                 keyboard_interrupt = SignalFence(signal.SIGINT, lambda signum, frame: logger.debug("Keyboard interrupt received, finishing ongoing operations before exit"))
                 control = AutomateControl(args, local, phone, keyboard_interrupt)

{prim_ctrl-0.8.0 → prim_ctrl-0.8.2}/pyproject.toml

@@ -3,7 +3,7 @@ packages = [{include = "prim_ctrl"}]
 
 [project]
 name = "prim-ctrl"
-version = "0.8.0"
+version = "0.8.2"
 description = "Primitive Ctrl - Remote control of your phone's Primitive FTPd Android SFTP server and optionally Tailscale VPN."
 license = "Apache-2.0"
 authors = [