fix bugs relating to the order of execution of the python and java processes

Author: compiler64

engine/src/crossplay_python/crossplay.py

@@ -13,6 +13,8 @@
 MESSAGE_FILE_OTHER = "messages_other.json"
 LOCK_FILE_JAVA = "lock_java.txt"
 LOCK_FILE_OTHER = "lock_other.txt"
+STARTED_FILE_JAVA = "started_java.txt"
+STARTED_FILE_OTHER = "started_other.txt"
 
 class CrossPlayException(Exception):
     def __init__(self, message):
@@ -200,60 +202,130 @@ def from_json(cls, json_data):
 
 # 0.1 ms timestep, 10 min timeout
 def wait(message: CrossPlayMessage, timeout=600, timestep=0.0001, message_dir=MESSAGE_DIR):
-    read_file = os.path.join(message_dir, MESSAGE_FILE_JAVA)
-    write_file = os.path.join(message_dir, MESSAGE_FILE_OTHER)
-    java_lock_file = os.path.join(message_dir, LOCK_FILE_JAVA)
-    other_lock_file = os.path.join(message_dir, LOCK_FILE_OTHER)
+    try:
+        read_file = os.path.join(message_dir, MESSAGE_FILE_JAVA)
+        write_file = os.path.join(message_dir, MESSAGE_FILE_OTHER)
+        java_lock_file = os.path.join(message_dir, LOCK_FILE_JAVA)
+        other_lock_file = os.path.join(message_dir, LOCK_FILE_OTHER)
 
-    json_message = message.to_json()
-    time_limit = time.time() + timeout
+        # if directory does not exist, create it
+        if not os.path.exists(message_dir):
+            os.makedirs(message_dir)
 
-    # print(f"Waiting to send message Python -> Java: {json_message}")
+        json_message = message.to_json()
+        time_limit = time.time() + timeout
 
-    while os.path.exists(read_file) or os.path.exists(write_file) or os.path.exists(java_lock_file):
-        time.sleep(timestep)
+        # print(f"Waiting to send message Python -> Java: {json_message}")
 
-        if time.time() > time_limit:
-            raise CrossPlayException("Cross-play message passing timed out (Python waiting, Java busy).")
+        while os.path.exists(read_file) or os.path.exists(write_file) or os.path.exists(java_lock_file):
+            time.sleep(timestep)
 
-    if not os.path.exists(other_lock_file):
-        with open(other_lock_file, 'x') as f:
-            f.write('')
+            if time.time() > time_limit:
+                raise CrossPlayException("Cross-play message passing timed out (Python waiting, Java busy).")
 
-        # print("Created other lock file")
+        if not os.path.exists(other_lock_file):
+            with open(other_lock_file, 'x') as f:
+                f.write('')
 
-    with open(write_file, 'w') as f:
-        json.dump(json_message, f)
+            # print("Created other lock file")
 
-    if os.path.exists(other_lock_file):
-        os.remove(other_lock_file)
+        with open(write_file, 'w') as f:
+            json.dump(json_message, f)
 
-    # print(f"Sent message Python -> Java: {json_message}")
-    # print("Waiting for response Java -> Python...")
-    time_limit = time.time() + timeout
-    
-    while not os.path.exists(read_file) or os.path.exists(write_file) or os.path.exists(java_lock_file):
-        time.sleep(timestep)
+        if os.path.exists(other_lock_file):
+            os.remove(other_lock_file)
+
+        # print(f"Sent message Python -> Java: {json_message}")
+        # print("Waiting for response Java -> Python...")
+        time_limit = time.time() + timeout
+        
+        while not os.path.exists(read_file) or os.path.exists(write_file) or os.path.exists(java_lock_file):
+            time.sleep(timestep)
 
-        if time.time() > time_limit:
-            raise CrossPlayException("Cross-play message passing timed out (Python waiting, Java not responding).")
+            if time.time() > time_limit:
+                raise CrossPlayException("Cross-play message passing timed out (Python waiting, Java not responding).")
 
-    if not os.path.exists(other_lock_file):
-        with open(other_lock_file, 'x') as f:
-            f.write('')
+        if not os.path.exists(other_lock_file):
+            with open(other_lock_file, 'x') as f:
+                f.write('')
+
+        with open(read_file, 'r') as f:
+            json_data = json.load(f)
+            result = CrossPlayObject.from_json(json_data)
+        
+        os.remove(read_file)
+        
+        if os.path.exists(other_lock_file):
+            os.remove(other_lock_file)
 
-    with open(read_file, 'r') as f:
-        json_data = json.load(f)
-        result = CrossPlayObject.from_json(json_data)
+        # print(f"Received message Java -> Python: {result}")
+
+        if isinstance(result, CrossPlayLiteral):
+            return result.reduce_literal()
+        else:
+            return result
+    except IOError as e:
+        raise CrossPlayException("Cross-play message passing failed due to file I/O error: " + str(e))
+
+def reset_files(message_dir=MESSAGE_DIR):
+    read_file = os.path.join(message_dir, MESSAGE_FILE_JAVA)
+    write_file = os.path.join(message_dir, MESSAGE_FILE_OTHER)
+    java_lock_file = os.path.join(message_dir, LOCK_FILE_JAVA)
+    other_lock_file = os.path.join(message_dir, LOCK_FILE_OTHER)
+    java_started_file = os.path.join(message_dir, STARTED_FILE_JAVA)
+    other_started_file = os.path.join(message_dir, STARTED_FILE_OTHER)
+
+    if not os.path.exists(message_dir) or not os.path.isdir(message_dir):
+        os.makedirs(message_dir)
+    elif os.path.exists(other_started_file):
+        print("DEBUGGING: Detected existing crossplay_temp/started_other.txt file. " \
+              "This indicates that a previous cross-play match did not terminate cleanly. " \
+                "Deleting the old crossplay_temp files.")
+    elif os.path.exists(java_started_file):
+        print("DEBUGGING: Java cross-play runner already started. Using existing cross-play temp directory.")
+        return
+
+    if os.path.exists(read_file):
+        os.remove(read_file)
 
-    os.remove(read_file)
+    if os.path.exists(write_file):
+        os.remove(write_file)
+    
+    if os.path.exists(java_lock_file):
+        os.remove(java_lock_file)
 
     if os.path.exists(other_lock_file):
         os.remove(other_lock_file)
+    
+    if not os.path.exists(os.path.join(message_dir, STARTED_FILE_OTHER)):
+        with open(other_started_file, 'x') as f:
+            f.write('')
+
+def clear_temp_files(message_dir=MESSAGE_DIR):
+    if not os.path.exists(message_dir) or not os.path.isdir(message_dir):
+        return
 
-    # print(f"Received message Java -> Python: {result}")
+    read_file = os.path.join(message_dir, MESSAGE_FILE_JAVA)
+    write_file = os.path.join(message_dir, MESSAGE_FILE_OTHER)
+    java_lock_file = os.path.join(message_dir, LOCK_FILE_JAVA)
+    other_lock_file = os.path.join(message_dir, LOCK_FILE_OTHER)
+    java_started_file = os.path.join(message_dir, STARTED_FILE_JAVA)
+    other_started_file = os.path.join(message_dir, STARTED_FILE_OTHER)
 
-    if isinstance(result, CrossPlayLiteral):
-        return result.reduce_literal()
-    else:
-        return result
+    if os.path.exists(read_file):
+        os.remove(read_file)
+    
+    if os.path.exists(write_file):
+        os.remove(write_file)
+    
+    if os.path.exists(java_lock_file):
+        os.remove(java_lock_file)
+    
+    if os.path.exists(other_lock_file):
+        os.remove(other_lock_file)
+    
+    if os.path.exists(java_started_file):
+        os.remove(java_started_file)
+    
+    if os.path.exists(other_started_file):
+        os.remove(other_started_file)

engine/src/crossplay_python/main.py

@@ -7,7 +7,8 @@
 
 from crossplay_python.runner import RobotRunner
 from crossplay_python.crossplay import BYTECODE_LIMIT, CrossPlayLiteral as lit, \
-    CrossPlayMessage as mess, CrossPlayMethod as m, CrossPlayObjectType as ot, wait
+    CrossPlayMessage as mess, CrossPlayMethod as m, CrossPlayObjectType as ot, \
+    wait, reset_files, clear_temp_files
 from crossplay_python.wrappers import _GAME_METHODS, Team
 
 CROSSPLAY_PYTHON_DIR = "example-bots/src/crossplay_python"
@@ -49,29 +50,34 @@ def play(team_a=None, team_b=None, debug=False):
         Team.B: get_code(team_b),
         Team.NEUTRAL: None
     }
+
+    reset_files()
 
-    while True:
-        rc, round, team, id, end = wait(mess(m.START_TURN, []))
-
-        if end:
-            print("Game ended")
-            break
-
-        if debug:
-            print(f"Starting turn. Round {round}, team {TEAM_NAMES[team]}, ID {id}, end {end}")
-
-        runner = RobotRunner(
-            code=code[team],
-            game_methods=_GAME_METHODS,
-            error_method=get_error_printer(team=team, id=id, round=round),
-            bytecode_limit=BYTECODE_LIMIT,
-            debug=debug)
-        
-        runner.init_robot()
-        runner.run()
-        bytecode = runner.bytecode_limit - runner.bytecode
-        runner.kill()
-        wait(mess(m.END_TURN, [lit(ot.INTEGER, bytecode)]))
+    try:
+        while True:
+            rc, round, team, id, end = wait(mess(m.START_TURN, []))
+
+            if end:
+                print("Game ended")
+                break
+
+            if debug:
+                print(f"Starting turn. Round {round}, team {TEAM_NAMES[team]}, ID {id}, end {end}")
+
+            runner = RobotRunner(
+                code=code[team],
+                game_methods=_GAME_METHODS,
+                error_method=get_error_printer(team=team, id=id, round=round),
+                bytecode_limit=BYTECODE_LIMIT,
+                debug=debug)
+            
+            runner.init_robot()
+            runner.run()
+            bytecode = runner.bytecode_limit - runner.bytecode
+            runner.kill()
+            wait(mess(m.END_TURN, [lit(ot.INTEGER, bytecode)]))
+    finally:
+        clear_temp_files()
 
 if __name__ == "__main__":
     parser = ArgumentParser()

engine/src/main/battlecode/crossplay/CrossPlay.java

@@ -21,7 +21,9 @@ public class CrossPlay {
         MESSAGE_FILE_JAVA = "messages_java.json", // messages from the java engine
         MESSAGE_FILE_OTHER = "messages_other.json", // messages from the other language's runner script
         LOCK_FILE_JAVA = "lock_java.txt", // lock file created by the java engine
-        LOCK_FILE_OTHER = "lock_other.txt"; // lock file created by the other language's runner script
+        LOCK_FILE_OTHER = "lock_other.txt", // lock file created by the other language's runner script
+        STARTED_JAVA = "started_java.txt", // file created by the java engine when it starts
+        STARTED_OTHER = "started_other.txt"; // file created by the other language's runner
 
     private final boolean finalizer;
     private boolean initialized;
@@ -55,12 +57,21 @@ public static void resetFiles() {
 
             if (!Files.exists(crossPlayDir) || !Files.isDirectory(crossPlayDir)) {
                 Files.createDirectory(crossPlayDir);
+            } else if (Files.exists(crossPlayDir.resolve(STARTED_JAVA))) {
+                System.out.println("DEBUGGING: Detected existing crossplay_temp/started_java.txt file. "
+                    + "This indicates that a previous cross-play match did not terminate cleanly. "
+                    + "Deleting the old crossplay_temp files.");
+            } else if (Files.exists(crossPlayDir.resolve(STARTED_OTHER))) {
+                System.out.println("DEBUGGING: Python cross-play runner already started. Using existing cross-play temp directory.");
+                return;
             }
 
             Files.deleteIfExists(crossPlayDir.resolve(MESSAGE_FILE_JAVA));
             Files.deleteIfExists(crossPlayDir.resolve(MESSAGE_FILE_OTHER));
             Files.deleteIfExists(crossPlayDir.resolve(LOCK_FILE_JAVA));
             Files.deleteIfExists(crossPlayDir.resolve(LOCK_FILE_OTHER));
+
+            Files.createFile(crossPlayDir.resolve(STARTED_JAVA));
         } catch (Exception e) {
             throw new CrossPlayException("Failed to clear cross-play lock files.");
         }
@@ -75,9 +86,11 @@ public static void clearTempFiles() {
                 Files.deleteIfExists(crossPlayDir.resolve(MESSAGE_FILE_OTHER));
                 Files.deleteIfExists(crossPlayDir.resolve(LOCK_FILE_JAVA));
                 Files.deleteIfExists(crossPlayDir.resolve(LOCK_FILE_OTHER));
+                Files.deleteIfExists(crossPlayDir.resolve(STARTED_JAVA));
+                Files.deleteIfExists(crossPlayDir.resolve(STARTED_OTHER));
                 Files.delete(crossPlayDir);
             }
-        } catch (Exception e) {
+        } catch (IOException e) {
             throw new CrossPlayException("Failed to clear cross-play lock files.");
         }
     }
@@ -178,7 +191,7 @@ public int runMessagePassing() throws GameActionException {
             } catch (InterruptedException e) {
                 throw new CrossPlayException("Cross-play message passing thread was interrupted.");
             } catch (IOException e) {
-                throw new CrossPlayException("Failed to read other language's cross-play message file.");
+                throw new CrossPlayException("Cross-play message passing failed due to file I/O error: " + e.getMessage());
             }
         }
     }