Update Pybytes to version 1.0.0

Author: Xykon

esp32/frozen/Base/_OTA.py

@@ -1,3 +1,11 @@
+'''
+Copyright (c) 2019, Pycom Limited.
+This software is licensed under the GNU GPL version 3 or any
+later version, with permitted additional terms. For more information
+see the Pycom Licence v1.0 document supplied with this file, or
+available at https://www.pycom.io/opensource/licensing
+'''
+
 import network
 import socket
 import ssl

esp32/frozen/Base/_flash_control_OTA.py

@@ -1,9 +1,18 @@
+'''
+Copyright (c) 2019, Pycom Limited.
+This software is licensed under the GNU GPL version 3 or any
+later version, with permitted additional terms. For more information
+see the Pycom Licence v1.0 document supplied with this file, or
+available at https://www.pycom.io/opensource/licensing
+'''
+
 import os
 try:
     from pybytes_debug import print_debug
 except:
     from _pybytes_debug import print_debug
 
+
 class FCOTA:
     def __init__(self):
         pass

esp32/frozen/Base/_mqtt.py

@@ -1,112 +1,142 @@
-import time
+'''
+Copyright (c) 2019, Pycom Limited.
+This software is licensed under the GNU GPL version 3 or any
+later version, with permitted additional terms. For more information
+see the Pycom Licence v1.0 document supplied with this file, or
+available at https://www.pycom.io/opensource/licensing
+'''
+
+try:
+    from mqtt_core import MQTTCore as mqtt_core
+except:
+    from _mqtt_core import MQTTCore as mqtt_core
+
+try:
+    from pybytes_constants import MQTTConstants as mqttConst
+except:
+    from _pybytes_constants import MQTTConstants as mqttConst
+
 try:
-    import mqtt_core
+    from pybytes_debug import print_debug
 except:
-    import _mqtt_core as mqtt_core
+    from _pybytes_debug import print_debug
+
+import time
 
 
 class MQTTClient:
 
-    def __init__(self, client_id, server, mqtt_download_topic, port=0, user=None, password=None, keepalive=0, ssl=False,
-                 ssl_params={}, reconnect=True):
+    def __init__(
+                self, client_id, server, mqtt_download_topic,
+                pybytes_protocol, port=0, user=None, password=None,
+                keepalive=0, ssl=False,
+                ssl_params={}, reconnect=True
+            ):
+        if port == 0:
+            self.__port = 8883 if ssl else 1883
+        else:
+            self.__port = port
         self.__reconnect = reconnect
         self.__reconnect_count = 0
         self.__reconnecting = False
         self.__server = server
         self.__mqtt_download_topic = mqtt_download_topic
-        self.__mqtt = mqtt_core.MQTTClient(client_id, server, port, user, password, keepalive,
-                                           ssl, ssl_params)
+        self.__pybytes_protocol = pybytes_protocol
+        self.__clientId = client_id
+        self.__user = user
+        self.__password = password
+        self.init_mqtt_core()
+
+    def init_mqtt_core(self):
+        self.__mqtt = mqtt_core(
+                self.__clientId,
+                True,
+                mqttConst.MQTTv3_1_1,
+                receive_timeout=500,
+                reconnectMethod=self.reconnect
+            )
+        self.__mqtt.configEndpoint(self.__server, self.__port)
+        self.__mqtt._user = self.__user
+        self.__mqtt._password = self.__password
 
     def getError(self, x):
         """Return a human readable error instead of its code number"""
 
-        # This errors are thrown by connect function, I wouldn't be able to find
+        # This errors are thrown by connect function,
+        # I wouldn't be able to find
         # anywhere a complete list of these error codes
         ERRORS = {
-            '-1': 'MQTTClient: Can\'t connect to MQTT server: "{}"'.format(self.__server),
-            '-4': 'MQTTClient: Bad credentials when connecting to MQTT server: "{}"'.format(self.__server),
-            '-9984': 'MQTTClient: Invalid certificate validation when connecting to MQTT server: "{}"'.format(self.__server)
+            '-1': 'MQTTClient: Can\'t connect to MQTT server: "{}"'.format(self.__server), # noqa
+            '-4': 'MQTTClient: Bad credentials when connecting to MQTT server: "{}"'.format(self.__server), # noqa
+            '-9984': 'MQTTClient: Invalid certificate validation when connecting to MQTT server: "{}"'.format(self.__server) # noqa
         }
         message = str(x)
-        return ERRORS.get(str(x), 'Unknown error while connecting to MQTT server ' + message)
+        return ERRORS.get(
+            str(x),
+            'Unknown error while connecting to MQTT server {}'.format(message)
+        )
 
     def connect(self, clean_session=True):
         i = 0
         while 1:
             try:
-                return self.__mqtt.connect(clean_session)
-            except OSError as e:
-                print(self.getError(e))
+                return self.__mqtt.connect()
+            except OSError:
                 if (not self.__reconnect):
                     raise Exception('Reconnection Disabled.')
                 i += 1
                 time.sleep(i)
 
-    def set_callback(self, f):
-        self.__mqtt.set_callback(f)
+    def set_callback(self, mqtt_client, message):
+        self.__pybytes_protocol.__process_recv_message(message)
 
     def subscribe(self, topic, qos=0):
-        self.__mqtt.subscribe(topic, qos)
-
-    def check_msg(self):
-        while 1:
-            time_before_retry = 10
-            if self.__reconnecting == False:
-                try:
-                    return self.__mqtt.check_msg()
-                except OSError as e:
-                    print("Error check_msg", e)
-
-                if (not self.__reconnect):
-                    raise Exception('Reconnection Disabled.')
-                self.reconnect()
-                break
-            else:
-                time.sleep(time_before_retry)
+        self.__mqtt.subscribe(topic, qos, self.set_callback)
 
+    def unsubscribe(self, topic):
+        return self.__mqtt.unsubscribe(topic)
 
     def reconnect(self):
         if self.__reconnecting:
             return
+
+        self.init_mqtt_core()
+
         while True:
-            self.__reconnect_count +=  1
+            self.__reconnect_count += 1
             self.__reconnecting = True
             try:
-                self.__mqtt.connect()
+                if not self.__mqtt.connect():
+                    time.sleep(self.__reconnect_count)
+                    continue
                 self.subscribe(self.__mqtt_download_topic)
-                self.__reconnect_count=0
-                print('Reconnected to MQTT server: "{}"'.format(self.__server))
+                self.__reconnect_count = 0
                 self.__reconnecting = False
                 break
             except OSError:
-                print("Reconnecting failed, will retry in {} seconds".format(self.__reconnect_count))
                 time.sleep(self.__reconnect_count)
 
-    def publish(self, topic, msg, retain=False, qos=0):
+    def publish(self, topic, msg, retain=False, qos=0, priority=False):
         while 1:
-            if self.__reconnecting == False:
+            if not self.__reconnecting:
                 try:
-                    return self.__mqtt.publish(topic, msg, retain, qos)
+                    # Disable retain for publish by now
+                    return self.__mqtt.publish(
+                        topic,
+                        msg,
+                        qos,
+                        False,
+                        priority=priority
+                    )
                 except OSError as e:
-                    print("Error publish", e)
+                    print_debug(2, "Error publish", e)
 
                 if (not self.__reconnect):
                     raise Exception('Reconnection Disabled.')
                 self.reconnect()
-                break
+                raise Exception('Error publish.')
             else:
                 time.sleep(10)
 
-    def wait_msg(self):
-        while 1:
-            try:
-                return self.__mqtt.wait_msg()
-            except OSError as e:
-                print("Error wait_msg {}".format(e))
-
-            if (not self.__reconnect):
-                raise Exception('Reconnection Disabled.')
-            self.reconnect()
-
     def disconnect(self):
         self.__mqtt.disconnect()