fix bugs, and advertise on ipv6 too if exists.

Author: James Boulton

dashio/device.py

@@ -125,13 +125,13 @@ def _on_command(self, data):
         if rx_device_id != self.device_id:
             return ""
         try:
-            cntrl_type = data_array[1]
+            ctrl_type = data_array[1]
         except KeyError:
             return ""
-        if cntrl_type in self._device_commands_dict:
-            return self._device_commands_dict[cntrl_type](data_array)
+        if ctrl_type in self._device_commands_dict:
+            return self._device_commands_dict[ctrl_type](data_array)
         try:
-            reply = self.controls_dict[cntrl_type + "\t" + data_array[2]]._message_rx_event(data_array)
+            reply = self.controls_dict[ctrl_type + "\t" + data_array[2]]._message_rx_event(data_array)
             if reply:
                 return reply.replace("{device_id}", self.device_id)
         except (KeyError, IndexError):
@@ -159,14 +159,14 @@ def _make_cfg64(self, data):
         cfg = {}
         cfg["CFG"] = self._cfg
         for control in self.controls_dict.values():
-            if control.cntrl_type == "ALM":
+            if control.ctrl_type == "ALM":
                 continue
-            if control.cntrl_type in ("BLE"):
-                cfg[control.cntrl_type] = control.get_cfg64(data)
+            if control.ctrl_type in ("BLE"):
+                cfg[control.ctrl_type] = control.get_cfg64(data)
                 continue
-            if control.cntrl_type not in cfg:
-                cfg[control.cntrl_type] = []
-            cfg[control.cntrl_type].extend(control.get_cfg64(data))
+            if control.ctrl_type not in cfg:
+                cfg[control.ctrl_type] = []
+            cfg[control.ctrl_type].extend(control.get_cfg64(data))
         c64_json = encode_cfg64(cfg)
         reply += c64_json + "\n"
         return reply
@@ -180,9 +180,9 @@ def _make_cfg(self, data):
         reply = self._device_id_str + f"\tCFG\t{dashboard_id}\tDVCE\t{json.dumps(self._cfg)}\n"
         dvvw_str = ""
         for control in self.controls_dict.values():
-            if control.cntrl_type == "ALM":
+            if control.ctrl_type == "ALM":
                 continue
-            if control.cntrl_type == "DVVW":
+            if control.ctrl_type == "DVVW":
                 cfg_list = control.get_cfg(data)
                 for cfg in cfg_list:
                     dvvw_str += self._device_id_str + cfg
@@ -273,7 +273,7 @@ def add_control(self, iot_control):
                 iot_control.add_transmit_message_callback(self._send_data)
         except AttributeError:
             pass
-        key = f"{iot_control.cntrl_type}\t{iot_control.control_id}"
+        key = f"{iot_control.ctrl_type}\t{iot_control.control_id}"
 
         if key not in self.controls_dict:
             if isinstance(iot_control, DeviceView):
@@ -309,7 +309,7 @@ def remove_control(self, iot_control):
         """
         if isinstance(iot_control, DeviceView):
             self._cfg["numDeviceViews"] -= 1
-        key = f"{iot_control.cntrl_type}\t{iot_control.control_id}"
+        key = f"{iot_control.ctrl_type}\t{iot_control.control_id}"
         if key in self.controls_dict:
             del self.controls_dict[key]
 

dashio/ip.py

@@ -32,18 +32,32 @@ def get_local_ip_v4_address():
         test_s.connect(('10.255.255.255', 1))
         i_address = test_s.getsockname()[0]
     except socket.error:
-        i_address = '127.0.0.1'
+        i_address = ''
     finally:
         test_s.close()
     return i_address
 
 
 def get_local_ip_v6_address():
     """Find the external IP address."""
-    i_address = socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET6)[1][4][0]
+    test_s = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
+    try:
+        # doesn't even have to be reachable
+        test_s.connect(('google.com', 8888))
+        i_address = test_s.getsockname()[0]
+    except socket.error:
+        return ''
     return i_address
 
 
+def get_local_ip_addresses():
+    """Retrieve local IPv4 and IPv6 addresses."""
+    ipv4 = get_local_ip_v4_address()
+    ipv6 = get_local_ip_v6_address()
+    return ipv4, ipv6
+
+
 def is_port_in_use(ip_address, port):
+    "Checks if port is in use"
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as port_s:
         return port_s.connect_ex((ip_address, port)) == 0

dashio/load_config.py

@@ -123,7 +123,7 @@ def encode_cfg64(cfg: dict) -> str:
         str: the cfg encoded as C64 format
     """
     cfg_json = json.dumps(cfg)
-    compress = zlib.compressobj(9, zlib.DEFLATED, -9, zlib.DEF_MEM_LEVEL, zlib.Z_DEFAULT_STRATEGY)
+    compress = zlib.compressobj(9, zlib.DEFLATED, -15, zlib.DEF_MEM_LEVEL, zlib.Z_DEFAULT_STRATEGY)
     tmp_z = compress.compress(cfg_json.encode())
     tmp_z += compress.flush()
     return base64.b64encode(tmp_z).decode()

dashio/tcp_connection.py

@@ -85,12 +85,15 @@ def __init__(self, ip_address="*", port=5650, use_zero_conf=True, context: zmq.C
         self.b_zmq_connection_uuid = self.zmq_connection_uuid.encode('utf-8')
         self.use_zeroconf = use_zero_conf
 
+        self.local_ipv4 = ''
+        self.local_ipv6 = ''
         if ip_address == "*":
-            self.local_ip = ip.get_local_ip_v4_address()
+            self.local_ipv4 = ip.get_local_ip_v4_address()
+            self.local_ipv6 = ip.get_local_ip_v6_address()
         else:
-            self.local_ip = ip_address
+            self.local_ipv4 = ip_address
         self.local_port = port
-        while ip.is_port_in_use(self.local_ip, self.local_port) and use_zero_conf:
+        while ip.is_port_in_use(self.local_ipv4, self.local_port) and use_zero_conf:
             # increment port until we find one that is free.
             self.local_port += 1
         self.ext_url = "tcp://*:" + str(self.local_port)
@@ -111,7 +114,7 @@ def __init__(self, ip_address="*", port=5650, use_zero_conf=True, context: zmq.C
         self.tx_zmq_pub.bind(CONNECTION_PUB_URL.format(id=self.zmq_connection_uuid))
 
         if self.use_zeroconf:
-            self.z_conf = ZeroconfService(self.zmq_connection_uuid, self.local_ip, self.local_port, self.context)
+            self.z_conf = ZeroconfService(self.zmq_connection_uuid, self.local_ipv4, self.local_ipv6, self.local_port, self.context)
 
         self.start()
 

dashio/zeroconf_service.py

@@ -112,15 +112,27 @@ def _zconf_update_zmq(self):
             'connectionUUID': self.connection_uuid,
             'deviceID': ','.join(self.device_id_list)
         }
-        zconf_info = ServiceInfo(
-            self.fully_qualified_name,
-            f"{self.connection_uuid}._DashIO._tcp.local.",
-            addresses=[socket.inet_aton(self.local_ip_address)],
-            port=self.local_port,
-            properties=zconf_desc,
-            server=self.host_name + ".",
-        )
-        self.zeroconf.update_service(zconf_info)
+        if self.local_ipv4_address:
+            zconf_ipv4_info = ServiceInfo(
+                self.fully_qualified_name,
+                f"{self.connection_uuid}._DashIO._tcp.local.",
+                addresses=[socket.inet_aton(self.local_ipv4_address)],
+                port=self.local_port,
+                properties=zconf_desc,
+                server=self.host_name + ".",
+            )
+            self.zeroconf.update_service(zconf_ipv4_info)
+
+        if self.local_ipv6_address:
+            zconf_ipv6_info = ServiceInfo(
+                self.fully_qualified_name,
+                f"{self.connection_uuid}._DashIO._tcp.local.",
+                addresses=[socket.inet_pton(socket.AF_INET6, self.local_ipv6_address)],
+                port=self.local_port,
+                properties=zconf_desc,
+                server=self.host_name + ".",
+            )
+            self.zeroconf.update_service(zconf_ipv6_info)
 
     def add_device(self, device_id):
         """Add a device_id to the advertiser"""
@@ -139,7 +151,7 @@ def close(self):
         self.zeroconf.unregister_all_services()
         self.zeroconf.close()
 
-    def __init__(self, connection_uuid: str, ip_address: str, port: int, context: zmq.Context | None = None):
+    def __init__(self, connection_uuid: str, ipv4_address: str, ipv6_address: str, port: int, context: zmq.Context | None = None):
         threading.Thread.__init__(self, daemon=True)
         self.context = context or zmq.Context.instance()
         self.connection_uuid = connection_uuid
@@ -148,7 +160,8 @@ def __init__(self, connection_uuid: str, ip_address: str, port: int, context: zm
         host_list = host_name.split(".")
         # rename for .local mDNS advertising
         self.host_name = f"{host_list[0]}.local"
-        self.local_ip_address = ip_address
+        self.local_ipv4_address = ipv4_address
+        self.local_ipv6_address = ipv6_address
         self.local_port = port
         self.zeroconf = Zeroconf()
         self.listener = ZeroConfDashTCPListener(self.fully_qualified_name, self.connection_uuid, self.context)
@@ -161,12 +174,24 @@ def run(self):
             'connectionUUID': self.connection_uuid,
             'deviceID': ','.join(self.device_id_list)
         }
-        zconf_info = ServiceInfo(
-            self.fully_qualified_name,
-            f"{self.connection_uuid}._DashIO._tcp.local.",
-            addresses=[socket.inet_aton(self.local_ip_address)],
-            port=self.local_port,
-            properties=zconf_desc,
-            server=self.host_name + ".",
-        )
-        self.zeroconf.update_service(zconf_info)
+        if self.local_ipv4_address:
+            zconf_ipv4_info = ServiceInfo(
+                self.fully_qualified_name,
+                f"{self.connection_uuid}._DashIO._tcp.local.",
+                addresses=[socket.inet_aton(self.local_ipv4_address)],
+                port=self.local_port,
+                properties=zconf_desc,
+                server=self.host_name + ".",
+            )
+            self.zeroconf.update_service(zconf_ipv4_info)
+
+        if self.local_ipv6_address:
+            zconf_ipv6_info = ServiceInfo(
+                self.fully_qualified_name,
+                f"{self.connection_uuid}._DashIO._tcp.local.",
+                addresses=[socket.inet_pton(socket.AF_INET6, self.local_ipv6_address)],
+                port=self.local_port,
+                properties=zconf_desc,
+                server=self.host_name + ".",
+            )
+            self.zeroconf.update_service(zconf_ipv6_info)