diff --git a/MicroWebServer.py b/MicroWebServer.py index 048cfee..458d4cd 100644 --- a/MicroWebServer.py +++ b/MicroWebServer.py @@ -2,7 +2,7 @@ import rp2 import network import ubinascii import time -import socket +import usocket import sys @@ -20,6 +20,7 @@ def get_logger(): class Request: + @staticmethod def parse_header(request): http_lines = request.decode().split('\r\n') http_request_split = http_lines[0].split(' ') @@ -30,65 +31,103 @@ class Request: ) if len(http_request_path_split) > 1: - http_request.set_parameter(dict( + print(http_request_path_split[1]) + http_request.parameter = dict( param.split('=') for param in http_request_path_split[1].split('&') - )) + ) if len(http_lines) > 1: - http_request.set_header(dict( + http_request.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.host = host - self.path = path - self.parameter = parameter - self.protocol = protocol - self.header = header - self.content = content - + self._method = method + self._host = host + self._path = path + self._parameter = parameter + self._protocol = protocol + self._header = header + self._content = content def __repr__(self): return repr({ - "method": self.method, - "host": self.host, - "path": self.path, - "parameter": self.parameter, - "protocol": self.protocol, - "header": self.header, - "content": self.content + "method": self._method, + "host": self._host, + "path": self._path, + "parameter": self._parameter, + "protocol": self._protocol, + "header": self._header, + "content": self._content }) def __str__(self): - return self.get_request().decode() + return self.request_bytes.decode() - def set_header(self, header): - if self.header is None or len(self.header) == 0: - self.header = header - def set_content(self, content): - if self.content is None or len(self.content) == 0: - self.content = content - def set_host(self, host): - if self.host is None or len(self.host) == 0: - self.host = host - def set_parameter(self, parameter): - if self.parameter is None or len(self.parameter) == 0: + @property + def method(self): + return self._method + @method.setter + def method(self, method): + if self._method is None or len(self._method) == 0: + self._method = method + @property + def host(self): + return self._host + @host.setter + 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 - - def get_request(self): - request = bytearray(self.get_header_request()) - request.extend(b"" if self.content is None else f"{self.content}".encode()) + @property + def protocol(self): + return self._protocol + @protocol.setter + 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 + @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 - def get_header_request(self): - headers = "\r\n".join(': '.join(header) for header in self.header.items()) - strpath = self.path - if len(self.parameter) > 0: - 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() + @property + def _header_request_bytes(self): + headers = "\r\n".join(': '.join(header) for header in self._header.items()) + strpath = self._path + if len(self._parameter) > 0: + 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() class Response(Request): messages = { @@ -100,33 +139,37 @@ 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 = status + self._status = status def __repr__(self): return repr({ - "method": self.method, - "host": self.host, - "path": self.path, - "parameter": self.parameter, - "protocol": self.protocol, - "status": self.status, - "message": Response.messages[self.status], - "header": self.header, - "content": self.content + "method": self._method, + "host": self._host, + "path": self._path, + "parameter": self._parameter, + "protocol": self._protocol, + "status": self._status, + "message": Response.messages[self._status], + "header": self._header, + "content": self._content }) def __str__(self): - return self.get_response().decode() - - def get_response(self): - response = bytearray(self.get_header_response()) - response.extend(b"" if self.content is None else f"{self.content}".encode()) + return self.response_bytes.decode() + @property + def status(self): + return self._status + @property + 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 - def get_header_response(self): - headers = "\r\n".join(': '.join(header) for header in self.header.items()) - strpath = self.path - if len(self.parameter) > 0: - 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() + @property + def _header_response_bytes(self): + headers = "\r\n".join(': '.join(header) for header in self._header.items()) + strpath = self._path + if len(self._parameter) > 0: + 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() class MicroWebServer: BUFFER_SIZE = 1024 @@ -139,7 +182,6 @@ 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) @@ -149,7 +191,7 @@ class MicroWebServer: connect, size=int(request.header['Content-Length']) ) content = request_content_bytes.decode() - request.set_content(content) + request.content = content return request @@ -158,8 +200,8 @@ class MicroWebServer: self._port = port def _create_socket(self): - self._socket_addrinfo = socket.getaddrinfo(self._listen_addr, self._port) - self._socket = socket.socket() + self._socket_addrinfo = usocket.getaddrinfo(self._listen_addr, self._port) + self._socket = usocket.socket() self._socket.bind(self._socket_addrinfo[0][-1]) self._socket.listen(1) @@ -178,7 +220,7 @@ class MicroWebServer: logger.debug(f"Client connect from '{addr[0]}'") request = MicroWebServer.socket_receive(conn) response = self._handle_request(request) - conn.send(response.get_response()) + conn.send(response.response_bytes) conn.close() except OSError as e: conn.close()