LDN7

LDN7/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

LDN7/.idea/LDN7.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

LDN7/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

LDN7/.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.12 (LDN7)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.12 (LDN7)" project-jdk-type="Python SDK" />
+</project>

LDN7/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/LDN7.iml" filepath="$PROJECT_DIR$/.idea/LDN7.iml" />
+    </modules>
+  </component>
+</project>

LDN7/client.py

@@ -0,0 +1,101 @@
+import json
+import socket
+import struct
+import sys
+import threading
+from datetime import datetime
+
+PORT = 1234
+HEADER_LENGTH = 2
+
+
+def receive_fixed_length_msg(sock, msglen):
+    message = b''
+    while len(message) < msglen:
+        chunk = sock.recv(msglen - len(message))  # preberi nekaj bajtov
+        if chunk == b'':
+            raise RuntimeError("socket connection broken")
+        message = message + chunk  # pripni prebrane bajte sporocilu
+
+    return message
+
+
+def receive_json(sock):
+    # preberi glavo sporocila (v prvih 2 bytih je dolzina sporocila)
+    header = receive_fixed_length_msg(sock, HEADER_LENGTH)
+    message_length = struct.unpack("!H", header)[0]  # pretvori dolzino sporocila v int
+
+    message = None
+    if message_length > 0:  # ce je vse OK
+        message = receive_fixed_length_msg(sock, message_length)  # preberi sporocilo
+        message = message.decode("utf-8")
+        message = json.loads(message)
+
+    return message
+
+
+def send_json(sock, data):
+    data["time"] = datetime.now().strftime("%c")
+
+    # pretvori sporocilo v niz bajtov, uporabi UTF-8 kodno tabelo
+    encoded_data = json.dumps(data).encode("utf-8")
+
+    # ustvari glavo v prvih 2 bytih je dolzina sporocila (HEADER_LENGTH)
+    # metoda pack "!H" : !=network byte order, H=unsigned short
+    header = struct.pack("!H", len(encoded_data))
+
+    data = header + encoded_data  # najprj posljemo dolzino sporocilo, sele nato sporocilo samo
+    sock.sendall(data)
+
+
+def send_username(sock, username):
+    send_json(sock, {
+        "type": "username",
+        "data": username,
+    })
+
+
+def send_message(sock, message):
+    send_json(sock, {
+        "type": "message",
+        "data": message,
+    })
+
+
+# message_receiver funkcija tece v loceni niti
+def message_receiver():
+    while True:
+        msg_received = receive_json(sock)
+
+        msg_type = msg_received["type"]
+        data = msg_received["data"]
+        time = msg_received["time"]
+        match msg_type:
+            case "message":
+                username = msg_received["username"]
+                print(f'[{time}] [{username}] : {data}')
+            case "error":
+                print(f'Error: {data}')
+
+
+# povezi se na streznik
+print("[system] connecting to chat server ...")
+sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+sock.connect(("localhost", PORT))
+print("[system] connected!")
+
+# zazeni message_receiver funkcijo v loceni niti
+thread = threading.Thread(target=message_receiver)
+thread.daemon = True
+thread.start()
+
+username = input("enter username: ")
+send_username(sock, username)
+
+# pocakaj da uporabnik nekaj natipka in poslji na streznik
+while True:
+    try:
+        msg_send = input("")
+        send_message(sock, msg_send)
+    except KeyboardInterrupt:
+        sys.exit()

LDN7/server.py

@@ -0,0 +1,147 @@
+import json
+import signal
+import socket
+import struct
+import threading
+from datetime import datetime
+
+signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+PORT = 1234
+HEADER_LENGTH = 2
+
+
+def receive_fixed_length_msg(sock, msglen):
+    message = b''
+    while len(message) < msglen:
+        chunk = sock.recv(msglen - len(message))  # preberi nekaj bajtov
+        if chunk == b'':
+            raise RuntimeError("socket connection broken")
+        message = message + chunk  # pripni prebrane bajte sporocilu
+
+    return message
+
+
+def receive_json(sock) -> dict:
+    # preberi glavo sporocila (v prvih 2 bytih je dolzina sporocila)
+    header = receive_fixed_length_msg(sock, HEADER_LENGTH)
+    message_length = struct.unpack("!H", header)[0]  # pretvori dolzino sporocila v int
+
+    message = None
+    if message_length > 0:  # ce je vse OK
+        message = receive_fixed_length_msg(sock, message_length)  # preberi sporocilo
+        message = message.decode("utf-8")
+        message = json.loads(message)
+
+    return message
+
+
+def send_json(sock, message):
+    message["time"] = datetime.now().strftime("%c")
+    encoded_message = json.dumps(message).encode("utf-8")  # pretvori sporocilo v niz bajtov, uporabi UTF-8 kodno tabelo
+
+    # ustvari glavo v prvih 2 bytih je dolzina sporocila (HEADER_LENGTH)
+    # metoda pack "!H" : !=network byte order, H=unsigned short
+    header = struct.pack("!H", len(encoded_message))
+
+    message = header + encoded_message  # najprj posljemo dolzino sporocilo, slee nato sporocilo samo
+    sock.sendall(message)
+
+
+def send_error(sock, message):
+    send_json(sock, {
+        "type": "error",
+        "data": message,
+    })
+
+
+# funkcija za komunikacijo z odjemalcem (tece v loceni niti za vsakega odjemalca)
+def client_thread(client_sock, client_addr):
+    global clients
+    global usernames
+
+    print("[system] connected with " + client_addr[0] + ":" + str(client_addr[1]))
+    print("[system] we now have " + str(len(clients)) + " clients")
+
+    try:
+
+        while True:  # neskoncna zanka
+            msg_received = receive_json(client_sock)
+            msg_type = str(msg_received["type"])
+            data = str(msg_received["data"])
+            time = str(msg_received["time"])
+
+            if not msg_received:  # ce obstaja sporocilo
+                break
+
+            match msg_type:
+                case "username":
+                    usernames[client_sock] = data
+
+                case "message":
+                    username = usernames[client_sock]
+                    if username is None:
+                        username = client_addr[0] + ":" + str(client_addr[1])
+                    msg_received["username"] = username
+
+                    print(f'[{time}] [{username}] : {data}')
+
+                    if data.startswith("@"):
+                        [username, *data] = data.split()
+                        username = str(username).replace("@", "")
+
+                        cl = [c for c, u in usernames.items() if u == username]
+                        if len(cl) == 0:
+                            send_error(client_sock, "Client with this username does not exist.")
+                            continue
+                        client = cl[0]
+
+                        msg_received["data"] = "".join(data)
+                        send_json(client, msg_received)
+                        continue
+
+                    for client in clients:
+                        if client == client_sock:
+                            continue
+                        send_json(client, msg_received)
+
+    except:
+        # tule bi lahko bolj elegantno reagirali, npr. na posamezne izjeme. Trenutno kar pozremo izjemo
+        pass
+
+    # prisli smo iz neskoncne zanke
+    with clients_lock:
+        clients.remove(client_sock)
+        if client_sock in usernames:
+            usernames.pop(client_sock)
+
+    print("[system] we now have " + str(len(clients)) + " clients")
+    client_sock.close()
+
+
+# kreiraj socket
+server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+server_socket.bind(("localhost", PORT))
+server_socket.listen(1)
+
+# cakaj na nove odjemalce
+print("[system] listening ...")
+clients = set()
+usernames = dict()
+clients_lock = threading.Lock()
+while True:
+    try:
+        # pocakaj na novo povezavo - blokirajoc klic
+        client_sock, client_addr = server_socket.accept()
+        with clients_lock:
+            clients.add(client_sock)
+
+        thread = threading.Thread(target=client_thread, args=(client_sock, client_addr))
+        thread.daemon = True
+        thread.start()
+
+    except KeyboardInterrupt:
+        break
+
+print("[system] closing server socket ...")
+server_socket.close()