Merge pull request #1 from micropython/master

Syncing with Original

Author: mad474

umqtt.robust/example_sub_robust.py

@@ -0,0 +1,41 @@
+import time
+from umqtt.robust import MQTTClient
+
+
+def sub_cb(topic, msg):
+    print((topic, msg))
+
+
+c = MQTTClient("umqtt_client", "localhost")
+# Print diagnostic messages when retries/reconnects happens
+c.DEBUG = True
+c.set_callback(sub_cb)
+# Connect to server, requesting not to clean session for this
+# client. If there was no existing session (False return value
+# from connect() method), we perform the initial setup of client
+# session - subscribe to needed topics. Afterwards, these
+# subscriptions will be stored server-side, and will be persistent,
+# (as we use clean_session=False).
+#
+# There can be a problem when a session for a given client exists,
+# but doesn't have subscriptions a particular application expects.
+# In this case, a session needs to be cleaned first. See
+# example_reset_session.py for an obvious way how to do that.
+#
+# In an actual application, it's up to its developer how to
+# manage these issues. One extreme is to have external "provisioning"
+# phase, where initial session setup, and any further management of
+# a session, is done by external tools. This allows to save resources
+# on a small embedded device. Another extreme is to have an application
+# to perform auto-setup (e.g., clean session, then re-create session
+# on each restart). This example shows mid-line between these 2
+# approaches, where initial setup of session is done by application,
+# but if anything goes wrong, there's an external tool to clean session.
+if not c.connect(clean_session=False):
+    print("New session being set up")
+    c.subscribe(b"foo_topic")
+
+while 1:
+    c.wait_msg()
+
+c.disconnect()

umqtt.robust/umqtt/robust.py

@@ -0,0 +1,43 @@
+import utime
+from . import simple
+
+class MQTTClient(simple.MQTTClient):
+
+    DELAY = 2
+    DEBUG = False
+
+    def delay(self, i):
+        utime.sleep(self.DELAY)
+
+    def log(self, in_reconnect, e):
+        if self.DEBUG:
+            if in_reconnect:
+                print("mqtt reconnect: %r" % e)
+            else:
+                print("mqtt: %r" % e)
+
+    def reconnect(self):
+        i = 0
+        while 1:
+            try:
+                return super().connect(False)
+            except OSError as e:
+                self.log(True, e)
+                i += 1
+                self.delay(i)
+
+    def publish(self, topic, msg, retain=False, qos=0):
+        while 1:
+            try:
+                return super().publish(topic, msg, retain, qos)
+            except OSError as e:
+                self.log(False, e)
+            self.reconnect()
+
+    def wait_msg(self):
+        while 1:
+            try:
+                return super().wait_msg()
+            except OSError as e:
+                self.log(False, e)
+            self.reconnect()

umqtt.simple/README.rst

@@ -46,7 +46,9 @@ API reference
 Taking into account API traits described above, umqtt pretty closely
 follows MQTT control operations, and maps them to class methods:
 
-* ``connect()`` - Connect to a server.
+* ``connect(...)`` - Connect to a server. Returns True if this connection
+  uses persisten session stored on a server (this will be always False if
+  clean_session=True argument is used (default)).
 * ``disconnect()`` - Disconnect from a server, release resources.
 * ``ping()`` - Ping server (response is processed automatically by wait_msg()).
 * ``publish()`` - Publish a message.

umqtt.simple/umqtt/simple.py

@@ -55,16 +55,20 @@ def ping(self):
         self.sock.close()
 
     def publish(self, topic, msg, retain=False, qos=0):
-        pkt = bytearray(b"\x30\0\0")
+        pkt = bytearray(b"\x30\0\0\0")
         pkt[0] |= qos << 1 | retain
         sz = 2 + len(topic) + len(msg)
         if qos > 0:
             sz += 2
-        assert sz <= 16383
-        pkt[1] = (sz & 0x7f) | 0x80
-        pkt[2] = sz >> 7
+        assert sz < 2097152
+        i = 1
+        while sz > 0x7f:
+            pkt[i] = (sz & 0x7f) | 0x80
+            sz >>= 7
+            i += 1
+        pkt[i] = sz
         #print(hex(len(pkt)), hexlify(pkt, ":"))
-        self.sock.write(pkt)
+        self.sock.write(pkt, i + 1)
         self._send_str(topic)
         if qos > 0:
             self.pid += 1
@@ -108,9 +112,9 @@ def subscribe(self, topic, qos=0):
     # messages processed internally.
     def wait_msg(self):
         res = self.sock.read(1)
+        self.sock.setblocking(True)
         if res is None:
             return None
-        self.sock.setblocking(True)
         if res == b"":
             raise OSError(-1)
         if res == b"\xd0":  # PINGRESP

upysh/metadata.txt

@@ -1,6 +1,6 @@
 srctype = micropython-lib
 type = module
-version = 0.4
+version = 0.5
 author = Paul Sokolovsky
 desc = Minimalistic file shell using native Python syntax.
 long_desc = Minimalistic file shell using native Python syntax.

upysh/setup.py

@@ -6,7 +6,7 @@
 
 
 setup(name='micropython-upysh',
-      version='0.4',
+      version='0.5',
       description='Minimalistic file shell using native Python syntax.',
       long_description='Minimalistic file shell using native Python syntax.',
       url='https://github.com/micropython/micropython/issues/405',

upysh/upysh.py

@@ -25,8 +25,17 @@ def __repr__(self):
     def __call__(self):
         return self.__repr__()
 
+class CLEAR:
+    def __repr__(self):
+        return "\x1b[2J\x1b[H"
+
+    def __call__(self):
+        return self.__repr__()
+
+
 pwd = PWD()
 ls = LS()
+clear = CLEAR()
 
 cd = os.chdir
 mkdir = os.mkdir
@@ -66,7 +75,8 @@ def __repr__(self):
 
 upysh commands:
 pwd, cd("new_dir"), ls, ls(...), head(...), cat(...)
-newfile(...), rm(...), mkdir(...), rmdir(...)
+newfile(...), rm(...), mkdir(...), rmdir(...),
+clear
 """)
 
 man = Man()