ESPWebServer.py

"""A simple HTTP server that only accept GET request
It adopt the programming style of ESP8266WebServer 
library in ESP8266 Arduino Core
"""

import network
import machine
import socket
import uselect
import os

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# Use for checking a new client connection
poller = uselect.poll()
# Dict for registed GET handlers of all paths
getHandlers = {}
# Dict for registed POST handlers of all paths
postHandlers = {}
# Dict for registed PUT handlers of all paths
putHandlers = {}
# Function of handler for request not found
notFoundHandler = None
# The path to the web documents on MicroPython filesystem
docPath = "/"
# Data for template
tplData = {}
# Max. POST/PUT-Data size
maxContentLength = 1024

# MIME types
mimeTypes = {
    ".css":"text/css",
    ".jpg":"image/jpg",
    ".png":"image/png",
}

def begin(port=80):
    """Function to start http server
    """
    global server, poller
    server.bind(('0.0.0.0', port))
    server.listen(1)
    # Register for checking new client connection
    poller.register(server, uselect.POLLIN)

def close():
    """Function to stop http server
    """
    poller.unregister(server)
    server.close()

def handleClient():
    """Check for new client connection and process the request
    """
    global server, poller
    # Note:don't call poll() with 0, that would randomly cause
    # reset with "Fatal exception 28(LoadProhibitedCause)" message
    res = poller.poll(1)
    if res:  # There's a new client connection
        (socket, sockaddr) = server.accept()
        socket.settimeout(0.02) # set timeout for readline to avoid blocking
        handle(socket)
        socket.close()

def __sendPage(socket, filePath):
    """Send the file as webpage to client
    """
    try:
        f = open(filePath, "rb")
        while True:
            data = f.read(64)
            if (data == b""):
                break
            socket.write(data)
        f.close()
    except Exception as e:
        print(e)


def err(socket, code, message):
    """Respong error meesage to client
    """
    socket.write("HTTP/1.1 " + code + " " + message + "\r\n")
    socket.write("Content-Type: text/html\r\n\r\n")
    socket.write("<h1>" + message + "</h1>")

def ok(socket, code, *args):
    """Response successful message or webpage to client
    """
    if len(args)==1:
        content_type = "text/plain"
        msg = args[0]
    elif len(args)==2:
        content_type = args[0]
        msg = args[1]
    else:
        raise TypeError("ok() takes 3 or 4 positional arguments but "+ str(len(args)+2) +" were given")
    socket.write("HTTP/1.1 " + code + " OK\r\n")
    socket.write("Content-Type: " + content_type + "\r\n\r\n")
#     if __fileExist(msg):
#         filePath = msg
#         __sendPage(socket, filePath)
#     else:
    socket.write(msg)

def __fileExist(path):
    """Check for file existence
    """
    print(path)
    try:
        stat = os.stat(path)
        # stat[0] bit 15 / 14 -> file/dir
        if stat[0] & 0x8000 == 0x8000: # file
            print("Found.")
            return True
        else:  # Dir
            return False
    except:
        print("Not Found.")
        return False


def __serveFile(socket, path):
    """Serves a file from the filesystem
    """
    filePath = docPath + path
    fileFound = True
    # find the file
    if not __fileExist(filePath):
        if not path.endswith("/"):
             fileFound = False
        else:
            filePath = path + docPath + "/index.html"
            # find index.html in the path
            if not __fileExist(filePath):
                filePath = path + docPath + "/index.p.html"
                # find index.p.html in the path
                if not __fileExist(filePath): # no default html file found
                    fileFound = False
    if not fileFound: # file or default html file specified in path not found
        if notFoundHandler:
            notFoundHandler(socket)
        else:
            err(socket, "404", "Not Found")
        return
    # Responds the header first
    socket.write("HTTP/1.1 200 OK\r\n")
    contentType = "text/html"
    for ext in mimeTypes:
        if filePath.endswith(ext):
            contentType = mimeTypes[ext]
    socket.write("Content-Type: " + contentType + "\r\n\r\n")
    # Responds the file content
    if filePath.endswith(".p.html"):
        print("template file.")
        f = open(filePath, "r")
        for l in f:
            socket.write(l.format(**tplData))
        f.close()
    else:
        __sendPage(socket, filePath)

def handle(socket):
    """Processing new GET request
    """
    global docPath, handlers
    try: # capture timeout for wainting a line
        currLine = str(socket.readline(), 'utf-8')
    except:
        currLine = "" # readline timeout (not a complete line) 
    request = currLine.split(" ")
    if len(request) != 3: # Discarded if it's a bad header
        return
    (method, url, version) = request
    if "?" in url: # Check if there's query string?
        (path, query) = url.split("?", 2)
    else:
        (path, query) = (url, "")
    args = {}
    contentType = ""
    content = b""
    contentLength = 0
    if query: # Parsing the querying string
        argPairs = query.split("&")
        for argPair in argPairs:
            arg = argPair.split("=")
            args[arg[0]] = arg[1]
    while True: # Read until blank line after header
        header = socket.readline()
        if header.startswith(b"Content-Length"):
            (key, contentLengthStr) = str(header).split(" ")
            contentLength = int(contentLengthStr[0:-5])
            if (contentLength > maxContentLength):
                err(socket, "400", "Bad Request")
                return
        if (header.startswith(b"Content-Type")):
            (key, contentType) = str(header).split(" ")
            contentType = contentType[0:-5]
        if (header == b""):
            return
        if (header == b"\r\n" and contentLength > 0):
            while(len(content) < contentLength):
                content = content + socket.recv(contentLength)
                if (len(content) > maxContentLength):
                    err(socket, "400", "Bad Request")
                    return
            break
        elif header == b"\r\n":
            break

    # Check for supported HTTP version
    if version != "HTTP/1.0\r\n" and version != "HTTP/1.1\r\n":
        err(socket, "505", "Version Not Supported")
    elif (method != "GET" and method != "PUT" and method != "POST"):  # Only accept GET,PUT and POST request
        err(socket, "501", "Not Implemented")
    elif (path in postHandlers and method == "POST"): # Check for registered POST path
        postHandlers[path](socket, args, contentType, content)
    elif (path in putHandlers and method == "PUT"): # Check for registered PUT path
        putHandlers[path](socket, args, contentType, content)
    elif (path in getHandlers and method == "GET"): # Check for registered GET path
        getHandlers[path](socket, args)
    elif path in getHandlers: # here to ensure compatibility
        getHandlers[path](socket, args)
    else: # find file in the document path
        __serveFile(socket, path)

def onPath(path, handler):
    """Register handler for processing GET request of specified path,
    Here to ensure compatibility.
    """
    onGetPath(path, handler)

def onGetPath(path, handler):
    """Register handler for processing GET request of specified path
    """
    global handlers
    getHandlers[path] = handler

def onPostPath(path, handler):
    """Register handler for processing POST of specified path
    """
    global handlers
    postHandlers[path] = handler
    
def onPutPath(path, handler):
    """Register handler for processing PUT of specified path
    """
    global handlers
    putHandlers[path] = handler
    
def onNotFound(handler):
    """Register handler for processing request of not found path
    """
    global notFoundHandler
    notFoundHandler = handler

def setDocPath(path):
    """Set the path to documents' directory
    """
    global docPath
    if path.endswith("/"):
        docPath = path[:-1]
    else:
        docPath = path

def setTplData(data):
    """Set data for template
    """
    global tplData
    tplData = data

def setMaxContentLength(max):
    """Set the maximum content lenpth for incomming data bodies
    """
    global maxContentLength
    maxContentLength = max