#!/usr/bin/env python import asyncio import json import os import secrets import signal import subprocess import websockets import shutil from connect4 import PLAYER1, PLAYER2, Connect4 from user import User JOIN = {} WATCH = {} async def generate_file_structure(path='.', encoding='utf-8'): file_structure = {'name': os.path.basename(path), 'type': 'folder', 'path': path, 'children': []} try: entries = os.listdir(path) except FileNotFoundError: return file_structure # Return an empty structure for non-existing directories for entry in entries: entry_path = os.path.join(path, entry) if os.path.isdir(entry_path): child_structure =await generate_file_structure(entry_path, encoding) file_structure['children'].append(child_structure) elif os.path.isfile(entry_path): try: with open(entry_path, 'r', encoding=encoding) as file: content = file.read() except UnicodeDecodeError: content = 'Unable to read content' file_structure['children'].append({'name': entry, 'type': 'file', 'path': entry_path, 'content': content}) return file_structure async def rename_item(websocket, key,project_name, path,new_name, connected): old_path = os.path.join(os.getcwd(),'projects', key,project_name, path) new_name = new_name try: if os.path.exists(old_path): # Determine the new path new_path = os.path.join(os.path.dirname(old_path), new_name) # Rename the file or folder os.rename(old_path, new_path) websockets.broadcast(connected,'success') event = { "type": "rename-success", "data": f'{old_path}-->{new_path}', } websockets.broadcast(connected,json.dumps(event)) else: event = { "type": "rename-failed", "data": f'{old_path}-->{new_path} failed Item not found', } websockets.broadcast(connected,json.dumps(event)) except Exception as e: websockets.broadcast(connected,str(e)) async def delete_item(websocket, key,project_name, path, connected): try: item_path = os.path.join(os.getcwd(), 'projects', key,project_name, path) if os.path.exists(item_path): if os.path.isdir(item_path): shutil.rmtree(item_path) # Remove the directory and its contents elif os.path.isfile(item_path): os.remove(item_path) # Remove the file event = { "type": "delete-success", "data": item_path, } websockets.broadcast(connected,json.dumps(event)) # websockets.broadcast(connected,'success') else: event = { "type": "delete-failed", "data": f'{item_path} Item not found', } websockets.broadcast(connected,json.dumps(event)) except Exception as e: # print(e) websockets.broadcast(connected,str(e)) async def create_file(websocket, key,project_name, path,name, connected): file_path = os.path.join(os.getcwd(), 'projects', key,project_name, path,name) # Create the file with open(file_path, 'w'): pass event = { "type": "file-created", "data": file_path, } websockets.broadcast(connected,json.dumps(event)) async def create_folder(websocket, key,project_name, path,name, connected): folder_path = os.path.join(os.getcwd(), 'projects', key,project_name, path,name) # Create the folder os.makedirs(folder_path) event = { "type": "folder-created", "data": folder_path, } websockets.broadcast(connected,json.dumps(event)) async def wirte_file(websocket, key,project_name, path, content, connected): try: file_path = os.path.join(os.getcwd(), 'projects', key,project_name, path) file_content = content with open(file_path, 'w', encoding='utf-8') as file: file.write(file_content) event = { "type": "write-success", "data": file_path, } websockets.broadcast(connected,json.dumps(event)) except FileNotFoundError as e: event = { "type": "write-error", "data": e, } websockets.broadcast(connected,json.dumps(event)) async def execute_command(websocket, key,project_name, command, connected): base_path = os.path.join(os.getcwd(), 'projects', key,project_name) mod_command = f'cd {base_path} && {command}' try: process = await asyncio.create_subprocess_shell( mod_command, # cwd=base_path, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE, # text=True, ) async def send_message(message): print('sending msg') # await websocket.send(f'data: {message}') websockets.broadcast(connected,json.dumps(message) ) async for line in process.stdout: print('sending line') event = { "type": "terminal-data", "data": line.strip().decode('utf-8'), } await send_message(event) async for line in process.stderr: print(f'error:{line.strip()}') event = { "type": "terminal-error", "data": line.strip().decode('utf-8'), } await send_message(event) return_code = await process.wait() if return_code == 0: # await send_message('Code executed successfully') pass else: # await send_message(f'error:Execution failed with return code {return_code}') pass except Exception as e: await error(websocket, str(e)) async def create_file_structure(websocket, data, base_path='.'): if data['type'] == 'folder': folder_path = os.path.join(base_path, data['name']) os.makedirs(folder_path, exist_ok=True) for child in data['children']: await create_file_structure(websocket,child, base_path=folder_path) elif data['type'] == 'file': file_path = os.path.join(base_path, data['name']) with open(file_path, 'w', encoding='utf-8') as file: file.write(data['content']) event = { "type": "msg", "message": "project created", } await websocket.send(json.dumps(event)) async def error(websocket, message): """ Send an error message. """ event = { "type": "error", "message": message, } await websocket.send(json.dumps(event)) async def replay(websocket, game): """ Send previous moves. """ # Make a copy to avoid an exception if game.moves changes while iteration # is in progress. If a move is played while replay is running, moves will # be sent out of order but each move will be sent once and eventually the # UI will be consistent. for player, column, row in game.moves.copy(): event = { "type": "play", "player": player, "column": column, "row": row, } await websocket.send(json.dumps(event)) async def play(websocket, game, player, connected): """ Receive and process moves from a player. """ async for message in websocket: # Parse a "play" event from the UI. event = json.loads(message) assert event["type"] == "play" column = event["column"] try: # Play the move. row = game.play(player, column) except RuntimeError as exc: # Send an "error" event if the move was illegal. await error(websocket, str(exc)) continue # Send a "play" event to update the UI. event = { "type": "play", "player": player, "column": column, "row": row, } websockets.broadcast(connected, json.dumps(event)) # If move is winning, send a "win" event. if game.winner is not None: event = { "type": "win", "player": game.winner, } websockets.broadcast(connected, json.dumps(event)) async def exe(websocket,connected,key): """ Receive and process moves from a player. """ print('in exe') async for message in websocket: # Parse a "play" event from the UI. event = json.loads(message) assert event["type"] == "cmd" # command = event["command"] print(event) try: if event["command"]["type"]=="shell": await execute_command(websocket, key,event["project_name"], event["command"]["command"], connected) elif event["command"]["type"]=="write": await wirte_file(websocket, key,event["project_name"], event["path"], event["content"], connected) elif event["command"]["type"]=="create": if event["item"]=="folder": await create_folder(websocket, key,event["project_name"], event["path"],event["name"], connected) else: await create_file(websocket, key,event["project_name"], event["path"],event["name"], connected) elif event["command"]["type"]=="delete": await delete_item(websocket, key,event["project_name"], event["path"], connected) elif event["command"]["type"]=="rename": await rename_item(websocket, key,event["project_name"], event["path"], event["name"], connected) elif event["command"]["type"]=="collabration": event = { "type": "collabration", 'name': event["name"], 'line': event["cursorPos-line"], 'ch': event["cursorPos-ch"], 'file':event["file"], 'content': event["content"], } websockets.broadcast(connected, json.dumps(event)) else: # First player starts a new game. pass except RuntimeError as exc: # Send an "error" event if the move was illegal. await error(websocket, str(exc)) continue # # Send a "play" event to update the UI. # event = { # "type": "play", # "player": player, # "column": column, # "row": row, # } # websockets.broadcast(connected, json.dumps(event)) # # If move is winning, send a "win" event. # if game.winner is not None: # event = { # "type": "win", # "player": game.winner, # } # websockets.broadcast(connected, json.dumps(event)) async def start(websocket,events): """ Handle a connection from the first player: start a new game. """ # Initialize a Connect Four game, the set of WebSocket connections # receiving moves from this game, and secret access tokens. game = User() connected = {websocket} join_key = secrets.token_urlsafe(12) JOIN[join_key] = game, connected watch_key = secrets.token_urlsafe(12) WATCH[watch_key] = game, connected try: # Send the secret access tokens to the browser of the first player, # where they'll be used for building "join" and "watch" links. event = { "type": "init", "join": join_key, "watch": watch_key, } await websocket.send(json.dumps(event)) js = json.loads(events) assert js["type"] == "init" base_path = os.path.join(os.getcwd(), 'projects',join_key, js["project_name"]) data=json.loads(js["file_structure"]) # Receive and process moves from the first player. # await play(websocket, game, PLAYER1, connected) await create_file_structure(websocket,data, base_path=base_path) await exe(websocket,connected,join_key) finally: del JOIN[join_key] del WATCH[watch_key] async def join(websocket, key): """ Handle a connection from the second player: join an existing game. """ # Find the Connect Four game. try: game, connected = JOIN[key] except KeyError: await error(websocket, "collabration not found.") return # Register to receive moves from this game. connected.add(websocket) try: current_directory = f'projects/{key}/' # Send the first move, in case the first player already played it. file_structure = await generate_file_structure(current_directory) # Receive and process moves from the second player. event = { "type": "join", "file_structure": json.dumps(file_structure), } await websocket.send(json.dumps(event)) await exe(websocket,connected,key) finally: connected.remove(websocket) async def watch(websocket, watch_key): """ Handle a connection from a spectator: watch an existing game. """ # Find the Connect Four game. try: game, connected = WATCH[watch_key] except KeyError: await error(websocket, "Game not found.") return # Register to receive moves from this game. connected.add(websocket) try: # Send previous moves, in case the game already started. await replay(websocket, game) # Keep the connection open, but don't receive any messages. await websocket.wait_closed() finally: connected.remove(websocket) async def handler(websocket): """ Handle a connection and dispatch it according to who is connecting. """ # Receive and parse the "init" event from the UI. message = await websocket.recv() event = json.loads(message) print(event) project_name = event["project_name"] # assert event["type"] == "init" if event["type"] == "init": if "join" in event: # Second player joins an existing game. await join(websocket, event["join"]) elif "watch" in event: # Spectator watches an existing game. await watch(websocket, event["watch"]) else: # First player starts a new game. await start(websocket, message) elif event["type"] == "cmd": print('executing commad') # Execute a command in the project folder. await execute_command(websocket, event["project_name"], event["command"]) # assert event["type"] == "cmd" # if "command" in event: # # Second player joins an existing game. # await execute_command(websocket, project_name, event["command"]) # elif "watch" in event: # # Spectator watches an existing game. # await watch(websocket, event["watch"]) # else: # # First player starts a new game. # await start(websocket, message) async def main(): # Set the stop condition when receiving SIGTERM. loop = asyncio.get_running_loop() stop = loop.create_future() loop.add_signal_handler(signal.SIGTERM, stop.set_result, None) port = int(os.environ.get("PORT", "7860")) async with websockets.serve(handler, "0.0.0.0", port): await stop if __name__ == "__main__": asyncio.run(main())