Test Case: python-instruct-1874

  1import hashlib  2import os  3import sys  4import fcntl  5import time  6​  7def run_once(process_name: str) -> tuple[int, str, str]:  8    """  9    Ensures a process runs only once at a time, using the process name and a 10    hash of the command line arguments to uniquely identify the process. 11​ 12    Args: 13        process_name: A unique name for the process. 14​ 15    Returns: 16        A tuple containing the process ID, the command line, and a file name 17        where the process ID is stored. 18​ 19    Raises: 20        RuntimeError: If another instance of the process is already running. 21    """ 22    # Construct a unique identifier based on the process name and command line arguments. 23    # We use a hash of sys.argv to ensure that different command lines for the same 24    # process name are treated as distinct processes. 25    command_line_hash = hashlib.sha256(" ".join(sys.argv).encode()).hexdigest() 26    lock_file_name = f"/tmp/{process_name}_{command_line_hash}.pid" 27​ 28    try: 29        # Open the lock file in read-write mode. 30        # If the file doesn't exist, it will be created. 31        pid_file = open(lock_file_name, "w+") 32    except IOError as e: 33        raise RuntimeError(f"Could not open or create PID file {lock_file_name}: {e}") from e 34​ 35    try: 36        # Attempt to acquire an exclusive lock on the file. 37        # This will block if another process already holds the lock. 38        # We use LOCK_NB (non-blocking) to immediately raise an error if the lock 39        # cannot be acquired, indicating another instance is running. 40        fcntl.flock(pid_file, fcntl.LOCK_EX | fcntl.LOCK_NB) 41    except IOError: 42        # If flock fails with IOError, it means the lock is already held. 43        # We should try to read the PID from the file to provide a more informative error. 44        try: 45            pid_file.seek(0) 46            existing_pid_str = pid_file.read().strip() 47            if existing_pid_str: 48                existing_pid = int(existing_pid_str) 49                # Check if the process with that PID is still running. 50                # This is a best-effort check and might have race conditions. 51                # A more robust solution might involve checking /proc/<pid>/cmdline 52                # or using a more sophisticated locking mechanism. 53                try: 54                    os.kill(existing_pid, 0) # Signal 0 checks if the process exists 55                    raise RuntimeError( 56                        f"Another instance of '{process_name}' with command line " 57                        f"'{' '.join(sys.argv)}' is already running (PID: {existing_pid})." 58                    ) 59                except OSError: 60                    # Process is not running, we can proceed to take over. 61                    pass 62            else: 63                # PID file exists but is empty, likely a stale lock. 64                raise RuntimeError( 65                    f"Another instance of '{process_name}' with command line " 66                    f"'{' '.join(sys.argv)}' is likely running (PID file {lock_file_name} is empty)." 67                ) 68        except (IOError, ValueError) as e: 69            # Error reading PID file, or it contains non-numeric data. 70            raise RuntimeError( 71                f"Another instance of '{process_name}' with command line " 72                f"'{' '.join(sys.argv)}' is already running (could not read PID from {lock_file_name}): {e}" 73            ) from e 74        finally: 75            pid_file.close() # Ensure file is closed even if we raise an error 76​ 77    # If we reach here, the lock was acquired successfully. 78    # Write the current process ID to the lock file. 79    current_pid = os.getpid() 80    pid_file.seek(0) 81    pid_file.truncate() 82    pid_file.write(str(current_pid)) 83    pid_file.flush() # Ensure the PID is written to disk 84​ 85    # Register a cleanup function to release the lock and remove the PID file 86    # when the process exits normally or abnormally. 87    import atexit 88    def cleanup(): 89        try: 90            # Attempt to acquire the lock again to ensure we are the ones releasing it. 91            # This is a safeguard against unexpected scenarios. 92            fcntl.flock(pid_file, fcntl.LOCK_EX) 93            # Remove the PID file. 94            os.remove(lock_file_name) 95        except (IOError, OSError): 96            # Ignore errors during cleanup, as the process is already exiting. 97            pass 98        finally: 99            # Ensure the file is closed.100            if not pid_file.closed:101                pid_file.close()102​103    atexit.register(cleanup)104​105    return current_pid, " ".join(sys.argv), lock_file_name106​107if __name__ == "__main__":108    # Example usage:109    process_identifier = "my_unique_app"110​111    try:112        pid, cmdline, pid_file = run_once(process_identifier)113        print(f"Process '{process_identifier}' started successfully.")114        print(f"PID: {pid}")115        print(f"Command Line: {cmdline}")116        print(f"PID File: {pid_file}")117​118        # Simulate work119        print("Working for 10 seconds...")120        time.sleep(10)121        print("Work finished.")122​123    except RuntimeError as e:124        print(f"Error: {e}")125        sys.exit(1)126​127    # The atexit handler will automatically clean up the lock file on exit.

None