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
|
