Initial commit

Author: glekhana

README.md

@@ -0,0 +1 @@
+Reimplemntation of python

spawn_redis_server.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+exec python3 -m src.app.main "$@"

src/__init__.py

@@ -0,0 +1,30 @@
+import time
+
+
+class ClientStore:
+    def __init__(self):
+        # self.key_file = key_file
+        self.__values = {}
+
+    def delete(self, key):
+        del self.__values[key]
+
+    def get(self, key):
+        # with open(self.key_file, 'r') as f:
+        #     keys = json.load(f)
+        values = self.__values.get(key, None)
+        if values is None:
+            return None
+        else:
+            return values
+
+    def keys(self):
+        return self.__values.keys()
+
+    def set(self, key: str, value: dict) -> None:
+        self.__values[key] = value
+        # with open(self.key_file, 'r') as f:
+        #     keys = json.load(f)
+        # keys[key_id] = key
+        # with open(self.key_file, 'w') as f:
+        #     json.dump(keys, f)

src/app/__init__.py

@@ -0,0 +1,17 @@
+from src.app.commands.client.infoCommand import ClientInfoCommand
+from src.app.commands.client.setInfo import SetInfoCommand
+from src.app.commands.command import Command
+from src.app.commands.commandContext import CommandContext
+
+
+class ClientCommand(Command):
+    def execute(self, args: list, command_context: CommandContext) -> bytes:
+        client_command = args[0]
+        client_args = args[1:]
+        parser = None
+        upper_command = client_command.upper()
+        if upper_command == "SETINFO":
+            parser = SetInfoCommand(request=client_command)
+        if upper_command == "INFO":
+            parser = ClientInfoCommand(request=client_command)
+        return parser.execute(client_args, command_context)

src/app/clientstore.py

@@ -0,0 +1,11 @@
+from src.app.commands.command import Command
+from src.app.commands.commandContext import CommandContext
+
+
+class ClientInfoCommand(Command):
+    def execute(self, args: list, command_context: CommandContext) -> bytes:
+        final_message = ""
+        for key in command_context.client_store.keys():
+            value = str(command_context.client_store.get(key))
+            final_message += f"{key}:{value}\r\n"
+        return f"${len(final_message)}\r\n{final_message}\r\n".encode()

src/app/commands/__init__.py

@@ -0,0 +1,11 @@
+from src.app.commands.command import Command
+from src.app.commands.commandContext import CommandContext
+
+
+class SetInfoCommand(Command):
+    def execute(self, args: dict, command_context: CommandContext) -> bytes:
+        key = args[0]
+        value = args[1]
+
+        command_context.client_store.set(key, value)
+        return b"+OK\r\n"

src/app/commands/client/__init__.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+from src.app.commands.commandContext import CommandContext
+
+
+
+class Command(ABC):
+    def __init__(self, request: str) -> None:
+        super().__init__()
+        self.request = request
+
+    @abstractmethod
+    def execute(self, args: list, command_context: CommandContext) -> bytes:
+        pass

src/app/commands/client/clientCommand.py

@@ -0,0 +1,13 @@
+# Description: This file contains the CommandContext class which is used to store the key store, info store, and client store
+# objects. This class is used to pass these objects to the command classes so that they can interact with the data stores
+from src.app.clientstore import ClientStore
+from src.app.infostore import InfoStore
+from src.app.keystore import KeyStore
+
+
+class CommandContext:
+    def __init__(self, key_store: KeyStore, info_store: InfoStore, client_store: ClientStore):
+        self.key_store = key_store
+        self.info_store = info_store
+        self.client_store = client_store
+        self.slaves = []

src/app/commands/client/infoCommand.py

@@ -0,0 +1,40 @@
+from src.app.commands.client.clientCommand import ClientCommand
+from src.app.commands.commandContext import CommandContext
+from src.app.commands.echoCommand import EchoCommand
+from src.app.commands.getCommand import GetCommand
+from src.app.commands.infoCommand import InfoCommand
+from src.app.commands.pingCommand import PingCommand
+from src.app.commands.psyncCommand import PsyncCommand
+from src.app.commands.replConfCommand import ReplConfCommand
+from src.app.commands.setCommand import SetCommand
+from src.app.parser import Parser
+
+
+class CommandHandler:
+    def __init__(self, command_context: CommandContext):
+        self.parser = Parser()
+        self.__values = {}
+        self.command_context = command_context
+
+    def handle_command(self, command: str, args):
+        upper_command = command.upper()
+        if upper_command == "ECHO":
+            parsed_command = EchoCommand(request=upper_command)
+        elif upper_command == "PING":
+            parsed_command = PingCommand(request=upper_command)
+        elif upper_command == "SET":
+            parsed_command = SetCommand(request=upper_command)
+        elif upper_command == "GET":
+            parsed_command = GetCommand(request=upper_command)
+        elif upper_command == "INFO":
+            parsed_command = InfoCommand(request=upper_command)
+        elif upper_command == "REPLCONF":
+            parsed_command = ReplConfCommand(request=upper_command)
+        elif upper_command == "PSYNC":
+            parsed_command = PsyncCommand(request=upper_command)
+        elif upper_command == "CLIENT":
+            parsed_command = ClientCommand(request=upper_command)
+        else:
+            print(f"Unknown command: {upper_command}")
+            return b"-ERR unknown command\r\n", upper_command
+        return upper_command, parsed_command.execute(args=args, command_context=self.command_context)

src/app/commands/client/setInfo.py

@@ -0,0 +1,9 @@
+from src.app.commands.command import Command
+from src.app.commands.commandContext import CommandContext
+
+
+
+class EchoCommand(Command):
+    def execute(self, args: list, command_context: CommandContext) -> bytes:
+        message = args[0] if args else ""
+        return f"${len(message)}\r\n{message}\r\n".encode()

src/app/commands/command.py

@@ -0,0 +1,13 @@
+from src.app.commands.command import Command
+
+from src.app.commands.commandContext import CommandContext
+
+
+class GetCommand(Command):
+    def execute(self, args: dict, command_context: CommandContext) -> bytes:
+        key = args[0]
+        values = command_context.key_store.get(key)
+        if values is None:
+            return b"$-1\r\n"
+        value = values[0]
+        return f"${len(value)}\r\n{value}\r\n".encode()

src/app/commands/commandContext.py

@@ -0,0 +1,11 @@
+from src.app.commands.command import Command
+from src.app.commands.commandContext import CommandContext
+
+
+class InfoCommand(Command):
+    def execute(self, args: list, command_context: CommandContext) -> bytes:
+        final_message = ""
+        for key in command_context.info_store.get("replication").keys():
+            value = str(command_context.info_store.get("replication")[key])
+            final_message += f"{key}:{value}\r\n"
+        return f"${len(final_message)}\r\n{final_message}\r\n".encode()

src/app/commands/commandHandler.py

@@ -0,0 +1,7 @@
+from src.app.commands.command import Command
+from src.app.commands.commandContext import CommandContext
+
+
+class PingCommand(Command):
+    def execute(self, args: list,command_context: CommandContext) -> bytes:
+        return b"+PONG\r\n"

src/app/commands/echoCommand.py

@@ -0,0 +1,15 @@
+from src.app.commands.command import Command
+from src.app.commands.commandContext import CommandContext
+
+import base64
+
+
+class PsyncCommand(Command):
+    def execute(self, args: list, command_context: CommandContext) -> list:
+        message = f'+FULLRESYNC {command_context.info_store.get("replication")["master_replid"]} {command_context.info_store.get("replication")["master_repl_offset"]}\r\n'
+        rdb = "UkVESVMwMDEx+glyZWRpcy12ZXIFNy4yLjD6CnJlZGlzLWJpdHPAQPoFY3RpbWXCbQi8ZfoIdXNlZC1tZW3CsMQQAPoIYW9mLWJhc2XAAP/wbjv+wP9aog=="
+        binary_data = base64.b64decode(rdb)
+        print(binary_data)
+        message2 = b"$" + str(len(binary_data)).encode() + b"\r\n" + binary_data
+        print(message2)
+        return [message.encode(), message2]

src/app/commands/getCommand.py

@@ -0,0 +1,24 @@
+import socket
+
+from src.app.commands.command import Command
+from src.app.commands.commandContext import CommandContext
+
+
+class ReplConfCommand(Command):
+    def execute(self, args: list, command_context: CommandContext) -> bytes:
+        repl_command = args[0]
+        repl_args = args[1]
+        upper_command = repl_command.upper()
+        # if upper_command == "LISTENING-PORT":
+        #     self.__connect_client(command_context, int(repl_args))
+        return b"+OK\r\n"
+
+    def __connect_client(self, command_context, port):
+        client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            # Connect to the server
+            print("Connecting to the server", port)
+            client_socket.connect(("localhost", port))
+            command_context.slaves.append(client_socket)
+        except Exception as e:
+            print("Error:", e)

src/app/commands/infoCommand.py

@@ -0,0 +1,141 @@
+# def deserialize(resp):
+#     def pop(resp):
+#         if len(resp) == 0:
+#             raise ValueError("Missing bytes. End of input reached.")
+#         return resp[0], resp[1:]
+#     def skip_CRLF(resp):
+#         if resp[:2] != b"\r\n":
+#             raise ValueError(f"Expected CRLF. Got {resp[:2]} instead.")
+#         return resp[2:]
+#     def parse_operator(resp):
+#         byte, resp = pop(resp)
+#         return chr(byte), resp
+#     def parse_int(resp):
+#         byte, resp = pop(resp)
+#         value = ""
+#         if chr(byte) == "-" or chr(byte).isdigit():
+#             value += chr(byte)
+#         byte, resp = pop(resp)
+#         while chr(byte).isdigit():
+#             value += chr(byte)
+#             byte, resp = pop(resp)
+#         else:
+#             resp = byte.to_bytes() + resp
+#         resp = skip_CRLF(resp)
+#         return value, resp
+#     def parse_value(resp, byte_amount=None):
+#         def add_bytes(resp, value, number_of_bytes=1):
+#             for i in range(number_of_bytes):
+#                 byte, resp = pop(resp)
+#                 value += byte.to_bytes()
+#             return value, resp
+#         def parse_simple_value(resp):
+#             value = b""
+#             index = resp.find(b"\r\n")
+#             value += resp[:index]
+#             resp = resp[index:]
+#             resp = skip_CRLF(resp)
+#             if len(value) >= 512 * 1024 * 1024:
+#                 raise ValueError("String too long. Exceeded 512MB")
+#             return value, resp
+#         def parse_aggregate(resp, byte_amount):
+#             value = b""
+#             value, resp = add_bytes(resp, value, byte_amount)
+#             resp = skip_CRLF(resp)
+#             return value, resp
+#         if byte_amount == None:
+#             value, resp = parse_simple_value(resp)
+#         else:
+#             value, resp = parse_aggregate(resp, byte_amount)
+#         return value, resp
+#     FIRST_BYTES_SIMPLE = ["+", "-", ":", "_", "#", ",", "("]
+#     FIRST_BYTES_AGGREGATE = ["$", "*"]
+#     operator_list = []
+#     if not isinstance(resp, bytes):
+#         resp = resp.encode()
+#     while len(resp) > 0:
+#         operator, number, value = None, None, None
+#         operator, resp = parse_operator(resp)
+#         if operator not in FIRST_BYTES_SIMPLE and operator not in FIRST_BYTES_AGGREGATE:
+#             raise ValueError(f"Expected operator. Got {operator} instead.")
+#         if operator in FIRST_BYTES_SIMPLE:
+#             value, resp = parse_value(resp)
+#             match operator:
+#                 case ":":
+#                     value = int(value.decode())
+#                 case "_":
+#                     if value != b"":
+#                         raise ValueError(
+#                             f"No extra bytes in Null allowed. Got {value} instead."
+#                         )
+#                     value = None
+#                 case "#":
+#                     if value != b"t" and value != b"f":
+#                         raise ValueError(
+#                             f'Only "t" and "f" for booleans allowed. Got {value} instead.'
+#                         )
+#                     if value == b"t":
+#                         value = True
+#                     if value == b"f":
+#                         value = False
+#         if operator in FIRST_BYTES_AGGREGATE:
+#             number, resp = parse_int(resp)
+#             if number != "-1":
+#                 if operator == "$":
+#                     value, resp = parse_value(resp, int(number))
+#                 if operator == "*":
+#                     value = []
+#         operator_list.append([operator, number, value])
+#     if len(operator_list) == 1:
+#         try:
+#             return operator_list[0][2].decode()
+#         except:
+#             return operator_list[0][2]
+#     else:
+#         def add_to_list(number_of_elements, operator_list, current_index):
+#             result = []
+#             for i in range(number_of_elements):
+#                 if i + current_index >= len(operator_list):
+#                     raise ValueError("Missing Array Elements")
+#                 while operator_list[i + current_index][0] is None:
+#                     i += 1
+#                     if i + current_index >= len(operator_list):
+#                         raise ValueError("Missing Array Elements")
+#                 if operator_list[i + current_index][0] == "*":
+#                     operator_list[i + current_index][0] = None
+#                     array_length = int(operator_list[i + current_index][1])
+#                     if array_length == -1:
+#                         result.append(None)
+#                     else:
+#                         list, operator_list = add_to_list(
+#                             array_length, operator_list, i + 1
+#                         )
+#                         result.append(list)
+#                 else:
+#                     if isinstance(operator_list[i + current_index][2], bytes):
+#                         result.append(operator_list[i + current_index][2].decode())
+#                     else:
+#                         result.append(operator_list[i + current_index][2])
+#                     operator_list[i + current_index][0] = None
+#             return result, operator_list
+#         result = []
+#         for i in range(len(operator_list)):
+#             if operator_list[i][0] is None:
+#                 continue
+#             if operator_list[i][0] == "*":
+#                 operator_list[i][0] = None
+#                 number_of_elements = int(operator_list[i][1])
+#                 if number_of_elements == -1:
+#                     result.append(None)
+#                 else:
+#                     list, operator_list = add_to_list(
+#                         number_of_elements, operator_list, i + 1
+#                     )
+#                     result.append(list)
+#             else:
+#                 if isinstance(operator_list[i][2], bytes):
+#                     result.append(operator_list[i][2].decode())
+#                 else:
+#                     result.append(operator_list[i][2])
+#
+#         return result[0]