MicroWebServer.py

@@ -2,8 +2,7 @@ import rp2
 import network
 import ubinascii
 import time
-import usocket
+import socket
-import json
 
 import sys
 
@@ -21,7 +20,6 @@ def get_logger():
 
 
 class Request:
-    @staticmethod
     def parse_header(request):
         http_lines = request.decode().split('\r\n')
         http_request_split = http_lines[0].split(' ')
@@ -32,105 +30,65 @@ class Request:
         )    
 
         if len(http_request_path_split) > 1:
-            http_request.parameter = dict(
+            http_request.set_parameter(dict(
                 param.split('=')
                 for param in http_request_path_split[1].split('&')
-            )
+            ))
         if len(http_lines) > 1:
-            http_request.header = dict(
+            http_request.set_header(dict(
                 header.split(': ')
                 for header in http_lines[1:]
                 if header is not None and header != ""
-            )
+            ))
         return http_request
 
     def __init__(
             self, method, path, protocol,
             host="", header={}, content=None, parameter={}):
-        self._method = method
+        self.method = method
-        self._host = host
+        self.host = host
-        self._path = path
+        self.path = path
-        self._parameter = parameter
+        self.parameter = parameter
-        self._protocol = protocol
+        self.protocol = protocol
-        self._header = header
+        self.header = header
-        self._content = content
+        self.content = content
+
     def __repr__(self):
         return repr({
-            "method": self._method,
+            "method": self.method,
-            "host": self._host,
+            "host": self.host,
-            "path": self._path,
+            "path": self.path,
-            "parameter": self._parameter,
+            "parameter": self.parameter,
-            "protocol": self._protocol,
+            "protocol": self.protocol,
-            "header": self._header,
+            "header": self.header,
-            "content": self._content
+            "content": self.content
         })
     def __str__(self):
-        return self.request_bytes.decode()
+        return self.get_request().decode()
 
-    @property
+    def set_header(self, header):
-    def method(self):
+        if self.header is None or len(self.header) == 0:
-        return self._method
+            self.header = header
-    @method.setter
+    def set_content(self, content):
-    def method(self, method):
+        if self.content is None or len(self.content) == 0:
-        if self._method is None or len(self._method) == 0:
+            self.content = content
-            self._method = method
+    def set_host(self, host):
-    @property
+        if self.host is None or len(self.host) == 0:
-    def host(self):
+            self.host = host
-        return self._host
+    def set_parameter(self, parameter):
-    @host.setter
+        if self.parameter is None or len(self.parameter) == 0:
-    def host(self, host):
-        if self._host is None or len(self._host) == 0:
-            self._host = host
-    @property
-    def path(self):
-        return self._path
-    @path.setter
-    def path(self, path):
-        if self._path is None or len(self._path) == 0:
-            self._path = path
-    @property
-    def parameter(self):
-        return self._parameter
-    @parameter.setter
-    def parameter(self, parameter):
-        if self._parameter is None or len(self._parameter) == 0:
             self.paramter = parameter
-    @property
+
-    def protocol(self):
+    def get_request(self):
-        return self._protocol
+        request = bytearray(self.get_header_request())
-    @protocol.setter
+        request.extend(b"" if self.content is None else f"{self.content}".encode())
-    def protocol(self, protocol):
-        if self._protocol is None or len(self._protocol) == 0:
-            self._protocol = protocol
-    @property
-    def header(self):
-        return self._header
-    @header.setter
-    def header(self, header):
-        if self._header is None or len(self._header) == 0:
-            self._header = header
-    @property
-    def content(self):
-        return self._content
-    @content.setter
-    def content(self, content):
-        if self._content is None or len(self._content) == 0:
-            self._content = content
-            self._header['Content-Length'] = str(len(content))
-    @property
-    def request_bytes(self):
-        request = bytearray(self._header_request_bytes)
-        request.extend(b"" if self._content is None else f"{self._content}".encode())
         return request
-    @property
+    def get_header_request(self):
-    def _header_request_bytes(self):
+        headers = "\r\n".join(': '.join(header) for header in self.header.items())
-        headers = "\r\n".join(': '.join(header) for header in self._header.items())
+        strpath = self.path
-        strpath = self._path
+        if len(self.parameter) > 0:
-        if len(self._parameter) > 0:
+            strpath += f"?{'&'.join('='.join(item) for item in self.parameter.items())}"
-            strpath += f"?{'&'.join('='.join(item) for item in self._parameter.items())}"
+        return f"{self.method} {strpath} {self.protocol}\r\n{headers}\r\n\r\n".encode()
-        if len(self._header) == 0:
-            return f"{self._method} {strpath} {self._protocol}\r\n\r\n".encode()
-        return f"{self._method} {strpath} {self._protocol}\r\n{headers}\r\n\r\n".encode()
 
 class Response(Request):
     messages = {
@@ -142,37 +100,33 @@ class Response(Request):
     def __init__(self, method, path, protocol, status,
             host="", header={}, content=None, parameter={}):
         super().__init__(method, path, protocol, host, header, content, parameter)
-        self._status = str(status)
+        self.status = status
 
     def __repr__(self):
         return repr({
-            "method": self._method,
+            "method": self.method,
-            "host": self._host,
+            "host": self.host,
-            "path": self._path,
+            "path": self.path,
-            "parameter": self._parameter,
+            "parameter": self.parameter,
-            "protocol": self._protocol,
+            "protocol": self.protocol,
-            "status": self._status,
+            "status": self.status,
-            "message": Response.messages[self._status],
+            "message": Response.messages[self.status],
-            "header": self._header,
+            "header": self.header,
-            "content": self._content
+            "content": self.content
         })
     def __str__(self):
-        return self.response_bytes.decode()
+        return self.get_response().decode()
-    @property
+
-    def status(self):
+    def get_response(self):
-        return self._status
+        response = bytearray(self.get_header_response())
-    @property
+        response.extend(b"" if self.content is None else f"{self.content}".encode())
-    def response_bytes(self):
-        response = bytearray(self._header_response_bytes)
-        response.extend(b"" if self._content is None else f"{self._content}".encode())
         return response
-    @property
+    def get_header_response(self):
-    def _header_response_bytes(self):
+        headers = "\r\n".join(': '.join(header) for header in self.header.items())
-        headers = "\r\n".join(': '.join(header) for header in self._header.items())
+        strpath = self.path
-        strpath = self._path
+        if len(self.parameter) > 0:
-        if len(self._parameter) > 0:
+            strpath += f"?{'&'.join('='.join(item) for item in self.parameter.items())}"
-            strpath += f"?{'&'.join('='.join(item) for item in self._parameter.items())}"
+        return f"{self.protocol} {self.status} {Response.messages[self.status]}\r\n{headers}\r\n\r\n".encode()
-        return f"{self._protocol} {self._status} {Response.messages[self._status]}\r\n{headers}\r\n\r\n".encode()
 
 class MicroWebServer:
     BUFFER_SIZE = 1024
@@ -185,6 +139,7 @@ class MicroWebServer:
             webrequest.extend(connect.recv(MicroWebServer.BUFFER_SIZE))
             is_end_stream = webrequest.endswith(b'\r\n\r\n') or len(webrequest) >= size
         return webrequest
+
     @staticmethod
     def socket_receive(connect):
         request_header_bytes = MicroWebServer.buffer_receive(connect)
@@ -194,42 +149,24 @@ class MicroWebServer:
                 connect, size=int(request.header['Content-Length'])
             )
             content = request_content_bytes.decode()
-            request.content = content
+            request.set_content(content)
         return request
-    @staticmethod
+
-    def default_locator():
-        return Response(None, None, "HTTP/1.0", 404)
 
     def __init__(self, listen_addr="0.0.0.0", port=80):
         self._listen_addr = listen_addr
         self._port = port
-        self._locations = {}
-    
-    def location(self, path):
-        def decorator(functor):
-            self._locations[path] = functor
-            return functor
-        return decorator
-
-    @property
-    def listen_addr(self):
-        return self._listen_addr
-    @property
-    def port(self):
-        return self._port
 
     def _create_socket(self):
-        self._socket_addrinfo = usocket.getaddrinfo(self._listen_addr, self._port)
+        self._socket_addrinfo = socket.getaddrinfo(self._listen_addr, self._port)
-        self._socket = usocket.socket()
+        self._socket = socket.socket()
         self._socket.bind(self._socket_addrinfo[0][-1])
         self._socket.listen(1)
 
     def _handle_request(self, request):
         logger.debug(f"Request: \n{request}")
-        if request.path in self._locations.keys():
+        response = Response(request.method, request.path, request.protocol, "200")
-            return self._locations[request.path]()
+        return response
-        else:
-            return MicroWebServer.default_locator()
 
     def serve(self):
         self._create_socket()
@@ -241,7 +178,7 @@ class MicroWebServer:
                 logger.debug(f"Client connect from '{addr[0]}'")
                 request = MicroWebServer.socket_receive(conn)
                 response = self._handle_request(request)
-                conn.send(response.response_bytes)
+                conn.send(response.get_response())
                 conn.close()
             except OSError as e:
                 conn.close()
@@ -278,8 +215,6 @@ def connect_wlan(ssid, passphrase, hostname="PicoW", country="DE", power_save=Fa
         print(f"\rConnection to '{ssid}' established. Connected via address '{ip}' from '{wlan_mac_address}'.")
     return wlan
 
-
-
 def main():
     ssid = "SSID"
     pw = "PASSWORD"
@@ -287,26 +222,8 @@ def main():
     get_logger()
 
     webserver = MicroWebServer()
-
-    @webserver.location(path="/")
-    def test_handler():
-        return Response("GET", "/", "HTTP/1.0", 204)
-
-    @webserver.location(path="/my/path")
-    def test_handler_content():
-        body = {
-            "Hello":"World"
-        }
-        resp = Response("GET", "/", "HTTP/1.0", 200)
-        # TODO: add some nicer handling with headers and content...
-        resp.header = {
-             "Content-Type": "application/json"   
-        }
-        resp.content = json.dumps(body)
-        print(resp.header)
-        return resp
-
     webserver.serve()
 
 if __name__=='__main__':
     main()
+