Add auto update from server

Author: LiteApplication

lelonmo/persist_data.py

@@ -16,7 +16,7 @@
     save_file = input("Please enter the location of your save file : ")
 
 default_data = dict(
-    version="00.4.8",
+    version="00.4.9",
     update_url='https://github.com/claj-ndc/LeLonMo/releases/latest',
     online=dict(
         uuid=str(uuid.uuid4()),

lelonmo/socket_client.py

@@ -12,6 +12,7 @@
 from lelonmo.main_offline import human_to_bool
 
 PORT = 11111
+BUFFER_SIZE = 4096
 
 
 def _send_data(data: str, host: str):
@@ -31,7 +32,7 @@ def _send_data(data: str, host: str):
             )
         )
         # UUID is never shared with other players
-        v = s.recv(1024)
+        v = s.recv(BUFFER_SIZE)
         s.close()
         return v
     except ConnectionRefusedError:
@@ -78,10 +79,14 @@ def _join_game(wb, ip="localhost"):  # Initiate the connexion between client and
         webbrowser.open(persist_data.DATA["update_url"])
         exit_server()
     elif player_id == b"outdated%update":
-        wb.add("Your client is outdated and automatic update install is not available")
-        import webbrowser
-        webbrowser.open(persist_data.DATA["update_url"])
+        wb.add(f"You are about to receive an update from {ip}.")
+        if human_to_bool("Do you trust this server ?\n"):
+            import lelonmo.updater as updater
+            updater.auto_update(ip, wb)
+        else:
+            wb.add("Aborted update, you cannot play on this server. ")
         exit_server()
+
     else:
         try:
             int(player_id)
@@ -274,6 +279,7 @@ def exit_server():
         pass
     finally:
         s.close()
+        sys.exit()
 
 
 if __name__ == "__main__":

lelonmo/updater.py

@@ -0,0 +1,58 @@
+import socket
+from zipfile import ZipFile
+import os, sys, imp
+from lelonmo import persist_data
+
+BUFFER_SIZE = 4096
+SERVER_PORT = 11111
+
+def _send_data(data: str, host: str):
+    socket.timeout = 2
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        s.connect((host, SERVER_PORT))
+        s.send(
+            bytearray(
+                "%llm_client%" \
+                f"{persist_data.DATA['version'].replace('.', str())}%" \
+                f"{persist_data.DATA['online']['uuid']}%" \
+                f"{data}",
+                "utf-8"
+            )
+        )
+        v = s.recv(BUFFER_SIZE)
+        s.close()
+        return v
+    except ConnectionRefusedError:
+        print("Server error : Connexion refused")
+        s.close()
+        exit()
+    except Exception as e:
+        s.close()
+        print("Server error :", e)
+        exit(0)
+
+
+def auto_update(ip, wb):
+    size = int(_send_data("size%", ip))
+    wb.add("The update is available")
+    tmp_file = open("tmp_update.zip", "wb")
+    s = socket.socket()  
+    s.connect((ip, SERVER_PORT))
+    s.send(bytearray(f"%llm_client%{persist_data.DATA['version'].replace('.', str())}%{persist_data.DATA['online']['uuid']}%latest_file%","utf-8"))
+    data = b'1'
+    wb.add("Downloading ...")
+    while data:
+        data = s.recv(BUFFER_SIZE)
+        if not data:
+            break
+        # write data to a file
+        tmp_file.write(data)
+    tmp_file.close()
+    wb.add("Done")
+    ziph = ZipFile('tmp_update.zip', 'r')
+    wb.add("Extracting update ...")
+    for file in ziph.namelist():
+        ziph.extract(file, os.path.realpath(os.path.join(__file__, f"..{os.path.sep}..")))
+    wb.add("Update successful")
+    exit(0)

release_tools/create_release_zip.py

@@ -0,0 +1,29 @@
+import os, sys
+import zipfile
+
+PACKAGE_PARENT = '..'
+SCRIPT_DIR = os.path.dirname(os.path.realpath(os.path.join(os.getcwd(), os.path.expanduser(__file__))))
+sys.path.append(os.path.normpath(os.path.join(SCRIPT_DIR, PACKAGE_PARENT)))
+from lelonmo.persist_data import DATA
+
+
+def zipdir(path, zip_handle):
+    for root, dirs, files in os.walk(path):
+        for file in files:
+            if not "__pycache__" in file:
+                zip_handle.write(
+                    os.path.join(root, file),
+                    os.path.relpath(
+                        os.path.join(root, file),
+                        os.path.join(path, '..')
+                    )
+                )
+
+
+if __name__ == '__main__':
+    version = DATA["version"].replace(".", "")
+    zipf = zipfile.ZipFile(
+        f'server{os.path.sep}LeLonMo_client_v{version}.zip', 'w', zipfile.ZIP_DEFLATED)
+    zipdir(f'lelonmo', zipf)
+    zipf.write(f"main.py", "main.py")
+    zipf.close()

server/persist_data.py

@@ -7,8 +7,8 @@
 save_file = home + ".lelonmo_server_save.json"
 
 default_data = dict(
-    version="0.4.8",
-    client_version="0048",
+    version="0.4.9",
+    client_version="0049",
     online=dict(
         uuid=str(uuid.uuid4()),
         name="",

server/socket_server.py

@@ -3,18 +3,20 @@
 import re
 import threading
 import socket
+import os
 
 from server import letter_generator, persist_data
 from server import word_check
 
-
+BUFFER_SIZE = 4096
 class Game():
     def __init__(self, LANGUAGE, MAX_PLAYERS = 10):
         self.state = 0
         print("[I] Waiting for admin ...")
         self.game_data = dict(players=list())
         self.LANGUAGE = LANGUAGE
         self.MAX_PLAYERS = MAX_PLAYERS
+        self.update_file = f'server{os.path.sep}LeLonMo_client_v{persist_data.DATA["client_version"]}.zip'
 
     def _new_player(self, uuid, name, ip, status="Connected"):
         if name in [i['name'] for i in self.game_data["players"]]:
@@ -49,6 +51,7 @@ def _delete_player(self, player_id: int, admin: bool):
 
     def _answer(self, msg, socket):
         socket.send(bytearray(str(msg), "utf-8"))
+        socket.close()
 
     def _get_player_id(self, uuid):
         for i, j in enumerate(self.game_data["players"]):
@@ -96,13 +99,21 @@ def handle_data(self, data: str, client_socket, client_thread):
         except:
             print("[W] Invalid request :", data)
             return data, client_socket, client_socket
+        
+        # Allow updates
         try:
-            if int(version) < int(persist_data.DATA["client_version"]):
-                self._answer("outdated%", client_socket)
-                return
+            if not msg in ['size%', 'latest_file%']:
+                if int(version) < int(persist_data.DATA["client_version"]) and os.path.exists(self.update_file):
+                    self._answer("outdated%update", client_socket)
+                    return
+                elif int(version) < int(persist_data.DATA["client_version"]):
+                    self._answer("outdated%", client_socket)
+                    return
         except:
             self._answer("outdated%", client_socket)
             return
+        
+        
         try:
             admin = uuid == self.game_data["admin"]["uuid"]
         except KeyError:
@@ -118,6 +129,28 @@ def handle_data(self, data: str, client_socket, client_thread):
                 self._answer("Nobody", client_socket)
         elif msg == "leave%":
             self._delete_player(self._get_player_id(uuid), admin)
+        
+        # Update sending part
+        elif msg == "latest_file%":
+            try:
+                print("[I] Uploading update")
+                f = open(self.update_file,'rb')
+                l = f.read(BUFFER_SIZE)
+                while (l):
+                   client_socket.send(l)
+                   l = f.read(BUFFER_SIZE)
+                f.close()
+                client_socket.close()
+                print("[I] Update done")
+            except Exception as e:
+                print("[E] Error while sending update :", e)
+        elif msg == "size%":
+            try:
+                f = open(self.update_file,'rb')
+                self._answer(len(f.read()), client_socket)
+                f.close()
+            except Exception as e:
+                print("[E] Error while calculating update :", e)
         elif self.state == 0 and msg.startswith("join%"):
             self.state = 1
             self.game_data["admin"] = dict(
@@ -193,7 +226,7 @@ def __init__(self, ip, port, clientsocket, game):
         self.clientsocket = clientsocket
 
     def run(self):
-        data = self.clientsocket.recv(1024).decode("utf-8")
+        data = self.clientsocket.recv(BUFFER_SIZE).decode("utf-8")
         if data.startswith("%llm_client%"):
             self.game.handle_data(data, self.clientsocket, self)
         else: