adding repo contents from micropython-uasyncio-webexample

Author: marcidy

README.rst

@@ -0,0 +1,46 @@
+Tiny Asyncio HTTP server for micropython
+========================================
+
+Who DOESN'T need to serve some files over http on their micropython device?
+
+This does it with asyncio and with extremely limited functionality.
+
+The goal here is not to be fully featured, but to aid in settings up basic services on a device
+which can then host small things like configuring a wifi connection, basic diagnostics, etc.
+
+Example
+-------
+If you want to see it in action, it's part of a worked example here:
+http://github.com/marcidy/micropython-uasyncio-webexample.
+
+http/web.py
+-----------
+`server(reader, writer)` is used with `uasyncio.start_server(server, host, port)` and is
+called on new connections.
+
+The server is really chatty at the moment with lots of print statements so you can see what's
+going on.  I'll quiet those with a debug flag at some point.
+
+The `route(location, resource)` function is used to match the requested route (say 'static/jquery-min.js`)
+with the resource on the filesytem that will be served (say '/www/jquery-3.5.1.js').  `route` is synchronous, 
+but turns the resource into an async coroutine with the `pre_route` function.  This is a bit convoluted,
+but will allow expansion over time.  The result of calling `route` is that the module dict `routes` is
+population with pairs like::
+
+    routes = {
+        b'/': b'/www/page.htm',
+        b'/style.css': b'/www/style.css',
+        b'/static/jquery-min.js': b'/www/jquery-3.5.1.js'
+    }
+
+Note that the entries are all decoded strings (b"").  This works better with the raw data coming over
+the socket.  Note we don't serve right off the filesystem.  This lets you control what can be accessed.
+
+`send_file(writer, file)` serves the item located at `file` via a chunked transfer.  This can be html, js,
+anything.  It's quite simple, however.  It's sufficient to send over an html page and the jquery library
+and do some fancy stuff client side instead of server side.
+
+Enhancements welcome, but we're trying to keep it small, so it realy ought to be something you can't do
+but is realy useful.
+
+Or ever better, make it modular to add handlers on the fly and have a repo of handlers.

http/web.py

@@ -0,0 +1,88 @@
+import gc
+import re
+import os
+
+
+url_pat = re.compile(
+    r'^(([^:/\\?#]+):)?' +  # scheme                # NOQA
+    r'(//([^/\\?#]*))?' +   # user:pass@host:port   # NOQA
+    r'([^\\?#]*)' +         # route                 # NOQA
+    r'(\\?([^#]*))?' +      # query                 # NOQA
+    r'(#(.*))?')            # fragment              # NOQA
+
+
+def pre_route(file):
+
+    async def _func(writer):
+        await send_file(writer, file)
+
+    return _func
+
+
+routes = {}
+
+# b'/': pre_route('/www/page.htm'),
+# b'/static/jquery.js': pre_route('/www/jquery-3.5.1.min.js')}
+
+
+def route(location, resource):
+    global routes
+    routes[location] = pre_route(resource)
+
+
+async def send_file(writer, file):
+    fstat = os.stat(file)
+    fsize = fstat[6]
+
+    writer.write(b'HTTP/1.1 200 OK\r\n')
+    writer.write(b'Content-Type: text/html\r\n')
+    writer.write('Content-Length: {}\r\n'.format(fsize).encode('utf-8'))
+    writer.write(b'Accept-Ranges: none\r\n')
+    writer.write(b'Transfer-Encoding: chunked\r\n')
+    writer.write(b'\r\n')
+    await writer.drain()
+    gc.collect()
+    max_chunk_size = 1024
+    with open(file, 'rb') as f:
+        for x in range(0, fsize, max_chunk_size):
+            chunk_size = min(max_chunk_size, fsize-x)
+            chunk_header = "{:x}\r\n".format(chunk_size).encode('utf-8')
+            writer.write(chunk_header)
+            writer.write(f.read(chunk_size))
+            writer.write(b'\r\n')
+            await writer.drain()
+            gc.collect()
+    writer.write(b"0\r\n")
+    writer.write(b"\r\n")
+    await writer.drain()
+    writer.close()
+    await writer.wait_closed()
+    gc.collect()
+
+
+async def server(reader, writer):
+    req = await reader.readline()
+    print(req)
+    method, uri, proto = req.split(b" ")
+    m = re.match(url_pat, uri)
+    route_req = m.group(5)
+
+    while True:
+        h = await reader.readline()
+        if h == b"" or h == b"\r\n":
+            break
+        print(h)
+
+    print("route: {}".format(route_req.decode('utf-8')))
+    test = route_req in routes
+    print("Route found?: {}".format(test))
+
+    if route_req in routes:
+        await routes[route_req](writer)
+    else:
+        writer.write(b'HTTP/1.0 404 Not Found\r\n')
+        writer.write(b'\r\n')
+        await writer.drain()
+        writer.close()
+        await writer.wait_closed()
+    gc.collect()