emerald-hws 0.0.16__py3-none-any.whl → 0.0.18__py3-none-any.whl

emerald_hws/emeraldhws.py

@@ -40,23 +40,29 @@ class EmeraldHWS():
         self.logger = logging.getLogger(__name__)
         self.update_callback = update_callback
         self._state_lock = threading.RLock()  # Thread-safe lock for state operations
-        
+        self._connection_event = threading.Event()  # Event to signal when MQTT connection is established
+        self._connect_lock = threading.Lock()  # Lock to prevent concurrent connect() calls
+        self._mqtt_lock = threading.RLock()  # Lock to protect MQTT client lifecycle operations
+        self._is_connected = False  # Flag to track connection state
+        self.mqttClient = None  # Initialize to None
+
         # Convert minutes to seconds for internal use
         self.connection_timeout = connection_timeout_minutes * 60.0
         self.health_check_interval = health_check_minutes * 60.0 if health_check_minutes > 0 else 0
         self.last_message_time = None
         self.health_check_timer = None
-        
+        self.reconnect_timer = None
+
         # Connection state tracking
         self.connection_state = "initial"  # possible states: initial, connected, failed
         self.consecutive_failures = 0
         self.max_backoff_seconds = 60  # Maximum backoff of 1 minute
-        
+
         # Ensure reasonable minimum values (e.g., at least 5 minutes for connection timeout)
         if connection_timeout_minutes < 5 and connection_timeout_minutes != 0:
             self.logger.warning("emeraldhws: Connection timeout too short, setting to minimum of 5 minutes")
             self.connection_timeout = 5 * 60.0
-        
+
         # Ensure reasonable minimum values for health check (e.g., at least 5 minutes)
         if 0 < health_check_minutes < 5:
             self.logger.warning("emeraldhws: Health check interval too short, setting to minimum of 5 minutes")
@@ -117,84 +123,67 @@ class EmeraldHWS():
         """ Stops an existing MQTT connection and creates a new one
         :param reason: Reason for reconnection (scheduled, health_check, etc.)
         """
-        self.logger.info(f"emeraldhws: awsiot: Reconnecting MQTT connection (reason: {reason})")
-        
-        # Store current temperature values for comparison after reconnect
-        temp_values = {}
-        for properties in self.properties:
-            heat_pumps = properties.get('heat_pump', [])
-            for heat_pump in heat_pumps:
-                hws_id = heat_pump['id']
-                if 'last_state' in heat_pump and 'temp_current' in heat_pump['last_state']:
-                    temp_values[hws_id] = heat_pump['last_state']['temp_current']
-        
-        self.mqttClient.stop()
-        self.connectMQTT()
-        self.subscribeAllHWS()
-        
-        # After reconnection, check if temperatures have changed
-        def check_temp_changes():
-            for properties in self.properties:
-                heat_pumps = properties.get('heat_pump', [])
-                for heat_pump in heat_pumps:
-                    hws_id = heat_pump['id']
-                    if (hws_id in temp_values and 
-                        'last_state' in heat_pump and 
-                        'temp_current' in heat_pump['last_state']):
-                        old_temp = temp_values[hws_id]
-                        new_temp = heat_pump['last_state']['temp_current']
-                        if old_temp != new_temp:
-                            self.logger.info(f"emeraldhws: Temperature changed after reconnect for {hws_id}: {old_temp} → {new_temp}")
-        
-        # Check for temperature changes after a short delay to allow for updates
-        threading.Timer(10.0, check_temp_changes).start()
+        with self._mqtt_lock:
+            self.logger.info(f"emeraldhws: awsiot: Reconnecting MQTT connection (reason: {reason})")
+
+            if self.mqttClient is not None:
+                self.mqttClient.stop()
+                self.mqttClient = None  # Clear the client so a new one can be created
+
+            self.connectMQTT()
+            self.subscribeAllHWS()
+
+            self.logger.info(f"emeraldhws: awsiot: MQTT reconnection completed (reason: {reason})")
 
     def connectMQTT(self):
         """ Establishes a connection to Amazon IOT core's MQTT service
         """
-
-        # Certificate path is available but not currently used in the connection
-        # os.path.join(os.path.dirname(__file__), '__assets__', 'SFSRootCAG2.pem')
-        identityPoolID = self.COGNITO_IDENTITY_POOL_ID
-        region = self.MQTT_HOST.split('.')[2]
-        cognito_endpoint = "cognito-identity." + region + ".amazonaws.com"
-        cognitoIdentityClient = boto3.client('cognito-identity', region_name=region)
-
-        temporaryIdentityId = cognitoIdentityClient.get_id(IdentityPoolId=identityPoolID)
-        identityID = temporaryIdentityId["IdentityId"]
-        self.logger.debug("emeraldhws: awsiot: AWS IoT IdentityID: {}".format(identityID))
-
-        credentials_provider = auth.AwsCredentialsProvider.new_cognito(
-                endpoint=cognito_endpoint,
-                identity=identityID,
-                tls_ctx=io.ClientTlsContext(io.TlsContextOptions()))
-
-        client = mqtt5_client_builder.websockets_with_default_aws_signing(
-            endpoint = self.MQTT_HOST,
-            region = region,
-            credentials_provider = credentials_provider,
-            on_connection_interrupted = self.on_connection_interrupted,
-            on_connection_resumed = self.on_connection_resumed,
-            on_lifecycle_connection_success = self.on_lifecycle_connection_success,
-            on_lifecycle_stopped = self.on_lifecycle_stopped,
-            on_lifecycle_attempting_connect = self.on_lifecycle_attempting_connect,
-            on_lifecycle_disconnection = self.on_lifecycle_disconnection,
-            on_lifecycle_connection_failure = self.on_lifecycle_connection_failure,
-            on_publish_received = self.mqttCallback
-        )
-
-        client.start()
-        self.mqttClient = client
-        
-        # Schedule periodic reconnection using configurable timeout
-        if self.connection_timeout > 0:
-            threading.Timer(self.connection_timeout, self.reconnectMQTT).start()
-        
-        # Start health check timer if enabled
-        if self.health_check_interval > 0:
-            self.health_check_timer = threading.Timer(self.health_check_interval, self.check_connection_health)
-            self.health_check_timer.daemon = True
-            self.health_check_timer.start()
+        with self._mqtt_lock:
+            # If already connected, skip
+            if self.mqttClient is not None:
+                self.logger.debug("emeraldhws: awsiot: MQTT client already exists, skipping connection")
+                return
+
+            # Clear the connection event before starting new connection
+            self._connection_event.clear()
+
+            # Certificate path is available but not currently used in the connection
+            # os.path.join(os.path.dirname(__file__), '__assets__', 'SFSRootCAG2.pem')
+            identityPoolID = self.COGNITO_IDENTITY_POOL_ID
+            region = self.MQTT_HOST.split('.')[2]
+            cognito_endpoint = "cognito-identity." + region + ".amazonaws.com"
+            cognitoIdentityClient = boto3.client('cognito-identity', region_name=region)
+
+            temporaryIdentityId = cognitoIdentityClient.get_id(IdentityPoolId=identityPoolID)
+            identityID = temporaryIdentityId["IdentityId"]
+            self.logger.debug("emeraldhws: awsiot: AWS IoT IdentityID: {}".format(identityID))
+
+            credentials_provider = auth.AwsCredentialsProvider.new_cognito(
+                    endpoint=cognito_endpoint,
+                    identity=identityID,
+                    tls_ctx=io.ClientTlsContext(io.TlsContextOptions()))
+
+            client = mqtt5_client_builder.websockets_with_default_aws_signing(
+                endpoint = self.MQTT_HOST,
+                region = region,
+                credentials_provider = credentials_provider,
+                on_connection_interrupted = self.on_connection_interrupted,
+                on_connection_resumed = self.on_connection_resumed,
+                on_lifecycle_connection_success = self.on_lifecycle_connection_success,
+                on_lifecycle_stopped = self.on_lifecycle_stopped,
+                on_lifecycle_attempting_connect = self.on_lifecycle_attempting_connect,
+                on_lifecycle_disconnection = self.on_lifecycle_disconnection,
+                on_lifecycle_connection_failure = self.on_lifecycle_connection_failure,
+                on_publish_received = self.mqttCallback
+            )
+
+            client.start()
+            self.mqttClient = client
+
+            # Block until connection is established or timeout (30 seconds)
+            if not self._connection_event.wait(timeout=30):
+                self.logger.warning("emeraldhws: awsiot: Connection establishment timed out after 30 seconds")
+                # Continue anyway - the connection may still succeed asynchronously
 
     def mqttDecodeUpdate(self, topic, payload):
         """ Attempt to decode a received MQTT message and direct appropriately
@@ -238,6 +227,8 @@ class EmeraldHWS():
         # Reset failure counter and update connection state
         self.consecutive_failures = 0
         self.connection_state = "connected"
+        # Signal that connection is established
+        self._connection_event.set()
         return
 
     def on_lifecycle_connection_failure(self, lifecycle_connection_failure: mqtt5.LifecycleConnectFailureData):
@@ -247,14 +238,18 @@ class EmeraldHWS():
         error_code = getattr(error, 'code', 'unknown')
         error_name = getattr(error, 'name', 'unknown')
         error_message = str(error)
-        
+
         # Update connection state and increment failure counter
         self.connection_state = "failed"
         self.consecutive_failures += 1
-        
+
         # Log at INFO level since this is important for troubleshooting
         self.logger.info(f"emeraldhws: awsiot: connection failed - Error: {error_name} (code: {error_code}), Message: {error_message}")
-        
+
+        # Log additional error details if available
+        if hasattr(error, '__dict__'):
+            self.logger.debug(f"emeraldhws: awsiot: error details: {error.__dict__}")
+
         # If there's a CONNACK packet available, log its details too
         if hasattr(lifecycle_connection_failure, 'connack_packet') and lifecycle_connection_failure.connack_packet:
             connack = lifecycle_connection_failure.connack_packet
@@ -264,6 +259,17 @@ class EmeraldHWS():
                 self.logger.info(f"emeraldhws: awsiot: MQTT CONNACK reason: {reason_code} - {reason_string}")
             else:
                 self.logger.info(f"emeraldhws: awsiot: MQTT CONNACK reason code: {reason_code}")
+
+            # Log all CONNACK properties if available
+            if hasattr(connack, '__dict__'):
+                self.logger.debug(f"emeraldhws: awsiot: CONNACK details: {connack.__dict__}")
+        else:
+            self.logger.debug("emeraldhws: awsiot: no CONNACK packet available in failure data")
+
+        # Log the exception data structure itself for deeper debugging
+        if hasattr(lifecycle_connection_failure, '__dict__'):
+            self.logger.debug(f"emeraldhws: awsiot: failure data: {lifecycle_connection_failure.__dict__}")
+
         return
 
     def on_lifecycle_stopped(self, lifecycle_stopped_data: mqtt5.LifecycleStoppedData):
@@ -278,23 +284,42 @@ class EmeraldHWS():
         # Extract disconnect reason if available
         reason = "unknown reason"
         if hasattr(lifecycle_disconnect_data, 'disconnect_packet') and lifecycle_disconnect_data.disconnect_packet:
-            reason_code = getattr(lifecycle_disconnect_data.disconnect_packet, 'reason_code', 'unknown')
-            reason_string = getattr(lifecycle_disconnect_data.disconnect_packet, 'reason_string', '')
+            disconnect_packet = lifecycle_disconnect_data.disconnect_packet
+            reason_code = getattr(disconnect_packet, 'reason_code', 'unknown')
+            reason_string = getattr(disconnect_packet, 'reason_string', '')
             reason = f"reason code: {reason_code}" + (f" - {reason_string}" if reason_string else "")
-        
+
+            # Log full disconnect packet details at debug level
+            if hasattr(disconnect_packet, '__dict__'):
+                self.logger.debug(f"emeraldhws: awsiot: disconnect packet details: {disconnect_packet.__dict__}")
+        else:
+            # Log the disconnect data structure if no packet available
+            if hasattr(lifecycle_disconnect_data, '__dict__'):
+                self.logger.debug(f"emeraldhws: awsiot: disconnect data: {lifecycle_disconnect_data.__dict__}")
+
         self.logger.info(f"emeraldhws: awsiot: disconnected - {reason}")
         return
 
     def on_lifecycle_attempting_connect(self, lifecycle_attempting_connect_data: mqtt5.LifecycleAttemptingConnectData):
         """ Log message when attempting connect
         """
-        # Include endpoint information if available
-        endpoint = getattr(lifecycle_attempting_connect_data, 'endpoint', 'unknown')
-        self.logger.debug(f"emeraldhws: awsiot: attempting to connect to {endpoint}")
+        self.logger.debug("emeraldhws: awsiot: attempting to connect")
         return
-        
+
+    def scheduled_reconnect(self):
+        """ Periodic MQTT reconnect - called by timer and reschedules itself
+        """
+        self.reconnectMQTT(reason="scheduled")
+
+        # Reschedule for next time
+        if self.connection_timeout > 0:
+            self.reconnect_timer = threading.Timer(self.connection_timeout, self.scheduled_reconnect)
+            self.reconnect_timer.daemon = True
+            self.reconnect_timer.start()
+
     def check_connection_health(self):
         """ Check if we've received any messages recently, reconnect if not
+        Called by timer and reschedules itself
         """
         if self.last_message_time is None:
             # No messages received yet, don't reconnect
@@ -303,24 +328,24 @@ class EmeraldHWS():
             current_time = time.time()
             time_since_last_message = current_time - self.last_message_time
             minutes_since_last = time_since_last_message / 60.0
-            
+
             if time_since_last_message > self.health_check_interval:
                 # This is an INFO level log because it's an important event
                 self.logger.info(f"emeraldhws: awsiot: No messages received for {minutes_since_last:.1f} minutes, reconnecting")
-                
+
                 # If we're in a failed state, apply exponential backoff
                 if self.connection_state == "failed" and self.consecutive_failures > 0:
                     # Calculate backoff time with exponential increase, capped at max_backoff_seconds
                     backoff_seconds = min(2 ** (self.consecutive_failures - 1), self.max_backoff_seconds)
                     self.logger.info(f"emeraldhws: awsiot: Connection in failed state, applying backoff of {backoff_seconds} seconds before retry (attempt {self.consecutive_failures})")
                     time.sleep(backoff_seconds)
-                
+
                 self.reconnectMQTT(reason="health_check")
             else:
                 # This is a DEBUG level log to avoid cluttering logs
                 self.logger.debug(f"emeraldhws: awsiot: Health check - Last message received {minutes_since_last:.1f} minutes ago")
-        
-        # Schedule next health check
+
+        # Always reschedule next health check
         if self.health_check_interval > 0:
             self.health_check_timer = threading.Timer(self.health_check_interval, self.check_connection_health)
             self.health_check_timer.daemon = True
@@ -339,7 +364,7 @@ class EmeraldHWS():
                 for heat_pump in heat_pumps:
                     if heat_pump['id'] == id:
                         heat_pump['last_state'][key] = value
-        
+
         # Call callback AFTER releasing lock to avoid potential deadlocks
         if self.update_callback is not None:
             self.update_callback()
@@ -348,25 +373,26 @@ class EmeraldHWS():
         """ Subscribes to the MQTT topics for the supplied HWS
         :param id: The UUID of the requested HWS
         """
-        if not self.mqttClient:
-            self.connectMQTT()
+        with self._mqtt_lock:
+            if not self.mqttClient:
+                self.connectMQTT()
 
-        mqtt_topic = "ep/heat_pump/from_gw/{}".format(id)
-        subscribe_future = self.mqttClient.subscribe(
-                subscribe_packet=mqtt5.SubscribePacket(
-                        subscriptions=[mqtt5.Subscription(
-                        topic_filter=mqtt_topic,
-                        qos=mqtt5.QoS.AT_LEAST_ONCE)]))
+            mqtt_topic = "ep/heat_pump/from_gw/{}".format(id)
+            subscribe_future = self.mqttClient.subscribe(
+                    subscribe_packet=mqtt5.SubscribePacket(
+                            subscriptions=[mqtt5.Subscription(
+                            topic_filter=mqtt_topic,
+                            qos=mqtt5.QoS.AT_LEAST_ONCE)]))
 
-        # Wait for subscription to complete
-        subscribe_future.result(20)
+            # Wait for subscription to complete
+            subscribe_future.result(20)
 
     def getFullStatus(self, id):
         """ Returns a dict with the full status of the specified HWS
         :param id: UUID of the HWS to get the status for
         """
 
-        if not self.properties:
+        if not self._is_connected:
             self.connect()
 
         with self._state_lock:
@@ -383,7 +409,7 @@ class EmeraldHWS():
         :param payload: JSON payload to send eg {"switch":1}
         """
 
-        if not self.properties:
+        if not self._is_connected:
             self.connect()
 
         hwsdetail = self.getFullStatus(id)
@@ -401,11 +427,17 @@ class EmeraldHWS():
                payload
               ]
         mqtt_topic = "ep/heat_pump/to_gw/{}".format(id)
-        publish_future = self.mqttClient.publish(
-                mqtt5.PublishPacket(
-                        topic=mqtt_topic,
-                        payload=json.dumps(msg),
-                        qos=mqtt5.QoS.AT_LEAST_ONCE))
+
+        with self._mqtt_lock:
+            if not self.mqttClient:
+                raise Exception("MQTT client not connected")
+            publish_future = self.mqttClient.publish(
+                    mqtt5.PublishPacket(
+                            topic=mqtt_topic,
+                            payload=json.dumps(msg),
+                            qos=mqtt5.QoS.AT_LEAST_ONCE))
+
+        # Wait for publish to complete outside the lock
         publish_future.result(20) # 20 seconds
 
     def turnOn(self, id):
@@ -464,14 +496,35 @@ class EmeraldHWS():
                 work_state = full_status.get("last_state").get("work_state")
                 # work_state: 0=off/idle, 1=actively heating, 2=on but not heating
                 return (work_state == 1)
-            
+
             # Fallback to device_operation_status if work_state not available yet
             # (e.g., before first MQTT update after initialization)
             heating_status = full_status.get("device_operation_status")
             return (heating_status == 1)
-        
+
         return False
 
+    def getHourlyEnergyUsage(self, id):
+        """ Returns energy usage as reported by heater for the previous hour in kWh and a string of format YYYY-MM-DD HH:00 dictating the starting hour for the energy reading
+        :param id: The UUID of the HWS to query
+        """
+        full_status = self.getFullStatus(id)
+        if not full_status:
+            return None
+
+        consumption = full_status.get("consumption_data")
+        if consumption:
+            consumption = json.loads(consumption)
+        else:
+            return None
+
+        current_hour = consumption.get("current_hour")
+        last_data_at = consumption.get("last_data_at")
+        if current_hour is None or last_data_at is None:
+            return None
+
+        return current_hour, last_data_at
+
     def currentMode(self, id):
         """ Returns an integer specifying the current mode (0==boost, 1==normal, 2==quiet)
         :param id: The UUID of the HWS to query
@@ -499,7 +552,7 @@ class EmeraldHWS():
     def listHWS(self):
         """ Returns a list of UUIDs of all discovered HWS
         """
-        if not self.properties:
+        if not self._is_connected:
             self.connect()
 
         hws = []
@@ -526,7 +579,27 @@ class EmeraldHWS():
         """ Connect to the API with the supplied credentials, retrieve HWS details
         :returns: True if successful
         """
-        self.getLoginToken()
-        self.getAllHWS()
-        self.connectMQTT()
-        self.subscribeAllHWS()
+        # Use lock to ensure only one thread can connect at a time
+        with self._connect_lock:
+            # Double-check pattern: check again inside the lock
+            if self._is_connected:
+                self.logger.debug("emeraldhws: Already connected, skipping")
+                return
+
+            self.logger.debug("emeraldhws: Connecting...")
+            self.getLoginToken()
+            self.getAllHWS()
+            self.connectMQTT()
+            self.subscribeAllHWS()
+            self._is_connected = True
+
+            # Start timers ONCE on initial connection
+            if self.connection_timeout > 0:
+                self.reconnect_timer = threading.Timer(self.connection_timeout, self.scheduled_reconnect)
+                self.reconnect_timer.daemon = True
+                self.reconnect_timer.start()
+
+            if self.health_check_interval > 0:
+                self.health_check_timer = threading.Timer(self.health_check_interval, self.check_connection_health)
+                self.health_check_timer.daemon = True
+                self.health_check_timer.start()

{emerald_hws-0.0.16.dist-info → emerald_hws-0.0.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerald_hws
-Version: 0.0.16
+Version: 0.0.18
 Summary: A package to manipulate and monitor Emerald Heat Pump Hot Water Systems
 Author-email: Ross Williamson <ross@inertia.net.nz>
 License-Expression: MIT

emerald_hws-0.0.18.dist-info/RECORD

@@ -0,0 +1,7 @@
+emerald_hws/__init__.py,sha256=uukjQ-kiPYKWvGT3jLL6kJA1DCNAxtw4HlLKqPSypXs,61
+emerald_hws/emeraldhws.py,sha256=_kW1CtCrhfUW7AXhzTdqO7TSSKQe_Oxw9q5v6qiPx_Q,26598
+emerald_hws/__assets__/SFSRootCAG2.pem,sha256=hw9W0AnYrrlbcWsOewAgIl1ULEsoO57Ylu35dCjWcS4,1424
+emerald_hws-0.0.18.dist-info/METADATA,sha256=gmRQmS3lp6IcJbb6jPCAYrn4sY7gY5GWln4a9x8VToY,2534
+emerald_hws-0.0.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+emerald_hws-0.0.18.dist-info/top_level.txt,sha256=ZCiUmnBkDr2n4QVkTet1s_AKiGJjuz3heuCR5w5ZqLY,12
+emerald_hws-0.0.18.dist-info/RECORD,,

emerald_hws-0.0.16.dist-info/RECORD

@@ -1,7 +0,0 @@
-emerald_hws/__init__.py,sha256=uukjQ-kiPYKWvGT3jLL6kJA1DCNAxtw4HlLKqPSypXs,61
-emerald_hws/emeraldhws.py,sha256=in2F-kUyKXGQApvm00L2DH3CSXFj4H_1Vapnxkfa7xM,23416
-emerald_hws/__assets__/SFSRootCAG2.pem,sha256=hw9W0AnYrrlbcWsOewAgIl1ULEsoO57Ylu35dCjWcS4,1424
-emerald_hws-0.0.16.dist-info/METADATA,sha256=X2bALg477JBnh4JUPD8MaEgWJiEjyh0INb5QMbGiHxE,2534
-emerald_hws-0.0.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-emerald_hws-0.0.16.dist-info/top_level.txt,sha256=ZCiUmnBkDr2n4QVkTet1s_AKiGJjuz3heuCR5w5ZqLY,12
-emerald_hws-0.0.16.dist-info/RECORD,,