prim-ctrl 0.8.3__tar.gz → 0.8.5__tar.gz

{prim_ctrl-0.8.3 → prim_ctrl-0.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prim-ctrl
-Version: 0.8.3
+Version: 0.8.5
 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.3 → prim_ctrl-0.8.5}/prim_ctrl/__main__.py

@@ -44,13 +44,19 @@ class LevelFormatter(logging.Formatter):
         return self.formatters.get(record.levelno, self.default_formatter).format(record)
 
 class Logger(logging.Logger):
+    timestamp: bool = False
+
+    @staticmethod
+    def setConfiguration(timestamp: bool):
+        Logger.timestamp = timestamp
+
     def __init__(self, name, level = logging.NOTSET):
         super().__init__(name, level)
-        self.exitcode = 0
+        self.addHandler(logging.StreamHandler(sys.stderr))
+        self.configure()
 
-    def prepare(self, timestamp: bool, silent: bool):
-        handler = logging.StreamHandler(sys.stderr)
-        handler.setFormatter(
+    def configure(self):
+        formatter = (
             LevelFormatter(
                 {
                     logging.WARNING: '%(asctime)s %(message)s',
@@ -58,7 +64,7 @@ class Logger(logging.Logger):
                     logging.DEBUG: '%(asctime)s %(levelname)s %(message)s',
                 },
                 '%(asctime)s %(name)s: %(levelname)s: %(message)s')
-            if timestamp else
+            if Logger.timestamp else
             LevelFormatter(
                 {
                     logging.WARNING: '%(message)s',
@@ -67,9 +73,16 @@ class Logger(logging.Logger):
                 },
                 '%(name)s: %(levelname)s: %(message)s')
         )
-        self.addHandler(handler)
-        if self.level == logging.NOTSET:
-            self.setLevel(logging.WARNING if silent else logging.INFO)
+        for handler in self.handlers:
+            handler.setFormatter(formatter)
+
+class MainLogger(Logger):
+    def __init__(self, name, level = logging.NOTSET):
+        super().__init__(name, level)
+        self.exitcode = 0
+
+    def setConfiguration(self, level: int):
+        self.setLevel(level)
 
     def exception_or_error(self, e: Exception):
         if self.level == logging.NOTSET or self.level == logging.DEBUG:
@@ -109,7 +122,7 @@ class LazyStr:
                 self.result = str(self.func)
         return self.result
 
-logger = Logger(Path(sys.argv[0]).name)
+logger = MainLogger(Path(sys.argv[0]).name)
 
 ########
 
@@ -727,8 +740,10 @@ class Funnel(Pingable):
         self.external_port = external_port
         self.external_url = f'https://{machine_name}.{tailscale.tailnet}:{external_port}{local_path}'
         self.local_tailscale = local_tailscale
+        self.external_public_dns_resolver_address = None
         self.external_public_dns_resolver = None
-        self.external_tailscale_dns_resolvers = None
+        self.external_tailscale_dns_resolver_addresses = None
+        self.external_tailscale_dns_resolver = None
 
     async def wait_for(self, available: bool, timeout: float):
         self._sleepcounter = 0
@@ -737,25 +752,33 @@ 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)
         # first try at Tailscale's DNSs, if they don't know, we should not resolve at a public DNS and cache nxdomain for 5 minutes
-        if self.external_tailscale_dns_resolvers is None:
+        if self.external_tailscale_dns_resolver_addresses is None:
             resolvers = [await self.local_tailscale.external_tailscale_dns_resolver()]
             resolvers.extend(await self._external_tailscale_dns_resolvers())
-            self.external_tailscale_dns_resolvers = [ExternalDnsResolver(resolver) for resolver in resolvers]
+            self.external_tailscale_dns_resolver_addresses = resolvers
+        resolver = self.external_tailscale_dns_resolver
+        if resolver is None:
+            resolver = ExternalDnsResolver(self.external_tailscale_dns_resolver_addresses[0])
         try:
-            _answer = await self.external_tailscale_dns_resolvers[0].resolve(self.external_name, self.external_port)
+            _answer = await resolver.resolve(self.external_name, self.external_port)
         except Exception as e:
-            logger.debug("Resolving at Tailscale's external DNS %s has failed: %s", self.external_tailscale_dns_resolvers[0].where, LazyStr(exception_repr, e))
+            logger.debug("Resolving at Tailscale's external DNS %s has failed: %s", self.external_tailscale_dns_resolver_addresses[0], LazyStr(exception_repr, e))
             # move current resolver to the end of the list
-            self.external_tailscale_dns_resolvers.append(self.external_tailscale_dns_resolvers.pop(0))
+            self.external_tailscale_dns_resolver_addresses.append(self.external_tailscale_dns_resolver_addresses.pop(0))
             return False
+        self.external_tailscale_dns_resolver = resolver
         # 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())
+        if self.external_public_dns_resolver_address is None:
+            self.external_public_dns_resolver_address = await self.local_tailscale.external_public_dns_resolver()
+        resolver = self.external_public_dns_resolver
+        if resolver is None:
+            resolver = ExternalDnsResolver(self.external_public_dns_resolver_address)
         try:
-            _answer = await self.external_public_dns_resolver.resolve(self.external_name, self.external_port)
+            _answer = await resolver.resolve(self.external_name, self.external_port)
         except Exception as e:
             logger.debug("Resolving at public external DNS has failed: %s", LazyStr(exception_repr, e))
             return False
+        self.external_public_dns_resolver = resolver
         return True
 
     async def _sleep_while_wait(self, available: bool):
@@ -1158,9 +1181,11 @@ class Control:
 
     @staticmethod
     def prepare(args: argparse.Namespace):
-        if args.debug:
-            logger.setLevel(logging.DEBUG)
-        logger.prepare(args.timestamp or args.debug, args.silent)
+        Logger.setConfiguration(args.timestamp or args.debug)
+        logging.setLoggerClass(Logger)
+        logger.setConfiguration(
+            logging.DEBUG if args.debug else logging.WARNING if args.silent else logging.INFO) #NOSONAR(S3358)
+        logger.configure()
 
         if args.accept_cellular and args.intent != 'start':
             raise ValueError("The --accept-cellular options can be enabled only for the start intent")

{prim_ctrl-0.8.3 → prim_ctrl-0.8.5}/pyproject.toml

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