prim-ctrl 0.6.0__tar.gz → 0.6.2__tar.gz

{prim_ctrl-0.6.0 → prim_ctrl-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prim-ctrl
-Version: 0.6.0
+Version: 0.6.2
 Summary: Primitive Ctrl - Remote control of your phone's Primitive FTPd Android SFTP server and optionally Tailscale VPN.
 Home-page: https://github.com/lmagyar/prim-ctrl
 License: Apache-2.0
@@ -13,9 +13,10 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: aiohttp (>=3.11.0,<4.0.0)
+Requires-Dist: aiohttp (>=3.11.10,<4.0.0)
+Requires-Dist: dnspython (>=2.7.0,<3.0.0)
 Requires-Dist: platformdirs (>=4.3.6,<5.0.0)
-Requires-Dist: zeroconf (>=0.136.0,<0.137.0)
+Requires-Dist: zeroconf (>=0.136.2,<0.137.0)
 Project-URL: Change Log, https://github.com/lmagyar/prim-ctrl/blob/main/CHANGELOG.md
 Project-URL: Repository, https://github.com/lmagyar/prim-ctrl
 Description-Content-Type: text/markdown
@@ -136,6 +137,7 @@ But if the script runs scheduled, we can't be sure whether the phone is on WiFi,
 
 Notes:
 - Even when -b option is **not** used, the script will output 'connected=(local|remote)', what you can use to determine whether to use -a option for the prim-sync script
+- If local Tailscale VPN was disconnected for a longer period (several hours), the public DNS records for Funnel are removed by Tailscale, and after connecting local Tailscale VPN to the tailnet it can take up to 10 minutes for Funnel's public DNS records to show up for your tailnet domain. If the script connects local Tailscale VPN to the tailnet, then it regularly checks and waits up to 10 minutes for the public DNS records to get updated.
 
 ### Some example
 

{prim_ctrl-0.6.0 → prim_ctrl-0.6.2}/README.md

@@ -114,6 +114,7 @@ But if the script runs scheduled, we can't be sure whether the phone is on WiFi,
 
 Notes:
 - Even when -b option is **not** used, the script will output 'connected=(local|remote)', what you can use to determine whether to use -a option for the prim-sync script
+- If local Tailscale VPN was disconnected for a longer period (several hours), the public DNS records for Funnel are removed by Tailscale, and after connecting local Tailscale VPN to the tailnet it can take up to 10 minutes for Funnel's public DNS records to show up for your tailnet domain. If the script connects local Tailscale VPN to the tailnet, then it regularly checks and waits up to 10 minutes for the public DNS records to get updated.
 
 ### Some example
 

{prim_ctrl-0.6.0 → prim_ctrl-0.6.2}/prim_ctrl/__main__.py

@@ -16,6 +16,8 @@ from pathlib import Path
 from typing import Dict
 
 import aiohttp
+import dns.asyncresolver
+import dns.resolver
 from aiohttp import ClientTimeout, web
 from platformdirs import user_cache_dir
 from zeroconf import Zeroconf, ServiceInfo, ServiceListener as ZeroconfServiceListener
@@ -35,7 +37,7 @@ class LevelFormatter(logging.Formatter):
         return self.formatters.get(record.levelno, self.default_formatter).format(record)
 
 class Logger(logging.Logger):
-    def __init__(self, name, level=logging.NOTSET):
+    def __init__(self, name, level = logging.NOTSET):
         super().__init__(name, level)
         self.exitcode = 0
 
@@ -62,6 +64,15 @@ class Logger(logging.Logger):
         if self.level == logging.NOTSET:
             self.setLevel(logging.WARNING if silent else logging.INFO)
 
+    def exception_or_error(self, e: Exception, args):
+        if not args or args.debug:
+            logger.exception(e)
+        else:
+            if hasattr(e, '__notes__'):
+                logger.error("%s: %s", LazyStr(repr, e), LazyStr(", ".join, e.__notes__))
+            else:
+                logger.error(LazyStr(repr, e))
+
     def error(self, msg, *args, **kwargs):
         self.exitcode = 1
         super().error(msg, *args, **kwargs)
@@ -90,50 +101,43 @@ logger = Logger(Path(sys.argv[0]).name)
 
 ########
 
-# based on https://stackoverflow.com/a/55656177/2755656
-def sync_ping(host, packets: int = 1, timeout: float = 1):
-    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
-        result = subprocess.run(command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, creationflags=subprocess.CREATE_NO_WINDOW)
-        return result.returncode == 0 and b'TTL=' in result.stdout
-    else:
-        command = ['ping', '-c', str(packets), '-W', str(int(timeout)), host]
-        result = subprocess.run(command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        return result.returncode == 0
-
-async def async_ping(host, packets: int = 1, timeout: float = 1):
-    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
-        proc = await asyncio.create_subprocess_exec(*command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, creationflags=subprocess.CREATE_NO_WINDOW)
+class Subprocess:
+
+    # based on https://stackoverflow.com/a/55656177/2755656
+    @staticmethod
+    def sync_ping(host, packets: int = 1, timeout: float = 1):
+        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
+            result = subprocess.run(command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, creationflags=subprocess.CREATE_NO_WINDOW)
+            return result.returncode == 0 and b'TTL=' in result.stdout
+        else:
+            command = ['ping', '-c', str(packets), '-W', str(int(timeout)), host]
+            result = subprocess.run(command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            return result.returncode == 0
+
+    @staticmethod
+    async def async_ping(host, packets: int = 1, timeout: float = 1):
+        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
+            proc = await asyncio.create_subprocess_exec(*command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, creationflags=subprocess.CREATE_NO_WINDOW)
+            stdout, _stderr = await proc.communicate()
+            return proc.returncode == 0 and b'TTL=' in stdout
+        else:
+            command = ['ping', '-c', str(packets), '-W', str(int(timeout)), host]
+            proc = await asyncio.create_subprocess_exec(*command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            _stdout, _stderr = await proc.communicate()
+            return proc.returncode == 0
+
+    @staticmethod
+    async def async_tailscale(args: list[str]):
+        command = ['tailscale']
+        command.extend(args)
+        creationflags = subprocess.CREATE_NO_WINDOW if platform.system().lower() == 'windows' else 0
+        proc = await asyncio.create_subprocess_exec(*command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, creationflags=creationflags)
         stdout, _stderr = await proc.communicate()
-        return proc.returncode == 0 and b'TTL=' in stdout
-    else:
-        command = ['ping', '-c', str(packets), '-W', str(int(timeout)), host]
-        proc = await asyncio.create_subprocess_exec(*command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        _stdout, _stderr = await proc.communicate()
-        return proc.returncode == 0
-
-async def async_tailscale(args: list[str]):
-    command = ['tailscale']
-    command.extend(args)
-    creationflags = subprocess.CREATE_NO_WINDOW if platform.system().lower() == 'windows' else 0
-    proc = await asyncio.create_subprocess_exec(*command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, creationflags=creationflags)
-    stdout, _stderr = await proc.communicate()
-    return proc.returncode == 0, stdout
-
-async def async_tailscale_up():
-    return (await async_tailscale(['up']))[0]
-
-async def async_tailscale_down():
-    return (await async_tailscale(['down']))[0]
-
-async def async_tailscale_is_online():
-    success, stdout = await async_tailscale(['status', '--json', '--peers=false', '--self=true'])
-    if success:
-        status = json.loads(stdout)
-    return success and status['BackendState'] == 'Running' and status['Self']['Online']
+        return proc.returncode == 0, stdout
 
 ########
 
@@ -171,8 +175,11 @@ class Pingable:
         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:
-                if not available:
-                    await asyncio.sleep(1)
+                await self._sleep_while_wait(available)
+
+    async def _sleep_while_wait(self, available: bool):
+        if not available:
+            await asyncio.sleep(1)
 
 class Manager:
     @abstractmethod
@@ -253,7 +260,7 @@ class Device(Manageable):
 
     async def ping(self, availability_hint: bool | None = None):
         logger.debug("Pinging %s (%s)", LazyStr(self.get_class_name), self.host)
-        return await async_ping(self.host, timeout=2)
+        return await Subprocess.async_ping(self.host, timeout=2)
 
 class StateSerializer:
     BOOL = {False: Pingable.get_state_name(False), True: Pingable.get_state_name(True)}
@@ -289,153 +296,6 @@ class PhoneState:
 
 ########
 
-class Webhooks:
-    PING_PATH = 'ping'
-    VARIABLE_PATH = 'variable'
-
-    def __init__(self, host: str, port: int):
-        self.host = host
-        self.port = port
-        self.variables = dict[str, asyncio.Queue[str]]()
-
-    @staticmethod
-    def get_ping_path():
-        return f'/{Webhooks.PING_PATH}'
-
-    @staticmethod
-    def get_variable_path(variable: str):
-        return f'/{Webhooks.VARIABLE_PATH}/{variable}'
-
-    async def _start(self):
-        async def _ping(request: web.Request):
-            return web.Response(text='pong')
-        async def _receive_variable(request: web.Request):
-            queue = self.variables.get(request.match_info['name'])
-            if queue:
-                with suppress(asyncio.QueueFull):
-                    queue.put_nowait(await request.text())
-            return web.Response(text='OK')
-        app = web.Application()
-        app.add_routes([
-            web.get(f'/{Webhooks.PING_PATH}', _ping),
-            web.post(f'/{Webhooks.VARIABLE_PATH}' + r'/{name}', _receive_variable)])
-        self.runner = web.AppRunner(app)
-        await self.runner.setup()
-        self.site = web.TCPSite(self.runner, host=self.host, port=self.port)
-        await self.site.start()
-
-    async def _stop(self):
-        await self.runner.cleanup()
-
-    def subscribe_variable(self, variable: str):
-        if variable not in self.variables:
-            self.variables[variable] = asyncio.Queue[str](maxsize=16)
-
-    def unsubscribe_variable(self, variable: str):
-        self.variables.pop(variable)
-
-    async def get_variable(self, variable: str, timeout: float):
-        queue = self.variables.get(variable)
-        if not queue:
-            raise ValueError(f"The {variable} is unknown")
-        try:
-            async with asyncio.timeout(timeout):
-                return await queue.get()
-        except TimeoutError as e:
-            e.add_note(f"Can't get value of {variable} for {timeout} seconds")
-            raise
-
-    def __enter__(self):
-        raise TypeError("Use async with instead")
-    def __exit__(self, exc_type, exc_value, exc_tb):
-        pass
-    async def __aenter__(self):
-        await self._start()
-        return self
-    async def __aexit__(self, exc_type, exc_value, exc_tb):
-        await self._stop()
-
-class Automate:
-    def __init__(self, secrets: Secrets, session: aiohttp.ClientSession, account: str, device: str, tokenfile: str):
-        self.session = session
-        self.account = account
-        self.device = device
-        self.secret = secrets.get(tokenfile)
-
-    async def send_message(self, message: str):
-        data = {
-            "secret": self.secret,
-            "to": self.account,
-            "device": self.device,
-            "priority": "high",
-            "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:
-            await response.text()
-
-class AutomatepFTPdManager(Manager):
-    def __init__(self, automate: Automate):
-        self.automate = automate
-
-    async def start(self):
-        await self.automate.send_message('start-pftpd')
-
-    async def stop(self):
-        await self.automate.send_message('stop-pftpd')
-
-class AutomateTailscaleManager(Manager):
-    def __init__(self, automate: Automate):
-        self.automate = automate
-
-    async def start(self):
-        await self.automate.send_message('start-tailscale')
-
-    async def stop(self):
-        await self.automate.send_message('stop-tailscale')
-
-class AutomatePhoneState(PhoneState):
-    VARIABLE_STATE = 'state'
-
-    def __init__(self, session: aiohttp.ClientSession, webhooks: Webhooks, automate: Automate, external_url: str):
-        self.session = session
-        self.webhooks = webhooks
-        self.automate = automate
-        self.external_url = external_url
-
-    async def get(self, repeat: float, timeout: float):
-        logger.info("Getting Phone state...")
-        # first test funnel + webhooks availability, to not wait for a reply if local tailscale or funnel is down
-        # though it will be routed locally, it will not go out to Tailscale's TCP forwarder servers, so the route is different from what Automate will see
-        logger.debug("Testing funnel with pinging local webhook (timeout is %ds)", int(timeout))
-        try:
-            async with self.session.get(f'{self.external_url}{Webhooks.get_ping_path()}', timeout=ClientTimeout(total=timeout)) as response:
-                if await response.text() != 'pong':
-                    raise Exception()
-        except:
-            raise RuntimeError(f"Local Tailscale is down or local Funnel is not configured properly for {self.external_url}")
-        # get state
-        logger.debug("Getting Phone state (repeat after %ds, timeout is %ds)", int(repeat), int(timeout))
-        self.webhooks.subscribe_variable(AutomatePhoneState.VARIABLE_STATE)
-        try:
-            async with asyncio.timeout(timeout):
-                while True:
-                    try:
-                        await self.automate.send_message(f'get-state;{self.external_url}{Webhooks.get_variable_path(AutomatePhoneState.VARIABLE_STATE)}')
-                        state = await self.webhooks.get_variable(AutomatePhoneState.VARIABLE_STATE, min(repeat, timeout))
-                        break
-                    except TimeoutError:
-                        pass
-        except TimeoutError as e:
-            e.add_note(f"Can't get value of {AutomatePhoneState.VARIABLE_STATE} for {timeout} seconds - please check on your phone in the Automate app, that the prim-ctrl flow is running")
-            raise
-        finally:
-            self.webhooks.unsubscribe_variable(AutomatePhoneState.VARIABLE_STATE)
-        logger.info("Phone state is %s", state)
-        return StateSerializer.loads(state)
-
-########
-
 class Cache:
     PRIM_SYNC_APP_NAME = 'prim-sync'
 
@@ -545,19 +405,19 @@ class ZeroconfService(Manageable):
 
     async def ping(self, availability_hint: bool | None = None):
         async def _connect(connect_timeout: float, resolve_timeout: float):
-            async def asyncio_open_connection(host: str, port: int, timeout: float):
+            async def _asyncio_open_connection(host: str, port: int, timeout: float):
                 logger.debug(" Connecting to %s on port %d (timeout is %ds)", host, port, timeout)
                 async with asyncio.timeout(timeout):
                     return await asyncio.open_connection(host, port)
-            async def service_resolver_get(service_name: str, timeout: float):
+            async def _service_resolver_get(service_name: str, timeout: float):
                 logger.debug(" Resolving %s (timeout is %ds)", service_name, timeout)
                 return await self.service_resolver.get(service_name, timeout)
             if self.host and self.port:
-                return await asyncio_open_connection(self.host, self.port, connect_timeout)
+                return await _asyncio_open_connection(self.host, self.port, connect_timeout)
             host, port = self.service_cache.get(self.service_name)
             if host and port:
                 try:
-                    reader_writer = await asyncio_open_connection(host, port, connect_timeout)
+                    reader_writer = await _asyncio_open_connection(host, port, connect_timeout)
                     self.host = host
                     self.port = port
                     return reader_writer
@@ -566,8 +426,8 @@ class ZeroconfService(Manageable):
                         pass
                     else:
                         raise
-            host, port = await service_resolver_get(self.service_name, resolve_timeout)
-            reader_writer = await asyncio_open_connection(host, port, connect_timeout)
+            host, port = await _service_resolver_get(self.service_name, resolve_timeout)
+            reader_writer = await _asyncio_open_connection(host, port, connect_timeout)
             self.service_cache.set(self.service_name, host, port)
             self.host = host
             self.port = port
@@ -624,13 +484,6 @@ class RemoteTailscale(Device):
         self.tailnet = tailnet
         self.__qualname__ = "Remote Tailscale"
 
-class Funnel:
-    LOCAL_HOST = '127.0.0.1'
-
-    def __init__(self, tailscale: RemoteTailscale, machine_name: str, local_port: int, local_path: str, external_port: int):
-        self.local_port = local_port
-        self.external_url = f'https://{machine_name}.{tailscale.tailnet}:{external_port}{local_path}'
-
 ########
 
 class Local:
@@ -639,10 +492,12 @@ class Local:
 
 class LocalTailscaleManager(Manager):
     async def start(self):
-        await async_tailscale_up()
+        if not (await Subprocess.async_tailscale(['up']))[0]:
+            raise RuntimeError("Failed to start up local Tailscale")
 
     async def stop(self):
-        await async_tailscale_down()
+        if not (await Subprocess.async_tailscale(['down']))[0]:
+            raise RuntimeError("Failed to shut down local Tailscale")
 
 class LocalTailscale(Manageable):
     def __init__(self):
@@ -650,8 +505,200 @@ class LocalTailscale(Manageable):
         self.__qualname__ = "Local Tailscale"
 
     async def ping(self, availability_hint: bool | None = None):
-        logger.debug("Pinging %s", LazyStr(self.get_class_name))
-        return await async_tailscale_is_online()
+        logger.debug("Getting status of %s", LazyStr(self.get_class_name))
+        success, stdout = await Subprocess.async_tailscale(['status', '--json', '--peers=false', '--self=true'])
+        if success:
+            status = json.loads(stdout)
+        return success and status['BackendState'] == 'Running' and status['Self']['Online']
+
+    async def _sleep_while_wait(self, available: bool):
+        await asyncio.sleep(0.250)
+
+class Funnel(Pingable):
+    LOCAL_HOST = '127.0.0.1'
+
+    def __init__(self, tailscale: RemoteTailscale, machine_name: str, local_port: int, local_path: str, external_port: int):
+        self.local_port = local_port
+        self.external_name = f'{machine_name}.{tailscale.tailnet}'
+        self.external_url = f'https://{machine_name}.{tailscale.tailnet}:{external_port}{local_path}'
+
+    async def wait_for(self, available: bool, timeout: float):
+        self._sleepcounter = 0
+        await super().wait_for(available, timeout)
+
+    async def ping(self, availability_hint: bool | None = None):
+        logger.debug("Resolving DNS for %s (%s)", LazyStr(self.get_class_name), self.external_name)
+        try:
+            # resolve directly at an outside DNS, because local magicDNS will return the tailnet IP
+            _answer = await dns.asyncresolver.resolve_at('1.1.1.1', self.external_name)
+        except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):
+            return False
+        return True
+
+    async def _sleep_while_wait(self, available: bool):
+        if 0 != self._sleepcounter and 0 == self._sleepcounter % 6:
+            logger.info("Waiting for public DNS records to be updated for %s (%s)...", LazyStr(self.get_class_name), self.external_name)
+        await asyncio.sleep(10)
+        self._sleepcounter += 1
+
+########
+
+class Webhooks:
+    PING_PATH = 'ping'
+    VARIABLE_PATH = 'variable'
+
+    def __init__(self, host: str, port: int):
+        self.host = host
+        self.port = port
+        self.variables = dict[str, asyncio.Queue[str]]()
+
+    @staticmethod
+    def get_ping_path():
+        return f'/{Webhooks.PING_PATH}'
+
+    @staticmethod
+    def get_variable_path(variable: str):
+        return f'/{Webhooks.VARIABLE_PATH}/{variable}'
+
+    async def _start(self):
+        async def _ping(request: web.Request):
+            return web.Response(text='pong')
+        async def _receive_variable(request: web.Request):
+            queue = self.variables.get(request.match_info['name'])
+            if queue:
+                with suppress(asyncio.QueueFull):
+                    queue.put_nowait(await request.text())
+            return web.Response(text='OK')
+        app = web.Application()
+        app.add_routes([
+            web.get(f'/{Webhooks.PING_PATH}', _ping),
+            web.post(f'/{Webhooks.VARIABLE_PATH}' + r'/{name}', _receive_variable)])
+        self.runner = web.AppRunner(app)
+        await self.runner.setup()
+        self.site = web.TCPSite(self.runner, host=self.host, port=self.port)
+        await self.site.start()
+
+    async def _stop(self):
+        await self.runner.cleanup()
+
+    def subscribe_variable(self, variable: str):
+        if variable not in self.variables:
+            self.variables[variable] = asyncio.Queue[str](maxsize=16)
+
+    def unsubscribe_variable(self, variable: str):
+        self.variables.pop(variable)
+
+    async def get_variable(self, variable: str, timeout: float):
+        queue = self.variables.get(variable)
+        if not queue:
+            raise ValueError(f"The {variable} is unknown")
+        try:
+            async with asyncio.timeout(timeout):
+                return await queue.get()
+        except TimeoutError as e:
+            e.add_note(f"Can't get value of {variable} for {timeout} seconds")
+            raise
+
+    def __enter__(self):
+        raise TypeError("Use async with instead")
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        pass
+    async def __aenter__(self):
+        await self._start()
+        return self
+    async def __aexit__(self, exc_type, exc_value, exc_tb):
+        await self._stop()
+
+class Automate:
+    def __init__(self, secrets: Secrets, session: aiohttp.ClientSession, account: str, device: str, tokenfile: str):
+        self.session = session
+        self.account = account
+        self.device = device
+        self.secret = secrets.get(tokenfile)
+
+    async def send_message(self, message: str):
+        data = {
+            "secret": self.secret,
+            "to": self.account,
+            "device": self.device,
+            "priority": "high",
+            "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:
+            await response.text()
+
+class AutomatepFTPdManager(Manager):
+    def __init__(self, automate: Automate):
+        self.automate = automate
+
+    async def start(self):
+        await self.automate.send_message('start-pftpd')
+
+    async def stop(self):
+        await self.automate.send_message('stop-pftpd')
+
+class AutomateTailscaleManager(Manager):
+    def __init__(self, automate: Automate):
+        self.automate = automate
+
+    async def start(self):
+        await self.automate.send_message('start-tailscale')
+
+    async def stop(self):
+        await self.automate.send_message('stop-tailscale')
+
+class AutomatePhoneState(PhoneState):
+    VARIABLE_STATE = 'state'
+
+    def __init__(self, session: aiohttp.ClientSession, webhooks: Webhooks, automate: Automate, funnel: Funnel):
+        self.session = session
+        self.webhooks = webhooks
+        self.automate = automate
+        self.funnel = funnel
+
+    async def get(self, repeat: float, timeout: float):
+        logger.info("Getting Phone state...")
+
+        # test funnel + webhooks availability, to not wait for a reply if funnel isn't configured properly
+        # though it will be routed locally, it will not go out to Tailscale's TCP forwarder servers, so the route is different from what Automate will see
+        test_timeout = 10.0
+        logger.debug("Testing Funnel with calling local webhook (timeout is %ds)", int(test_timeout))
+        try:
+            async with self.session.get(f'{self.funnel.external_url}{Webhooks.get_ping_path()}', timeout=ClientTimeout(total=test_timeout)) as response:
+                if await response.text() != 'pong':
+                    raise Exception()
+        except Exception as e:
+            raise RuntimeError(f"Local Funnel is not configured properly for {self.funnel.external_url}") from e
+
+        # test funnel's DNS resolvability, if local Tailscale is freshly started up after longer down state, it can take up to 10 minutes for public DNS records to get updated
+        test_timeout = 600.0
+        logger.debug("Testing Funnel's DNS configuration (timeout is %ds)", int(test_timeout))
+        try:
+            await self.funnel.wait_for(True, test_timeout)
+        except Exception as e:
+            raise RuntimeError(f"Funnel's DNS is not configured by Tailscale for {self.funnel.external_name}") from e
+
+        # get state
+        logger.debug("Getting Phone state (repeat after %ds, timeout is %ds)", int(repeat), int(timeout))
+        self.webhooks.subscribe_variable(AutomatePhoneState.VARIABLE_STATE)
+        try:
+            async with asyncio.timeout(timeout):
+                while True:
+                    try:
+                        await self.automate.send_message(f'get-state;{self.funnel.external_url}{Webhooks.get_variable_path(AutomatePhoneState.VARIABLE_STATE)}')
+                        state = await self.webhooks.get_variable(AutomatePhoneState.VARIABLE_STATE, min(repeat, timeout))
+                        break
+                    except TimeoutError:
+                        pass
+        except TimeoutError as e:
+            e.add_note(f"Can't get value of {AutomatePhoneState.VARIABLE_STATE} for {timeout} seconds - please check on your phone in the Automate app, that the prim-ctrl flow is running")
+            raise
+        finally:
+            self.webhooks.unsubscribe_variable(AutomatePhoneState.VARIABLE_STATE)
+
+        logger.info("Phone state is %s", state)
+        return StateSerializer.loads(state)
 
 ########
 
@@ -715,18 +762,30 @@ class Control:
             raise ValueError("The --restore-state option can be enabled only for the stop intent")
 
     async def execute(self, args, local: Local, phone: Phone):
-        async def _stop(restore_state: dict | None):
+        async def _stop(restore_state: dict | None, stop_only_started: bool = False):
             if local.vpn and phone.vpn and phone.remote_sftp and await local.vpn.test() and await phone.vpn.test():
-                if (restore_state is None or not restore_state.get(Control.PHONE_SFTP, False)) and await phone.remote_sftp.test():
-                    await phone.remote_sftp.stop(10, 30)
-                if restore_state is None or not restore_state.get(Control.PHONE_VPN, False):
-                    await phone.vpn.stop(10, 60)
+                if (restore_state is None or not restore_state.get(Control.PHONE_SFTP, stop_only_started)) and await phone.remote_sftp.test():
+                    try:
+                        await phone.remote_sftp.stop(10, 30)
+                    except Exception as e:
+                        logger.exception_or_error(e, args)
+                if restore_state is None or not restore_state.get(Control.PHONE_VPN, stop_only_started):
+                    try:
+                        await phone.vpn.stop(10, 60)
+                    except Exception as e:
+                        logger.exception_or_error(e, args)
             else:
-                if (restore_state is None or not restore_state.get(Control.PHONE_SFTP, False)):
-                    await phone.zeroconf_sftp.stop(10, 30)
+                if (restore_state is None or not restore_state.get(Control.PHONE_SFTP, stop_only_started)):
+                    try:
+                        await phone.zeroconf_sftp.stop(10, 30)
+                    except Exception as e:
+                        logger.exception_or_error(e, args)
             if local.vpn:
-                if restore_state is None or not restore_state.get(Control.LOCAL_VPN, False):
-                    await local.vpn.stop(10, 30)
+                if restore_state is None or not restore_state.get(Control.LOCAL_VPN, stop_only_started):
+                    try:
+                        await local.vpn.stop(10, 30)
+                    except Exception as e:
+                        logger.exception_or_error(e, args)
         match args.intent:
             case 'test':
                 if local.vpn and phone.vpn and phone.remote_sftp and phone.state:
@@ -739,29 +798,31 @@ class Control:
             case 'start':
                 if local.vpn and phone.vpn and phone.remote_sftp:
                     state = dict()
-                    zeroconf_accessible = False
-                    remote_accessible = False
-
-                    # gather local state info
-                    local_vpn_state = await local.vpn.test()
-                    state[Control.LOCAL_VPN] = local_vpn_state
-                    # start changing local state - we need a local vpn to be able to access the state of the remote vpn and optionally the phone
-                    await local.vpn.start(10, 30)
-
-                    # gather remote state info
-                    if phone.state:
-                        phone_state, phone_vpn_state = await gather_with_taskgroup(phone.state.get(10, 30), phone.vpn.test())
-                        state[Control.PHONE_WIFI] = phone_state[PhoneState.WIFI]
-                        state[Control.PHONE_VPN] = phone_vpn_state
-                        state[Control.PHONE_SFTP] = phone_state[PhoneState.PFTPD]
-                        if not state[Control.PHONE_WIFI] and not args.accept_cellular:
-                            raise RuntimeError(f"Phone is not on Wi-Fi network")
-                    else:
-                        state[Control.PHONE_VPN] = await phone.vpn.test()
-                        if state[Control.PHONE_VPN]:
-                            state[Control.PHONE_SFTP] = remote_accessible = await phone.remote_sftp.test()
-                    # start changing remote state
                     try:
+                        # gather local state info
+                        local_vpn_state = await local.vpn.test()
+                        state[Control.LOCAL_VPN] = local_vpn_state
+
+                        # start changing local state - we need a local vpn to be able to access the state of the remote vpn and optionally the phone
+                        await local.vpn.start(10, 30)
+
+                        zeroconf_accessible = False
+                        remote_accessible = False
+
+                        # gather phone state info
+                        if phone.state:
+                            phone_state, phone_vpn_state = await gather_with_taskgroup(phone.state.get(10, 30), phone.vpn.test())
+                            state[Control.PHONE_WIFI] = phone_state[PhoneState.WIFI]
+                            state[Control.PHONE_VPN] = phone_vpn_state
+                            state[Control.PHONE_SFTP] = phone_state[PhoneState.PFTPD]
+                            if not state[Control.PHONE_WIFI] and not args.accept_cellular:
+                                raise RuntimeError(f"Phone is not on Wi-Fi network")
+                        else:
+                            state[Control.PHONE_VPN] = await phone.vpn.test()
+                            if state[Control.PHONE_VPN]:
+                                state[Control.PHONE_SFTP] = remote_accessible = await phone.remote_sftp.test()
+
+                        # start changing phone state
                         if phone.state:
                             if not state[Control.PHONE_SFTP]:
                                 if not state[Control.PHONE_VPN]:
@@ -799,20 +860,22 @@ class Control:
                                 zeroconf_accessible = await phone.zeroconf_sftp.test()
                         if not zeroconf_accessible and not remote_accessible:
                             raise RuntimeError(f"Even when {phone.vpn.get_class_name()} and {phone.remote_sftp.get_class_name()} is started, {phone.remote_sftp.get_class_name()} is still not accessible")
+
+                        # print out result on stdout
+                        if not args.backup_state:
+                            state = dict()
+                        state[Control.CONNECTED] = Control.ZEROCONF if zeroconf_accessible else Control.REMOTE
+                        print(StateSerializer.dumps(state))
                     except:
-                        await _stop(state)
+                        await _stop(state, stop_only_started = True)
                         raise
-                    if not args.backup_state:
-                        state = dict()
-                    state[Control.CONNECTED] = Control.ZEROCONF if zeroconf_accessible else Control.REMOTE
-                    print(StateSerializer.dumps(state))
                 else:
-                    if not await phone.zeroconf_sftp.test():
-                        try:
+                    try:
+                        if not await phone.zeroconf_sftp.test():
                             await phone.zeroconf_sftp.start(10, 30)
-                        except:
-                            await _stop(None)
-                            raise
+                    except:
+                        await _stop(None)
+                        raise
             case 'stop':
                 await _stop(StateSerializer.loads(args.restore_state) if args.restore_state else None)
 
@@ -893,7 +956,7 @@ class AutomateControl(Control):
 
             async with Webhooks(Funnel.LOCAL_HOST, funnel.local_port) if funnel else nullcontext() as webhooks:
                 local = Local(local_tailscale)
-                automate_phone_state = AutomatePhoneState(session, webhooks, automate, funnel.external_url) if funnel and webhooks else None
+                automate_phone_state = AutomatePhoneState(session, webhooks, automate, funnel) if funnel and webhooks else None
                 phone = Phone(zeroconf_pftpd, remote_tailscale, remote_pftpd, automate_phone_state)
                 await self.execute(args, local, phone)
 
@@ -912,13 +975,7 @@ async def main():
         await args.ctor().run(args)
 
     except Exception as e:
-        if not args or args.debug:
-            logger.exception(e)
-        else:
-            if hasattr(e, '__notes__'):
-                logger.error("%s: %s", LazyStr(repr, e), LazyStr(", ".join, e.__notes__))
-            else:
-                logger.error(LazyStr(repr, e))
+        logger.exception_or_error(e, args)
 
     return logger.exitcode
 

{prim_ctrl-0.6.0 → prim_ctrl-0.6.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "prim-ctrl"
-version = "0.6.0"
+version = "0.6.2"
 description = "Primitive Ctrl - Remote control of your phone's Primitive FTPd Android SFTP server and optionally Tailscale VPN."
 license = "Apache-2.0"
 authors = ["Laszlo Magyar <lmagyar1973@gmail.com>"]
@@ -18,9 +18,10 @@ packages = [{include = "prim_ctrl"}]
 
 [tool.poetry.dependencies]
 python = "^3.12"
-aiohttp = "^3.11.0"
+aiohttp = "^3.11.10"
 platformdirs = "^4.3.6"
-zeroconf = "^0.136.0"
+zeroconf = "^0.136.2"
+dnspython = "^2.7.0"
 
 [tool.poetry.scripts]
 prim-ctrl = "prim_ctrl.__main__:run"