Client update

client/httpclient.py

@@ -0,0 +1,131 @@
+import logging
+import re
+import socket
+from typing import Dict
+
+BUFSIZE = 4096
+TIMEOUT = 3
+FORMAT = "UTF-8"
+
+
+class HTTPClient(socket.socket):
+    host: str
+
+    def __init__(self, host: str):
+
+        super().__init__(socket.AF_INET, socket.SOCK_STREAM)
+        self.settimeout(TIMEOUT)
+        self.host = host
+
+    def _do_receive(self):
+        if self.fileno() == -1:
+            raise Exception("Connection closed")
+
+        result = self.recv(BUFSIZE)
+        return result
+
+    def receive(self):
+        """Receive data from the client up to BUFSIZE
+        """
+        count = 0
+        while True:
+            count += 1
+            try:
+                return self._do_receive()
+            except socket.timeout:
+                logging.debug("Socket receive timed out after %s seconds", TIMEOUT)
+                if count == 3:
+                    break
+                logging.debug("Retrying %s", count)
+
+        logging.debug("Timed out after waiting %s seconds for response", TIMEOUT * count)
+        raise TimeoutError("Request timed out")
+
+    def validate_status_line(self, status_line: str):
+        split = list(filter(None, status_line.split(" ")))
+        if len(split) < 3:
+            return False
+
+        # Check HTTP version
+        http_version = split.pop(0)
+        if len(http_version) < 8 or http_version[4] != "/":
+            raise InvalidStatusLine(status_line)
+        (name, version) = http_version[:4], http_version[5:]
+        if name != "HTTP" or not re.match(r"1\.[0|1]", version):
+            return False
+
+        if not re.match(r"\d{3}", split[0]):
+            return False
+
+        return True
+
+    def get_crlf_chunk(self, buffer: bytes):
+        """Finds the line break type (`CRLF` or `LF`) and splits the specified buffer
+        when encountering 2 consecutive linebreaks.
+        Returns a tuple with the first part and the remaining of the buffer.
+
+        :param buffer:
+        :return:
+        """
+        lf_pos = buffer.find(b"\n\n")
+        crlf_pos = buffer.find(b"\r\n\r\n")
+        if lf_pos != -1 and lf_pos < crlf_pos:
+            split_start = lf_pos
+            split_end = lf_pos + 2
+        else:
+            split_start = crlf_pos
+            split_end = crlf_pos + 4
+
+        return buffer[:split_start], buffer[split_end:]
+
+    def parse_headers(self, data: bytes):
+        headers = {}
+
+        # decode bytes, split into lines and filter
+        header_split = list(
+            filter(lambda l: l is not "" and not l[0].isspace(), map(str.strip, data.decode("utf-8").split("\n"))))
+
+        if len(header_split) == 0:
+            raise InvalidResponse(data)
+
+        start_line = header_split.pop(0)
+        logging.debug("start-line: %r", start_line)
+
+        for line in header_split:
+            pos = line.find(":")
+
+            if pos <= 0 or pos >= len(line) - 1:
+                continue
+
+            (header, value) = map(str.strip, line.split(":", 1))
+            headers[header.lower()] = value.lower()
+
+        logging.debug("Parsed headers: %r", headers)
+
+        return start_line, headers
+
+
+class HTTPException(Exception):
+    """ Base class for HTTP exceptions """
+
+
+class InvalidResponse(HTTPException):
+    """ Response message cannot be parsed """
+
+    def __init(self, message):
+        self.message = message
+
+
+class InvalidStatusLine(HTTPException):
+    """ Response status line is invalid """
+
+    def __init(self, line):
+        self.line = line
+
+
+class UnsupportedEncoding(HTTPException):
+    """ Reponse Encoding not support """
+
+    def __init(self, enc_type, encoding):
+        self.enc_type = enc_type
+        self.encoding = encoding