diff options
author | Shubham Saini <shubham6405@gmail.com> | 2018-12-11 10:01:23 +0000 |
---|---|---|
committer | Shubham Saini <shubham6405@gmail.com> | 2018-12-11 10:01:23 +0000 |
commit | 68df54d6629ec019142eb149dd037774f2d11e7c (patch) | |
tree | 345bc22d46b4e01a4ba8303b94278952a4ed2b9e /venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/__init__.py |
First commit
Diffstat (limited to 'venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/__init__.py')
-rw-r--r-- | venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/__init__.py | 347 |
1 files changed, 347 insertions, 0 deletions
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/__init__.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/__init__.py new file mode 100644 index 0000000..228e051 --- /dev/null +++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/__init__.py | |||
@@ -0,0 +1,347 @@ | |||
1 | # -*- coding: utf-8 -*- | ||
2 | |||
3 | """ | ||
4 | lockfile.py - Platform-independent advisory file locks. | ||
5 | |||
6 | Requires Python 2.5 unless you apply 2.4.diff | ||
7 | Locking is done on a per-thread basis instead of a per-process basis. | ||
8 | |||
9 | Usage: | ||
10 | |||
11 | >>> lock = LockFile('somefile') | ||
12 | >>> try: | ||
13 | ... lock.acquire() | ||
14 | ... except AlreadyLocked: | ||
15 | ... print 'somefile', 'is locked already.' | ||
16 | ... except LockFailed: | ||
17 | ... print 'somefile', 'can\\'t be locked.' | ||
18 | ... else: | ||
19 | ... print 'got lock' | ||
20 | got lock | ||
21 | >>> print lock.is_locked() | ||
22 | True | ||
23 | >>> lock.release() | ||
24 | |||
25 | >>> lock = LockFile('somefile') | ||
26 | >>> print lock.is_locked() | ||
27 | False | ||
28 | >>> with lock: | ||
29 | ... print lock.is_locked() | ||
30 | True | ||
31 | >>> print lock.is_locked() | ||
32 | False | ||
33 | |||
34 | >>> lock = LockFile('somefile') | ||
35 | >>> # It is okay to lock twice from the same thread... | ||
36 | >>> with lock: | ||
37 | ... lock.acquire() | ||
38 | ... | ||
39 | >>> # Though no counter is kept, so you can't unlock multiple times... | ||
40 | >>> print lock.is_locked() | ||
41 | False | ||
42 | |||
43 | Exceptions: | ||
44 | |||
45 | Error - base class for other exceptions | ||
46 | LockError - base class for all locking exceptions | ||
47 | AlreadyLocked - Another thread or process already holds the lock | ||
48 | LockFailed - Lock failed for some other reason | ||
49 | UnlockError - base class for all unlocking exceptions | ||
50 | AlreadyUnlocked - File was not locked. | ||
51 | NotMyLock - File was locked but not by the current thread/process | ||
52 | """ | ||
53 | |||
54 | from __future__ import absolute_import | ||
55 | |||
56 | import functools | ||
57 | import os | ||
58 | import socket | ||
59 | import threading | ||
60 | import warnings | ||
61 | |||
62 | # Work with PEP8 and non-PEP8 versions of threading module. | ||
63 | if not hasattr(threading, "current_thread"): | ||
64 | threading.current_thread = threading.currentThread | ||
65 | if not hasattr(threading.Thread, "get_name"): | ||
66 | threading.Thread.get_name = threading.Thread.getName | ||
67 | |||
68 | __all__ = ['Error', 'LockError', 'LockTimeout', 'AlreadyLocked', | ||
69 | 'LockFailed', 'UnlockError', 'NotLocked', 'NotMyLock', | ||
70 | 'LinkFileLock', 'MkdirFileLock', 'SQLiteFileLock', | ||
71 | 'LockBase', 'locked'] | ||
72 | |||
73 | |||
74 | class Error(Exception): | ||
75 | """ | ||
76 | Base class for other exceptions. | ||
77 | |||
78 | >>> try: | ||
79 | ... raise Error | ||
80 | ... except Exception: | ||
81 | ... pass | ||
82 | """ | ||
83 | pass | ||
84 | |||
85 | |||
86 | class LockError(Error): | ||
87 | """ | ||
88 | Base class for error arising from attempts to acquire the lock. | ||
89 | |||
90 | >>> try: | ||
91 | ... raise LockError | ||
92 | ... except Error: | ||
93 | ... pass | ||
94 | """ | ||
95 | pass | ||
96 | |||
97 | |||
98 | class LockTimeout(LockError): | ||
99 | """Raised when lock creation fails within a user-defined period of time. | ||
100 | |||
101 | >>> try: | ||
102 | ... raise LockTimeout | ||
103 | ... except LockError: | ||
104 | ... pass | ||
105 | """ | ||
106 | pass | ||
107 | |||
108 | |||
109 | class AlreadyLocked(LockError): | ||
110 | """Some other thread/process is locking the file. | ||
111 | |||
112 | >>> try: | ||
113 | ... raise AlreadyLocked | ||
114 | ... except LockError: | ||
115 | ... pass | ||
116 | """ | ||
117 | pass | ||
118 | |||
119 | |||
120 | class LockFailed(LockError): | ||
121 | """Lock file creation failed for some other reason. | ||
122 | |||
123 | >>> try: | ||
124 | ... raise LockFailed | ||
125 | ... except LockError: | ||
126 | ... pass | ||
127 | """ | ||
128 | pass | ||
129 | |||
130 | |||
131 | class UnlockError(Error): | ||
132 | """ | ||
133 | Base class for errors arising from attempts to release the lock. | ||
134 | |||
135 | >>> try: | ||
136 | ... raise UnlockError | ||
137 | ... except Error: | ||
138 | ... pass | ||
139 | """ | ||
140 | pass | ||
141 | |||
142 | |||
143 | class NotLocked(UnlockError): | ||
144 | """Raised when an attempt is made to unlock an unlocked file. | ||
145 | |||
146 | >>> try: | ||
147 | ... raise NotLocked | ||
148 | ... except UnlockError: | ||
149 | ... pass | ||
150 | """ | ||
151 | pass | ||
152 | |||
153 | |||
154 | class NotMyLock(UnlockError): | ||
155 | """Raised when an attempt is made to unlock a file someone else locked. | ||
156 | |||
157 | >>> try: | ||
158 | ... raise NotMyLock | ||
159 | ... except UnlockError: | ||
160 | ... pass | ||
161 | """ | ||
162 | pass | ||
163 | |||
164 | |||
165 | class _SharedBase(object): | ||
166 | def __init__(self, path): | ||
167 | self.path = path | ||
168 | |||
169 | def acquire(self, timeout=None): | ||
170 | """ | ||
171 | Acquire the lock. | ||
172 | |||
173 | * If timeout is omitted (or None), wait forever trying to lock the | ||
174 | file. | ||
175 | |||
176 | * If timeout > 0, try to acquire the lock for that many seconds. If | ||
177 | the lock period expires and the file is still locked, raise | ||
178 | LockTimeout. | ||
179 | |||
180 | * If timeout <= 0, raise AlreadyLocked immediately if the file is | ||
181 | already locked. | ||
182 | """ | ||
183 | raise NotImplemented("implement in subclass") | ||
184 | |||
185 | def release(self): | ||
186 | """ | ||
187 | Release the lock. | ||
188 | |||
189 | If the file is not locked, raise NotLocked. | ||
190 | """ | ||
191 | raise NotImplemented("implement in subclass") | ||
192 | |||
193 | def __enter__(self): | ||
194 | """ | ||
195 | Context manager support. | ||
196 | """ | ||
197 | self.acquire() | ||
198 | return self | ||
199 | |||
200 | def __exit__(self, *_exc): | ||
201 | """ | ||
202 | Context manager support. | ||
203 | """ | ||
204 | self.release() | ||
205 | |||
206 | def __repr__(self): | ||
207 | return "<%s: %r>" % (self.__class__.__name__, self.path) | ||
208 | |||
209 | |||
210 | class LockBase(_SharedBase): | ||
211 | """Base class for platform-specific lock classes.""" | ||
212 | def __init__(self, path, threaded=True, timeout=None): | ||
213 | """ | ||
214 | >>> lock = LockBase('somefile') | ||
215 | >>> lock = LockBase('somefile', threaded=False) | ||
216 | """ | ||
217 | super(LockBase, self).__init__(path) | ||
218 | self.lock_file = os.path.abspath(path) + ".lock" | ||
219 | self.hostname = socket.gethostname() | ||
220 | self.pid = os.getpid() | ||
221 | if threaded: | ||
222 | t = threading.current_thread() | ||
223 | # Thread objects in Python 2.4 and earlier do not have ident | ||
224 | # attrs. Worm around that. | ||
225 | ident = getattr(t, "ident", hash(t)) | ||
226 | self.tname = "-%x" % (ident & 0xffffffff) | ||
227 | else: | ||
228 | self.tname = "" | ||
229 | dirname = os.path.dirname(self.lock_file) | ||
230 | |||
231 | # unique name is mostly about the current process, but must | ||
232 | # also contain the path -- otherwise, two adjacent locked | ||
233 | # files conflict (one file gets locked, creating lock-file and | ||
234 | # unique file, the other one gets locked, creating lock-file | ||
235 | # and overwriting the already existing lock-file, then one | ||
236 | # gets unlocked, deleting both lock-file and unique file, | ||
237 | # finally the last lock errors out upon releasing. | ||
238 | self.unique_name = os.path.join(dirname, | ||
239 | "%s%s.%s%s" % (self.hostname, | ||
240 | self.tname, | ||
241 | self.pid, | ||
242 | hash(self.path))) | ||
243 | self.timeout = timeout | ||
244 | |||
245 | def is_locked(self): | ||
246 | """ | ||
247 | Tell whether or not the file is locked. | ||
248 | """ | ||
249 | raise NotImplemented("implement in subclass") | ||
250 | |||
251 | def i_am_locking(self): | ||
252 | """ | ||
253 | Return True if this object is locking the file. | ||
254 | """ | ||
255 | raise NotImplemented("implement in subclass") | ||
256 | |||
257 | def break_lock(self): | ||
258 | """ | ||
259 | Remove a lock. Useful if a locking thread failed to unlock. | ||
260 | """ | ||
261 | raise NotImplemented("implement in subclass") | ||
262 | |||
263 | def __repr__(self): | ||
264 | return "<%s: %r -- %r>" % (self.__class__.__name__, self.unique_name, | ||
265 | self.path) | ||
266 | |||
267 | |||
268 | def _fl_helper(cls, mod, *args, **kwds): | ||
269 | warnings.warn("Import from %s module instead of lockfile package" % mod, | ||
270 | DeprecationWarning, stacklevel=2) | ||
271 | # This is a bit funky, but it's only for awhile. The way the unit tests | ||
272 | # are constructed this function winds up as an unbound method, so it | ||
273 | # actually takes three args, not two. We want to toss out self. | ||
274 | if not isinstance(args[0], str): | ||
275 | # We are testing, avoid the first arg | ||
276 | args = args[1:] | ||
277 | if len(args) == 1 and not kwds: | ||
278 | kwds["threaded"] = True | ||
279 | return cls(*args, **kwds) | ||
280 | |||
281 | |||
282 | def LinkFileLock(*args, **kwds): | ||
283 | """Factory function provided for backwards compatibility. | ||
284 | |||
285 | Do not use in new code. Instead, import LinkLockFile from the | ||
286 | lockfile.linklockfile module. | ||
287 | """ | ||
288 | from . import linklockfile | ||
289 | return _fl_helper(linklockfile.LinkLockFile, "lockfile.linklockfile", | ||
290 | *args, **kwds) | ||
291 | |||
292 | |||
293 | def MkdirFileLock(*args, **kwds): | ||
294 | """Factory function provided for backwards compatibility. | ||
295 | |||
296 | Do not use in new code. Instead, import MkdirLockFile from the | ||
297 | lockfile.mkdirlockfile module. | ||
298 | """ | ||
299 | from . import mkdirlockfile | ||
300 | return _fl_helper(mkdirlockfile.MkdirLockFile, "lockfile.mkdirlockfile", | ||
301 | *args, **kwds) | ||
302 | |||
303 | |||
304 | def SQLiteFileLock(*args, **kwds): | ||
305 | """Factory function provided for backwards compatibility. | ||
306 | |||
307 | Do not use in new code. Instead, import SQLiteLockFile from the | ||
308 | lockfile.mkdirlockfile module. | ||
309 | """ | ||
310 | from . import sqlitelockfile | ||
311 | return _fl_helper(sqlitelockfile.SQLiteLockFile, "lockfile.sqlitelockfile", | ||
312 | *args, **kwds) | ||
313 | |||
314 | |||
315 | def locked(path, timeout=None): | ||
316 | """Decorator which enables locks for decorated function. | ||
317 | |||
318 | Arguments: | ||
319 | - path: path for lockfile. | ||
320 | - timeout (optional): Timeout for acquiring lock. | ||
321 | |||
322 | Usage: | ||
323 | @locked('/var/run/myname', timeout=0) | ||
324 | def myname(...): | ||
325 | ... | ||
326 | """ | ||
327 | def decor(func): | ||
328 | @functools.wraps(func) | ||
329 | def wrapper(*args, **kwargs): | ||
330 | lock = FileLock(path, timeout=timeout) | ||
331 | lock.acquire() | ||
332 | try: | ||
333 | return func(*args, **kwargs) | ||
334 | finally: | ||
335 | lock.release() | ||
336 | return wrapper | ||
337 | return decor | ||
338 | |||
339 | |||
340 | if hasattr(os, "link"): | ||
341 | from . import linklockfile as _llf | ||
342 | LockFile = _llf.LinkLockFile | ||
343 | else: | ||
344 | from . import mkdirlockfile as _mlf | ||
345 | LockFile = _mlf.MkdirLockFile | ||
346 | |||
347 | FileLock = LockFile | ||