/usr/share/pyshared/daemon/pidlockfile.py is in python-daemon 1.5.5-1ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 | # -*- coding: utf-8 -*-
# daemon/pidlockfile.py
# Part of python-daemon, an implementation of PEP 3143.
#
# Copyright © 2008–2010 Ben Finney <ben+python@benfinney.id.au>
#
# This is free software: you may copy, modify, and/or distribute this work
# under the terms of the Python Software Foundation License, version 2 or
# later as published by the Python Software Foundation.
# No warranty expressed or implied. See the file LICENSE.PSF-2 for details.
""" Lockfile behaviour implemented via Unix PID files.
"""
import os
import errno
from lockfile import (
LinkFileLock,
AlreadyLocked, LockFailed,
NotLocked, NotMyLock,
)
class PIDFileError(Exception):
""" Abstract base class for errors specific to PID files. """
class PIDFileParseError(ValueError, PIDFileError):
""" Raised when parsing contents of PID file fails. """
class PIDLockFile(LinkFileLock, object):
""" Lockfile implemented as a Unix PID file.
The PID file is named by the attribute `path`. When locked,
the file will be created with a single line of text,
containing the process ID (PID) of the process that acquired
the lock.
The lock is acquired and maintained as per `LinkFileLock`.
"""
def read_pid(self):
""" Get the PID from the lock file.
"""
result = read_pid_from_pidfile(self.path)
return result
def acquire(self, *args, **kwargs):
""" Acquire the lock.
Locks the PID file then creates the PID file for this
lock. The `timeout` parameter is used as for the
`LinkFileLock` class.
"""
super(PIDLockFile, self).acquire(*args, **kwargs)
try:
write_pid_to_pidfile(self.path)
except OSError, exc:
error = LockFailed("%(exc)s" % vars())
raise error
def release(self):
""" Release the lock.
Removes the PID file then releases the lock, or raises an
error if the current process does not hold the lock.
"""
if self.i_am_locking():
remove_existing_pidfile(self.path)
super(PIDLockFile, self).release()
def break_lock(self):
""" Break an existing lock.
If the lock is held, breaks the lock and removes the PID
file.
"""
super(PIDLockFile, self).break_lock()
remove_existing_pidfile(self.path)
class TimeoutPIDLockFile(PIDLockFile):
""" Lockfile with default timeout, implemented as a Unix PID file.
This uses the ``PIDLockFile`` implementation, with the
following changes:
* The `acquire_timeout` parameter to the initialiser will be
used as the default `timeout` parameter for the `acquire`
method.
"""
def __init__(self, path, acquire_timeout=None, *args, **kwargs):
""" Set up the parameters of a DaemonRunnerLock. """
self.acquire_timeout = acquire_timeout
super(TimeoutPIDLockFile, self).__init__(path, *args, **kwargs)
def acquire(self, timeout=None, *args, **kwargs):
""" Acquire the lock. """
if timeout is None:
timeout = self.acquire_timeout
super(TimeoutPIDLockFile, self).acquire(timeout, *args, **kwargs)
def read_pid_from_pidfile(pidfile_path):
""" Read the PID recorded in the named PID file.
Read and return the numeric PID recorded as text in the named
PID file. If the PID file does not exist, return ``None``. If
the content is not a valid PID, raise ``PIDFileParseError``.
"""
pid = None
pidfile = None
try:
pidfile = open(pidfile_path, 'r')
except IOError, exc:
if exc.errno == errno.ENOENT:
pass
else:
raise
if pidfile:
# According to the FHS 2.3 section on PID files in ‘/var/run’:
#
# The file must consist of the process identifier in
# ASCII-encoded decimal, followed by a newline character. …
#
# Programs that read PID files should be somewhat flexible
# in what they accept; i.e., they should ignore extra
# whitespace, leading zeroes, absence of the trailing
# newline, or additional lines in the PID file.
line = pidfile.readline().strip()
try:
pid = int(line)
except ValueError:
raise PIDFileParseError(
"PID file %(pidfile_path)r contents invalid" % vars())
pidfile.close()
return pid
def write_pid_to_pidfile(pidfile_path):
""" Write the PID in the named PID file.
Get the numeric process ID (“PID”) of the current process
and write it to the named file as a line of text.
"""
open_flags = (os.O_CREAT | os.O_EXCL | os.O_WRONLY)
open_mode = (
((os.R_OK | os.W_OK) << 6) |
((os.R_OK) << 3) |
((os.R_OK)))
pidfile_fd = os.open(pidfile_path, open_flags, open_mode)
pidfile = os.fdopen(pidfile_fd, 'w')
# According to the FHS 2.3 section on PID files in ‘/var/run’:
#
# The file must consist of the process identifier in
# ASCII-encoded decimal, followed by a newline character. For
# example, if crond was process number 25, /var/run/crond.pid
# would contain three characters: two, five, and newline.
pid = os.getpid()
line = "%(pid)d\n" % vars()
pidfile.write(line)
pidfile.close()
def remove_existing_pidfile(pidfile_path):
""" Remove the named PID file if it exists.
Remove the named PID file. Ignore the condition if the file
does not exist, since that only means we are already in the
desired state.
"""
try:
os.remove(pidfile_path)
except OSError, exc:
if exc.errno == errno.ENOENT:
pass
else:
raise
|