1. Wojciech Malinowski
  2. Webware

Source

Webware / WebKit / PidFile.py

"""Process id file management"""

import os
import atexit

if os.name == 'nt':
    try:
        import win32api
    except ImportError:
        try:
            import ctypes
            win32api = ctypes.windll.kernel32
        except (AttributeError, ImportError):
            win32api = None
else:
    win32api = None


class ProcessRunning(Exception):
    """Error when creating pid file for already running process."""


class PidFile(object):
    """Process id file management."""

    def __init__(self, path, create=True):
        """Create a pid file with the given path for the current process."""
        self._path = path
        self._created = False
        self._pid = None
        if os.path.exists(path):
            try:
                self._pid = int(open(path).read())
                if self._pid <= 1:
                    self._pid = None
                    raise ValueError
            except (IOError, ValueError, TypeError):
                # Can't open file or read PID from file.
                # File is probably  invalid or stale, so try to delete it.
                print ("%s is invalid or cannot be opened;"
                    " attempting to remove it." % path)
                self.remove(stale=True)
            else:
                if self.pidRunning(self._pid):
                    if create:
                        raise ProcessRunning()
                else:
                    print "%s is stale; removing." % path
                    self.remove(stale=True)
        if create:
            self._pid = self.currentPID()
            if self._pid is not None:
                self.write()
                # Delete the pid file when Python exits, so that the pid file
                # is removed if the process exits abnormally. If the process
                # crashes, though, the pid file will be left behind.
                atexit.register(self.remove)

    @staticmethod
    def pidRunning(pid):
        """Check whether process with given pid is running."""
        try:
            os.kill(pid, 0)
        except OSError, e:
            if e.errno == 3: # no such process
                return False
        except AttributeError:
            if win32api:
                try:
                    if not win32api.OpenProcess(1024, False, pid):
                        return False
                except win32api.error, e:
                    if e.winerror == 87: # wrong parameter (no such process)
                        return False
        return True

    @staticmethod
    def currentPID():
        """Get the current process id."""
        try:
            return os.getpid()
        except AttributeError:
            if win32api:
                return win32api.GetCurrentProcessId()
        return None

    @staticmethod
    def killPID(pid, sig=None):
        """Kill the process with the given pid."""
        try:
            if sig is None:
                from signal import SIGTERM
                sig = SIGTERM
            os.kill(pid, sig)
        except (AttributeError, ImportError):
            if win32api:
                handle = win32api.OpenProcess(1, False, pid)
                win32api.TerminateProcess(handle, -1)
                win32api.CloseHandle(handle)

    def pid(self):
        """Return our process id."""
        return self._pid

    def running(self):
        """Check whether our process is running."""
        return self.pidRunning(self._pid)

    def kill(self):
        """Kill our process."""
        if self._pid is None:
            return
        return self.killPID(self._pid)

    def __del__(self):
        """Remove pid file together with our instance."""
        self.remove()

    def remove(self, stale=False):
        """Remove our pid file."""
        if not stale:
            if not self._created:
                # Only remove the file if we created it. Otherwise starting
                # a second process will remove the file created by the first.
                return
            stale = os.path.exists(self._path)
        if stale:
            try:
                os.unlink(self._path)
            except (AttributeError, OSError):
                pass
        self._created = False # remove only once

    def write(self):
        """Write our pid file."""
        if self._created:
            return
        pidfile = open(self._path, 'w')
        pidfile.write(str(self._pid))
        pidfile.close()
        self._created = True # write only one