Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! #$ $ __init__.pynu [ # -*- coding: utf-8 -*-
"""
lockfile.py - Platform-independent advisory file locks.
Requires Python 2.5 unless you apply 2.4.diff
Locking is done on a per-thread basis instead of a per-process basis.
Usage:
>>> lock = LockFile('somefile')
>>> try:
... lock.acquire()
... except AlreadyLocked:
... print 'somefile', 'is locked already.'
... except LockFailed:
... print 'somefile', 'can\\'t be locked.'
... else:
... print 'got lock'
got lock
>>> print lock.is_locked()
True
>>> lock.release()
>>> lock = LockFile('somefile')
>>> print lock.is_locked()
False
>>> with lock:
... print lock.is_locked()
True
>>> print lock.is_locked()
False
>>> lock = LockFile('somefile')
>>> # It is okay to lock twice from the same thread...
>>> with lock:
... lock.acquire()
...
>>> # Though no counter is kept, so you can't unlock multiple times...
>>> print lock.is_locked()
False
Exceptions:
Error - base class for other exceptions
LockError - base class for all locking exceptions
AlreadyLocked - Another thread or process already holds the lock
LockFailed - Lock failed for some other reason
UnlockError - base class for all unlocking exceptions
AlreadyUnlocked - File was not locked.
NotMyLock - File was locked but not by the current thread/process
"""
from __future__ import absolute_import
import functools
import os
import socket
import threading
import warnings
# Work with PEP8 and non-PEP8 versions of threading module.
if not hasattr(threading, "current_thread"):
threading.current_thread = threading.currentThread
if not hasattr(threading.Thread, "get_name"):
threading.Thread.get_name = threading.Thread.getName
__all__ = ['Error', 'LockError', 'LockTimeout', 'AlreadyLocked',
'LockFailed', 'UnlockError', 'NotLocked', 'NotMyLock',
'LinkFileLock', 'MkdirFileLock', 'SQLiteFileLock',
'LockBase', 'locked']
class Error(Exception):
"""
Base class for other exceptions.
>>> try:
... raise Error
... except Exception:
... pass
"""
pass
class LockError(Error):
"""
Base class for error arising from attempts to acquire the lock.
>>> try:
... raise LockError
... except Error:
... pass
"""
pass
class LockTimeout(LockError):
"""Raised when lock creation fails within a user-defined period of time.
>>> try:
... raise LockTimeout
... except LockError:
... pass
"""
pass
class AlreadyLocked(LockError):
"""Some other thread/process is locking the file.
>>> try:
... raise AlreadyLocked
... except LockError:
... pass
"""
pass
class LockFailed(LockError):
"""Lock file creation failed for some other reason.
>>> try:
... raise LockFailed
... except LockError:
... pass
"""
pass
class UnlockError(Error):
"""
Base class for errors arising from attempts to release the lock.
>>> try:
... raise UnlockError
... except Error:
... pass
"""
pass
class NotLocked(UnlockError):
"""Raised when an attempt is made to unlock an unlocked file.
>>> try:
... raise NotLocked
... except UnlockError:
... pass
"""
pass
class NotMyLock(UnlockError):
"""Raised when an attempt is made to unlock a file someone else locked.
>>> try:
... raise NotMyLock
... except UnlockError:
... pass
"""
pass
class _SharedBase(object):
def __init__(self, path):
self.path = path
def acquire(self, timeout=None):
"""
Acquire the lock.
* If timeout is omitted (or None), wait forever trying to lock the
file.
* If timeout > 0, try to acquire the lock for that many seconds. If
the lock period expires and the file is still locked, raise
LockTimeout.
* If timeout <= 0, raise AlreadyLocked immediately if the file is
already locked.
"""
raise NotImplemented("implement in subclass")
def release(self):
"""
Release the lock.
If the file is not locked, raise NotLocked.
"""
raise NotImplemented("implement in subclass")
def __enter__(self):
"""
Context manager support.
"""
self.acquire()
return self
def __exit__(self, *_exc):
"""
Context manager support.
"""
self.release()
def __repr__(self):
return "<%s: %r>" % (self.__class__.__name__, self.path)
class LockBase(_SharedBase):
"""Base class for platform-specific lock classes."""
def __init__(self, path, threaded=True, timeout=None):
"""
>>> lock = LockBase('somefile')
>>> lock = LockBase('somefile', threaded=False)
"""
super(LockBase, self).__init__(path)
self.lock_file = os.path.abspath(path) + ".lock"
self.hostname = socket.gethostname()
self.pid = os.getpid()
if threaded:
t = threading.current_thread()
# Thread objects in Python 2.4 and earlier do not have ident
# attrs. Worm around that.
ident = getattr(t, "ident", hash(t))
self.tname = "-%x" % (ident & 0xffffffff)
else:
self.tname = ""
dirname = os.path.dirname(self.lock_file)
# unique name is mostly about the current process, but must
# also contain the path -- otherwise, two adjacent locked
# files conflict (one file gets locked, creating lock-file and
# unique file, the other one gets locked, creating lock-file
# and overwriting the already existing lock-file, then one
# gets unlocked, deleting both lock-file and unique file,
# finally the last lock errors out upon releasing.
self.unique_name = os.path.join(dirname,
"%s%s.%s%s" % (self.hostname,
self.tname,
self.pid,
hash(self.path)))
self.timeout = timeout
def is_locked(self):
"""
Tell whether or not the file is locked.
"""
raise NotImplemented("implement in subclass")
def i_am_locking(self):
"""
Return True if this object is locking the file.
"""
raise NotImplemented("implement in subclass")
def break_lock(self):
"""
Remove a lock. Useful if a locking thread failed to unlock.
"""
raise NotImplemented("implement in subclass")
def __repr__(self):
return "<%s: %r -- %r>" % (self.__class__.__name__, self.unique_name,
self.path)
def _fl_helper(cls, mod, *args, **kwds):
warnings.warn("Import from %s module instead of lockfile package" % mod,
DeprecationWarning, stacklevel=2)
# This is a bit funky, but it's only for awhile. The way the unit tests
# are constructed this function winds up as an unbound method, so it
# actually takes three args, not two. We want to toss out self.
if not isinstance(args[0], str):
# We are testing, avoid the first arg
args = args[1:]
if len(args) == 1 and not kwds:
kwds["threaded"] = True
return cls(*args, **kwds)
def LinkFileLock(*args, **kwds):
"""Factory function provided for backwards compatibility.
Do not use in new code. Instead, import LinkLockFile from the
lockfile.linklockfile module.
"""
from . import linklockfile
return _fl_helper(linklockfile.LinkLockFile, "lockfile.linklockfile",
*args, **kwds)
def MkdirFileLock(*args, **kwds):
"""Factory function provided for backwards compatibility.
Do not use in new code. Instead, import MkdirLockFile from the
lockfile.mkdirlockfile module.
"""
from . import mkdirlockfile
return _fl_helper(mkdirlockfile.MkdirLockFile, "lockfile.mkdirlockfile",
*args, **kwds)
def SQLiteFileLock(*args, **kwds):
"""Factory function provided for backwards compatibility.
Do not use in new code. Instead, import SQLiteLockFile from the
lockfile.mkdirlockfile module.
"""
from . import sqlitelockfile
return _fl_helper(sqlitelockfile.SQLiteLockFile, "lockfile.sqlitelockfile",
*args, **kwds)
def locked(path, timeout=None):
"""Decorator which enables locks for decorated function.
Arguments:
- path: path for lockfile.
- timeout (optional): Timeout for acquiring lock.
Usage:
@locked('/var/run/myname', timeout=0)
def myname(...):
...
"""
def decor(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
lock = FileLock(path, timeout=timeout)
lock.acquire()
try:
return func(*args, **kwargs)
finally:
lock.release()
return wrapper
return decor
if hasattr(os, "link"):
from . import linklockfile as _llf
LockFile = _llf.LinkLockFile
else:
from . import mkdirlockfile as _mlf
LockFile = _mlf.MkdirLockFile
FileLock = LockFile
PK ! Ǟ+P/ P/ __init__.pyonu [
abc
@@ s d Z d d l m Z d d l Z d d l Z d d l Z d d l Z d d l Z e e d sp e j e _
n e e j d s e j j e j _
n d d d d d
d d d
d d d d d g
Z d e f d YZ d e f d YZ d e f d YZ d e f d YZ d
e f d YZ d e f d YZ d e f d YZ d
e f d YZ d e f d YZ d e f d YZ d Z d Z d Z d! Z d d" Z e e d# rd$ d% l! m" Z# e# j$ Z% n d$ d& l! m& Z' e' j( Z% e% Z) d S(' s
lockfile.py - Platform-independent advisory file locks.
Requires Python 2.5 unless you apply 2.4.diff
Locking is done on a per-thread basis instead of a per-process basis.
Usage:
>>> lock = LockFile('somefile')
>>> try:
... lock.acquire()
... except AlreadyLocked:
... print 'somefile', 'is locked already.'
... except LockFailed:
... print 'somefile', 'can\'t be locked.'
... else:
... print 'got lock'
got lock
>>> print lock.is_locked()
True
>>> lock.release()
>>> lock = LockFile('somefile')
>>> print lock.is_locked()
False
>>> with lock:
... print lock.is_locked()
True
>>> print lock.is_locked()
False
>>> lock = LockFile('somefile')
>>> # It is okay to lock twice from the same thread...
>>> with lock:
... lock.acquire()
...
>>> # Though no counter is kept, so you can't unlock multiple times...
>>> print lock.is_locked()
False
Exceptions:
Error - base class for other exceptions
LockError - base class for all locking exceptions
AlreadyLocked - Another thread or process already holds the lock
LockFailed - Lock failed for some other reason
UnlockError - base class for all unlocking exceptions
AlreadyUnlocked - File was not locked.
NotMyLock - File was locked but not by the current thread/process
i ( t absolute_importNt current_threadt get_namet Errort LockErrort LockTimeoutt
AlreadyLockedt
LockFailedt UnlockErrort NotLockedt NotMyLockt LinkFileLockt
MkdirFileLockt SQLiteFileLockt LockBaset lockedc B@ s e Z d Z RS( sw
Base class for other exceptions.
>>> try:
... raise Error
... except Exception:
... pass
( t __name__t
__module__t __doc__( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR J s c B@ s e Z d Z RS( s
Base class for error arising from attempts to acquire the lock.
>>> try:
... raise LockError
... except Error:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR V s c B@ s e Z d Z RS( s Raised when lock creation fails within a user-defined period of time.
>>> try:
... raise LockTimeout
... except LockError:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR b s c B@ s e Z d Z RS( s Some other thread/process is locking the file.
>>> try:
... raise AlreadyLocked
... except LockError:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR m s c B@ s e Z d Z RS( s Lock file creation failed for some other reason.
>>> try:
... raise LockFailed
... except LockError:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR x s c B@ s e Z d Z RS( s
Base class for errors arising from attempts to release the lock.
>>> try:
... raise UnlockError
... except Error:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR s c B@ s e Z d Z RS( s Raised when an attempt is made to unlock an unlocked file.
>>> try:
... raise NotLocked
... except UnlockError:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR s c B@ s e Z d Z RS( s Raised when an attempt is made to unlock a file someone else locked.
>>> try:
... raise NotMyLock
... except UnlockError:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR
s t _SharedBasec B@ sA e Z d Z d d Z d Z d Z d Z d Z RS( c C@ s
| | _ d S( N( t path( t selfR ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt __init__ s c C@ s t d d S( s
Acquire the lock.
* If timeout is omitted (or None), wait forever trying to lock the
file.
* If timeout > 0, try to acquire the lock for that many seconds. If
the lock period expires and the file is still locked, raise
LockTimeout.
* If timeout <= 0, raise AlreadyLocked immediately if the file is
already locked.
s implement in subclassN( t NotImplemented( R t timeout( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt acquire s c C@ s t d d S( sX
Release the lock.
If the file is not locked, raise NotLocked.
s implement in subclassN( R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt release s c C@ s | j | S( s*
Context manager support.
( R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt __enter__ s
c G@ s | j d S( s*
Context manager support.
N( R ( R t _exc( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt __exit__ s c C@ s d | j j | j f S( Ns <%s: %r>( t __class__R R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt __repr__ s N( R R R t NoneR R R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR s c B@ sA e Z d Z e d d Z d Z d Z d Z d Z RS( s. Base class for platform-specific lock classes.c C@ s t t | j | t j j | d | _ t j | _ t j
| _ | r t j
} t | d t | } d | d @| _ n d | _ t j j | j } t j j | d | j | j | j t | j f | _ | | _ d S( si
>>> lock = LockBase('somefile')
>>> lock = LockBase('somefile', threaded=False)
s .lockt idents -%xI t s %s%s.%s%sN( t superR R t osR t abspatht lock_filet sockett gethostnamet hostnamet getpidt pidt threadingR t getattrt hasht tnamet dirnamet joint unique_nameR ( R R t threadedR t tR! R0 ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR s c C@ s t d d S( s9
Tell whether or not the file is locked.
s implement in subclassN( R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt is_locked s c C@ s t d d S( sA
Return True if this object is locking the file.
s implement in subclassN( R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt i_am_locking s c C@ s t d d S( sN
Remove a lock. Useful if a locking thread failed to unlock.
s implement in subclassN( R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt
break_lock s c C@ s d | j j | j | j f S( Ns <%s: %r -- %r>( R R R2 R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR s N(
R R R t TrueR R R5 R6 R7 R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR s ! c O@ sm t j d | t d d t | d t s: | d } n t | d k r` | r` t | d 4 sF -: PK ! !&~ mkdirlockfile.pynu [ from __future__ import absolute_import, division
import time
import os
import sys
import errno
from . import (LockBase, LockFailed, NotLocked, NotMyLock, LockTimeout,
AlreadyLocked)
class MkdirLockFile(LockBase):
"""Lock file by creating a directory."""
def __init__(self, path, threaded=True, timeout=None):
"""
>>> lock = MkdirLockFile('somefile')
>>> lock = MkdirLockFile('somefile', threaded=False)
"""
LockBase.__init__(self, path, threaded, timeout)
# Lock file itself is a directory. Place the unique file name into
# it.
self.unique_name = os.path.join(self.lock_file,
"%s.%s%s" % (self.hostname,
self.tname,
self.pid))
def acquire(self, timeout=None):
timeout = timeout if timeout is not None else self.timeout
end_time = time.time()
if timeout is not None and timeout > 0:
end_time += timeout
if timeout is None:
wait = 0.1
else:
wait = max(0, timeout / 10)
while True:
try:
os.mkdir(self.lock_file)
except OSError:
err = sys.exc_info()[1]
if err.errno == errno.EEXIST:
# Already locked.
if os.path.exists(self.unique_name):
# Already locked by me.
return
if timeout is not None and time.time() > end_time:
if timeout > 0:
raise LockTimeout("Timeout waiting to acquire"
" lock for %s" %
self.path)
else:
# Someone else has the lock.
raise AlreadyLocked("%s is already locked" %
self.path)
time.sleep(wait)
else:
# Couldn't create the lock for some other reason
raise LockFailed("failed to create %s" % self.lock_file)
else:
open(self.unique_name, "wb").close()
return
def release(self):
if not self.is_locked():
raise NotLocked("%s is not locked" % self.path)
elif not os.path.exists(self.unique_name):
raise NotMyLock("%s is locked, but not by me" % self.path)
os.unlink(self.unique_name)
os.rmdir(self.lock_file)
def is_locked(self):
return os.path.exists(self.lock_file)
def i_am_locking(self):
return (self.is_locked() and
os.path.exists(self.unique_name))
def break_lock(self):
if os.path.exists(self.lock_file):
for name in os.listdir(self.lock_file):
os.unlink(os.path.join(self.lock_file, name))
os.rmdir(self.lock_file)
PK ! | pidlockfile.pycnu [
abc @@ s d Z d d l m Z d d l Z d d l Z d d l Z d d l m Z m Z m Z m
Z
m Z m Z d e f d YZ
d Z d Z d
Z d S( s8 Lockfile behaviour implemented via Unix PID files.
i ( t absolute_importNi ( t LockBaset
AlreadyLockedt
LockFailedt NotLockedt NotMyLockt LockTimeoutt PIDLockFilec B@ sV e Z d Z e d d Z d Z d Z d Z d d Z d Z
d Z RS( sA Lockfile implemented as a Unix PID file.
The lock file is a normal file named by the attribute `path`.
A lock's PID file contains a single line of text, containing
the process ID (PID) of the process that acquired the lock.
>>> lock = PIDLockFile('somefile')
>>> lock = PIDLockFile('somefile')
c C@ s& t j | | t | | j | _ d S( N( R t __init__t Falset patht unique_name( t selfR
t threadedt timeout( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyR $ s c C@ s
t | j S( s- Get the PID from the lock file.
( t read_pid_from_pidfileR
( R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt read_pid* s c C@ s t j j | j S( sv Test if the lock is currently held.
The lock is held if the PID file for this lock exists.
( t osR
t exists( R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt is_locked/ s c C@ s" | j o! t j | j k S( s Test if the lock is held by the current process.
Returns ``True`` if the current process ID matches the
number stored in the PID file.
( R R t getpidR ( R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt i_am_locking7 s c C@ s) | d k r | n | j } t j } | d k rL | d k rL | | 7} n x t r$y t | j Wn t k
r } | j t j k rt j | k r | d k r | d k r t d | j q t
d | j n t j | d k r | d p d q!t d | j qO Xd SqO Wd S( s Acquire the lock.
Creates the PID file for this lock, or raises an error if
the lock could not be acquired.
i s& Timeout waiting to acquire lock for %ss %s is already lockedi
g?s failed to create %sN(
t NoneR t timet Truet write_pid_to_pidfileR
t OSErrort errnot EEXISTR R t sleepR ( R R t end_timet exc( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt acquire? s$
&c C@ sU | j s" t d | j n | j sD t d | j n t | j d S( s Release the lock.
Removes the PID file to release the lock, or raises an
error if the current process does not hold the lock.
s %s is not lockeds %s is locked, but not by meN( R R R
R R t remove_existing_pidfile( R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt release_ s
c C@ s t | j d S( s Break an existing lock.
Removes the PID file if it already exists, otherwise does
nothing.
N( R! R
( R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt
break_lockl s N( t __name__t
__module__t __doc__R R R R R R R R" R# ( ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyR s
c C@ sq d } y t | d } Wn t k
r, nA X| j j } y t | } Wn t k
rb n X| j | S( s 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 cannot be read, or if the content is
not a valid PID, return ``None``.
t rN( R t opent IOErrort readlinet stript intt
ValueErrort close( t pidfile_patht pidt pidfilet line( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyR v s
c C@ so t j t j Bt j B} d } t j | | | } t j | d } t j } | j d | | j d S( s 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.
i t ws %s
N( R t O_CREATt O_EXCLt O_WRONLYR( t fdopenR t writeR. ( R/ t
open_flagst open_modet
pidfile_fdR1 R0 ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyR s c C@ sC y t j | Wn+ t k
r> } | j t j k r8 q? n Xd S( s Remove the named PID file if it exists.
Removing a PID file that doesn't already exist puts us in the
desired state, so we ignore the condition if the file does not
exist.
N( R t removeR R t ENOENT( R/ R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyR! s ( R& t
__future__R R R R t R R R R R R R R R R! ( ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt
s .] " PK ! iY] ] linklockfile.pyonu [
abc @@ sp d d l m Z d d l Z d d l Z d d l m Z m Z m Z m Z m Z m
Z
d e f d YZ d S( i ( t absolute_importNi ( t LockBaset
LockFailedt NotLockedt NotMyLockt LockTimeoutt
AlreadyLockedt LinkLockFilec B@ s> e Z d Z d d Z d Z d Z d Z d Z RS( s Lock access to a file using atomic property of link(2).
>>> lock = LinkLockFile('somefile')
>>> lock = LinkLockFile('somefile', threaded=False)
c C@ s~ y t | j d j Wn$ t k
r@ t d | j n X| d k rS | n | j } t j } | d k r | d k r | | 7} n x t ryy t j
| j | j Wn t k
rqt j
| j j } | d k r d S| d k rKt j | k rKt j | j | d k r5t d | j qKt d | j n t j | d k rg| d pjd q Xd Sq Wd S( Nt wbs failed to create %si i s& Timeout waiting to acquire lock for %ss %s is already lockedi
g?( t opent unique_namet closet IOErrorR t Nonet timeoutt timet Truet ost linkt lock_filet OSErrort statt st_nlinkt unlinkR t pathR t sleep( t selfR t end_timet nlinks( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyt acquire s0
'c C@ sq | j s" t d | j n+ t j j | j sM t d | j n t j | j t j | j d S( Ns %s is not lockeds %s is locked, but not by me( t is_lockedR R R t existsR
R R R ( R ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyt release7 s c C@ s t j j | j S( N( R R R R ( R ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyR ? s c C@ s: | j o9 t j j | j o9 t j | j j d k S( Ni ( R R R R R
R R ( R ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyt i_am_lockingB s c C@ s, t j j | j r( t j | j n d S( N( R R R R R ( R ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyt
break_lockG s N( t __name__t
__module__t __doc__R
R R R R! R" ( ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyR
s & ( t
__future__R R R t R R R R R R R ( ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyt s .PK ! _] symlinklockfile.pycnu [
abc @@ sj d d l m Z d d l Z d d l Z d d l m Z m Z m Z m Z m Z d e f d YZ
d S( i ( t absolute_importNi ( t LockBaset NotLockedt NotMyLockt LockTimeoutt
AlreadyLockedt SymlinkLockFilec B@ sM e Z d Z e d d Z d d Z d Z d Z d Z d Z
RS( s' Lock access to a file using symlink(2).c C@ s6 t j | | | | t j j | j d | _ d S( Ni ( R t __init__t ost patht splitt unique_name( t selfR t threadedt timeout( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyR
s c C@ s | d k r | n | j } t j } | d k rL | d k rL | | 7} n x t ry t j | j | j Wn t k
r | j r d S| d k r t j | k r | d k r t
d | j q t d | j n t j
| d k r| d n d qO Xd SqO Wd S( Ni s& Timeout waiting to acquire lock for %ss %s is already lockedi
g?( t NoneR t timet TrueR t symlinkR t lock_filet OSErrort i_am_lockingR R R t sleep( R R t end_time( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyt acquire s$
'c C@ sX | j s" t d | j n" | j sD t d | j n t j | j d S( Ns %s is not lockeds %s is locked, but not by me( t is_lockedR R R R R t unlinkR ( R ( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyt release6 s
c C@ s t j j | j S( N( R R t islinkR ( R ( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyR = s c C@ s. t j j | j o- t j | j | j k S( N( R R R R t readlinkR ( R ( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyR @ s c C@ s, t j j | j r( t j | j n d S( N( R R R R R ( R ( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyt
break_lockD s N( t __name__t
__module__t __doc__R R R R R R R R ( ( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyR
s # ( t
__future__R R R t R R R R R R ( ( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyt s (PK ! _] symlinklockfile.pyonu [
abc @@ sj d d l m Z d d l Z d d l Z d d l m Z m Z m Z m Z m Z d e f d YZ
d S( i ( t absolute_importNi ( t LockBaset NotLockedt NotMyLockt LockTimeoutt
AlreadyLockedt SymlinkLockFilec B@ sM e Z d Z e d d Z d d Z d Z d Z d Z d Z
RS( s' Lock access to a file using symlink(2).c C@ s6 t j | | | | t j j | j d | _ d S( Ni ( R t __init__t ost patht splitt unique_name( t selfR t threadedt timeout( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyR
s c C@ s | d k r | n | j } t j } | d k rL | d k rL | | 7} n x t ry t j | j | j Wn t k
r | j r d S| d k r t j | k r | d k r t
d | j q t d | j n t j
| d k r| d n d qO Xd SqO Wd S( Ni s& Timeout waiting to acquire lock for %ss %s is already lockedi
g?( t NoneR t timet TrueR t symlinkR t lock_filet OSErrort i_am_lockingR R R t sleep( R R t end_time( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyt acquire s$
'c C@ sX | j s" t d | j n" | j sD t d | j n t j | j d S( Ns %s is not lockeds %s is locked, but not by me( t is_lockedR R R R R t unlinkR ( R ( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyt release6 s
c C@ s t j j | j S( N( R R t islinkR ( R ( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyR = s c C@ s. t j j | j o- t j | j | j k S( N( R R R R t readlinkR ( R ( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyR @ s c C@ s, t j j | j r( t j | j n d S( N( R R R R R ( R ( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyt
break_lockD s N( t __name__t
__module__t __doc__R R R R R R R R ( ( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyR
s # ( t
__future__R R R t R R R R R R ( ( ( sH /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.pyt s (PK ! 6$hb
b
mkdirlockfile.pyonu [
abc @` s d d l m Z m Z d d l Z d d l Z d d l Z d d l Z d d l m Z m Z m
Z
m Z m Z m
Z
d e f d YZ d S( i ( t absolute_importt divisionNi ( t LockBaset
LockFailedt NotLockedt NotMyLockt LockTimeoutt
AlreadyLockedt
MkdirLockFilec B` sM e Z d Z e d d Z d d Z d Z d Z d Z d Z
RS( s" Lock file by creating a directory.c C` sK t j | | | | t j j | j d | j | j | j f | _ d S( ss
>>> lock = MkdirLockFile('somefile')
>>> lock = MkdirLockFile('somefile', threaded=False)
s %s.%s%sN(
R t __init__t ost patht joint lock_filet hostnamet tnamet pidt unique_name( t selfR t threadedt timeout( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyR s
c C` s{ | d k r | n | j } t j } | d k rL | d k rL | | 7} n | d k ra d } n t d | d } x t rvy t j | j Wn t k
rXt j
d } | j t j k rBt j
j | j r d S| d k r2t j | k r2| d k r t d | j
q2t d | j
n t j | qst d | j qw Xt | j d j d Sqw Wd S( Ni g?i
i s& Timeout waiting to acquire lock for %ss %s is already lockeds failed to create %st wb( t NoneR t timet maxt TrueR
t mkdirR
t OSErrort syst exc_infot errnot EEXISTR t existsR R R t sleepR t opent close( R R t end_timet waitt err( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyt acquire s2
c C` sq | j s" t d | j n+ t j j | j sM t d | j n t j | j t j | j d S( Ns %s is not lockeds %s is locked, but not by me(
t is_lockedR R R
R R R t unlinkt rmdirR
( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyt releaseA s c C` s t j j | j S( N( R
R R R
( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyR( I s c C` s | j o t j j | j S( N( R( R
R R R ( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyt i_am_lockingL s c C` sh t j j | j rd x9 t j | j D]% } t j t j j | j | q( Wt j | j n d S( N( R
R R R
t listdirR) R R* ( R t name( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyt
break_lockP s #N( t __name__t
__module__t __doc__R R R R' R+ R( R, R/ ( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyR s
& ( t
__future__R R R R
R R t R R R R R R R ( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyt s .PK ! 6$hb
b
mkdirlockfile.pycnu [
abc @` s d d l m Z m Z d d l Z d d l Z d d l Z d d l Z d d l m Z m Z m
Z
m Z m Z m
Z
d e f d YZ d S( i ( t absolute_importt divisionNi ( t LockBaset
LockFailedt NotLockedt NotMyLockt LockTimeoutt
AlreadyLockedt
MkdirLockFilec B` sM e Z d Z e d d Z d d Z d Z d Z d Z d Z
RS( s" Lock file by creating a directory.c C` sK t j | | | | t j j | j d | j | j | j f | _ d S( ss
>>> lock = MkdirLockFile('somefile')
>>> lock = MkdirLockFile('somefile', threaded=False)
s %s.%s%sN(
R t __init__t ost patht joint lock_filet hostnamet tnamet pidt unique_name( t selfR t threadedt timeout( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyR s
c C` s{ | d k r | n | j } t j } | d k rL | d k rL | | 7} n | d k ra d } n t d | d } x t rvy t j | j Wn t k
rXt j
d } | j t j k rBt j
j | j r d S| d k r2t j | k r2| d k r t d | j
q2t d | j
n t j | qst d | j qw Xt | j d j d Sqw Wd S( Ni g?i
i s& Timeout waiting to acquire lock for %ss %s is already lockeds failed to create %st wb( t NoneR t timet maxt TrueR
t mkdirR
t OSErrort syst exc_infot errnot EEXISTR t existsR R R t sleepR t opent close( R R t end_timet waitt err( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyt acquire s2
c C` sq | j s" t d | j n+ t j j | j sM t d | j n t j | j t j | j d S( Ns %s is not lockeds %s is locked, but not by me(
t is_lockedR R R
R R R t unlinkt rmdirR
( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyt releaseA s c C` s t j j | j S( N( R
R R R
( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyR( I s c C` s | j o t j j | j S( N( R( R
R R R ( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyt i_am_lockingL s c C` sh t j j | j rd x9 t j | j D]% } t j t j j | j | q( Wt j | j n d S( N( R
R R R
t listdirR) R R* ( R t name( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyt
break_lockP s #N( t __name__t
__module__t __doc__R R R R' R+ R( R, R/ ( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyR s
& ( t
__future__R R R R
R R t R R R R R R R ( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.pyt s .PK ! g}Ha_ _ sqlitelockfile.pyonu [
abc @` s d d l m Z m Z d d l Z d d l Z y e Wn e k
rO e Z n Xd d l m Z m
Z
m Z m Z m
Z
d e f d YZ d S( i ( t absolute_importt divisionNi ( t LockBaset NotLockedt NotMyLockt LockTimeoutt
AlreadyLockedt SQLiteLockFilec B` s\ e Z d Z d Z e d d Z d d Z d Z d Z d Z
d Z d Z RS( s Demonstrate SQL-based locking.c
C` s t j | | | | t | j | _ t | j | _ t j d k r d d l } | j \ } } t
j | t
j | ~ ~ | t _ n d d l
} | j t j | _ | j j } y | j d Wn | j k
r n0 X| j j d d l } | j t
j t j d S( su
>>> lock = SQLiteLockFile('somefile')
>>> lock = SQLiteLockFile('somefile', threaded=False)
i NsG create table locks( lock_file varchar(32), unique_name varchar(32))( R t __init__t unicodet lock_filet unique_nameR t testdbt Nonet tempfilet mkstempt ost closet unlinkt sqlite3t connectt
connectiont cursort executet OperationalErrort committ atexitt register(
t selft patht threadedt timeoutR t _fdR R t cR ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyR s(
c C` s | d k r | n | j } t j } | d k rL | d k rL | | 7} n | d k ra d } n | d k rv d } n
| d } | j j } x;t r| j s.| j d | j | j f | j j
| j d | j f | j } t | d k r'| j d | j f | j j
qfd Sn8 | j d | j f | j } t | d k rfd S| d k rt j | k r| d k rt
d | j qt d | j n t j | q Wd S(
Ni g?i
s; insert into locks (lock_file, unique_name) values (?, ?)s* select * from locks where unique_name = ?i s( delete from locks where unique_name = ?s& Timeout waiting to acquire lock for %ss %s is already locked( R
R t timeR R t Truet is_lockedR R
R R t fetchallt lenR R R t sleep( R R t end_timet waitR t rows( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyt acquire5 sD
c C` s | j s" t d | j n | j sP t d | j | j f n | j j } | j d | j f | j j
d S( Ns %s is not lockeds# %s is locked, but not by me (by %s)s( delete from locks where unique_name = ?( R$ R R t i_am_lockingR R t _who_is_lockingR R R R ( R R ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyt releaset s
c C` s3 | j j } | j d | j f | j d S( Ns2 select unique_name from locks where lock_file = ?i ( R R R R
t fetchone( R R ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyR- s
c C` s7 | j j } | j d | j f | j } | S( Ns( select * from locks where lock_file = ?( R R R R
R% ( R R R* ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyR$ s
c C` s7 | j j } | j d | j | j f | j S( Ns? select * from locks where lock_file = ? and unique_name = ?( R R R R
R R% ( R R ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyR, s c C` s6 | j j } | j d | j f | j j d S( Ns& delete from locks where lock_file = ?( R R R R
R ( R R ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyt
break_lock s
N(
t __name__t
__module__t __doc__R
R R# R R+ R. R- R$ R, R0 ( ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyR s " ? ( t
__future__R R R" R R t NameErrort strt R R R R R R ( ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyt s
(PK ! # 8
8
symlinklockfile.pynu [ from __future__ import absolute_import
import os
import time
from . import (LockBase, NotLocked, NotMyLock, LockTimeout,
AlreadyLocked)
class SymlinkLockFile(LockBase):
"""Lock access to a file using symlink(2)."""
def __init__(self, path, threaded=True, timeout=None):
# super(SymlinkLockFile).__init(...)
LockBase.__init__(self, path, threaded, timeout)
# split it back!
self.unique_name = os.path.split(self.unique_name)[1]
def acquire(self, timeout=None):
# Hopefully unnecessary for symlink.
# try:
# open(self.unique_name, "wb").close()
# except IOError:
# raise LockFailed("failed to create %s" % self.unique_name)
timeout = timeout if timeout is not None else self.timeout
end_time = time.time()
if timeout is not None and timeout > 0:
end_time += timeout
while True:
# Try and create a symbolic link to it.
try:
os.symlink(self.unique_name, self.lock_file)
except OSError:
# Link creation failed. Maybe we've double-locked?
if self.i_am_locking():
# Linked to out unique name. Proceed.
return
else:
# Otherwise the lock creation failed.
if timeout is not None and time.time() > end_time:
if timeout > 0:
raise LockTimeout("Timeout waiting to acquire"
" lock for %s" %
self.path)
else:
raise AlreadyLocked("%s is already locked" %
self.path)
time.sleep(timeout / 10 if timeout is not None else 0.1)
else:
# Link creation succeeded. We're good to go.
return
def release(self):
if not self.is_locked():
raise NotLocked("%s is not locked" % self.path)
elif not self.i_am_locking():
raise NotMyLock("%s is locked, but not by me" % self.path)
os.unlink(self.lock_file)
def is_locked(self):
return os.path.islink(self.lock_file)
def i_am_locking(self):
return (os.path.islink(self.lock_file)
and os.readlink(self.lock_file) == self.unique_name)
def break_lock(self):
if os.path.islink(self.lock_file): # exists && link
os.unlink(self.lock_file)
PK !
#
# 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.
"""
from __future__ import absolute_import
import errno
import os
import time
from . import (LockBase, AlreadyLocked, LockFailed, NotLocked, NotMyLock,
LockTimeout)
class PIDLockFile(LockBase):
""" Lockfile implemented as a Unix PID file.
The lock file is a normal file named by the attribute `path`.
A lock's PID file contains a single line of text, containing
the process ID (PID) of the process that acquired the lock.
>>> lock = PIDLockFile('somefile')
>>> lock = PIDLockFile('somefile')
"""
def __init__(self, path, threaded=False, timeout=None):
# pid lockfiles don't support threaded operation, so always force
# False as the threaded arg.
LockBase.__init__(self, path, False, timeout)
self.unique_name = self.path
def read_pid(self):
""" Get the PID from the lock file.
"""
return read_pid_from_pidfile(self.path)
def is_locked(self):
""" Test if the lock is currently held.
The lock is held if the PID file for this lock exists.
"""
return os.path.exists(self.path)
def i_am_locking(self):
""" Test if the lock is held by the current process.
Returns ``True`` if the current process ID matches the
number stored in the PID file.
"""
return self.is_locked() and os.getpid() == self.read_pid()
def acquire(self, timeout=None):
""" Acquire the lock.
Creates the PID file for this lock, or raises an error if
the lock could not be acquired.
"""
timeout = timeout if timeout is not None else self.timeout
end_time = time.time()
if timeout is not None and timeout > 0:
end_time += timeout
while True:
try:
write_pid_to_pidfile(self.path)
except OSError as exc:
if exc.errno == errno.EEXIST:
# The lock creation failed. Maybe sleep a bit.
if time.time() > end_time:
if timeout is not None and timeout > 0:
raise LockTimeout("Timeout waiting to acquire"
" lock for %s" %
self.path)
else:
raise AlreadyLocked("%s is already locked" %
self.path)
time.sleep(timeout is not None and timeout / 10 or 0.1)
else:
raise LockFailed("failed to create %s" % self.path)
else:
return
def release(self):
""" Release the lock.
Removes the PID file to release the lock, or raises an
error if the current process does not hold the lock.
"""
if not self.is_locked():
raise NotLocked("%s is not locked" % self.path)
if not self.i_am_locking():
raise NotMyLock("%s is locked, but not by me" % self.path)
remove_existing_pidfile(self.path)
def break_lock(self):
""" Break an existing lock.
Removes the PID file if it already exists, otherwise does
nothing.
"""
remove_existing_pidfile(self.path)
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 cannot be read, or if the content is
not a valid PID, return ``None``.
"""
pid = None
try:
pidfile = open(pidfile_path, 'r')
except IOError:
pass
else:
# 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:
pass
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 = 0o644
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()
pidfile.write("%s\n" % pid)
pidfile.close()
def remove_existing_pidfile(pidfile_path):
""" Remove the named PID file if it exists.
Removing a PID file that doesn't already exist puts us in the
desired state, so we ignore the condition if the file does not
exist.
"""
try:
os.remove(pidfile_path)
except OSError as exc:
if exc.errno == errno.ENOENT:
pass
else:
raise
PK ! iY] ] linklockfile.pycnu [
abc @@ sp d d l m Z d d l Z d d l Z d d l m Z m Z m Z m Z m Z m
Z
d e f d YZ d S( i ( t absolute_importNi ( t LockBaset
LockFailedt NotLockedt NotMyLockt LockTimeoutt
AlreadyLockedt LinkLockFilec B@ s> e Z d Z d d Z d Z d Z d Z d Z RS( s Lock access to a file using atomic property of link(2).
>>> lock = LinkLockFile('somefile')
>>> lock = LinkLockFile('somefile', threaded=False)
c C@ s~ y t | j d j Wn$ t k
r@ t d | j n X| d k rS | n | j } t j } | d k r | d k r | | 7} n x t ryy t j
| j | j Wn t k
rqt j
| j j } | d k r d S| d k rKt j | k rKt j | j | d k r5t d | j qKt d | j n t j | d k rg| d pjd q Xd Sq Wd S( Nt wbs failed to create %si i s& Timeout waiting to acquire lock for %ss %s is already lockedi
g?( t opent unique_namet closet IOErrorR t Nonet timeoutt timet Truet ost linkt lock_filet OSErrort statt st_nlinkt unlinkR t pathR t sleep( t selfR t end_timet nlinks( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyt acquire s0
'c C@ sq | j s" t d | j n+ t j j | j sM t d | j n t j | j t j | j d S( Ns %s is not lockeds %s is locked, but not by me( t is_lockedR R R t existsR
R R R ( R ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyt release7 s c C@ s t j j | j S( N( R R R R ( R ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyR ? s c C@ s: | j o9 t j j | j o9 t j | j j d k S( Ni ( R R R R R
R R ( R ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyt i_am_lockingB s c C@ s, t j j | j r( t j | j n d S( N( R R R R R ( R ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyt
break_lockG s N( t __name__t
__module__t __doc__R
R R R R! R" ( ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyR
s & ( t
__future__R R R t R R R R R R R ( ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.pyt s .PK ! g}Ha_ _ sqlitelockfile.pycnu [
abc @` s d d l m Z m Z d d l Z d d l Z y e Wn e k
rO e Z n Xd d l m Z m
Z
m Z m Z m
Z
d e f d YZ d S( i ( t absolute_importt divisionNi ( t LockBaset NotLockedt NotMyLockt LockTimeoutt
AlreadyLockedt SQLiteLockFilec B` s\ e Z d Z d Z e d d Z d d Z d Z d Z d Z
d Z d Z RS( s Demonstrate SQL-based locking.c
C` s t j | | | | t | j | _ t | j | _ t j d k r d d l } | j \ } } t
j | t
j | ~ ~ | t _ n d d l
} | j t j | _ | j j } y | j d Wn | j k
r n0 X| j j d d l } | j t
j t j d S( su
>>> lock = SQLiteLockFile('somefile')
>>> lock = SQLiteLockFile('somefile', threaded=False)
i NsG create table locks( lock_file varchar(32), unique_name varchar(32))( R t __init__t unicodet lock_filet unique_nameR t testdbt Nonet tempfilet mkstempt ost closet unlinkt sqlite3t connectt
connectiont cursort executet OperationalErrort committ atexitt register(
t selft patht threadedt timeoutR t _fdR R t cR ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyR s(
c C` s | d k r | n | j } t j } | d k rL | d k rL | | 7} n | d k ra d } n | d k rv d } n
| d } | j j } x;t r| j s.| j d | j | j f | j j
| j d | j f | j } t | d k r'| j d | j f | j j
qfd Sn8 | j d | j f | j } t | d k rfd S| d k rt j | k r| d k rt
d | j qt d | j n t j | q Wd S(
Ni g?i
s; insert into locks (lock_file, unique_name) values (?, ?)s* select * from locks where unique_name = ?i s( delete from locks where unique_name = ?s& Timeout waiting to acquire lock for %ss %s is already locked( R
R t timeR R t Truet is_lockedR R
R R t fetchallt lenR R R t sleep( R R t end_timet waitR t rows( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyt acquire5 sD
c C` s | j s" t d | j n | j sP t d | j | j f n | j j } | j d | j f | j j
d S( Ns %s is not lockeds# %s is locked, but not by me (by %s)s( delete from locks where unique_name = ?( R$ R R t i_am_lockingR R t _who_is_lockingR R R R ( R R ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyt releaset s
c C` s3 | j j } | j d | j f | j d S( Ns2 select unique_name from locks where lock_file = ?i ( R R R R
t fetchone( R R ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyR- s
c C` s7 | j j } | j d | j f | j } | S( Ns( select * from locks where lock_file = ?( R R R R
R% ( R R R* ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyR$ s
c C` s7 | j j } | j d | j | j f | j S( Ns? select * from locks where lock_file = ? and unique_name = ?( R R R R
R R% ( R R ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyR, s c C` s6 | j j } | j d | j f | j j d S( Ns& delete from locks where lock_file = ?( R R R R
R ( R R ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyt
break_lock s
N(
t __name__t
__module__t __doc__R
R R# R R+ R. R- R$ R, R0 ( ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyR s " ? ( t
__future__R R R" R R t NameErrort strt R R R R R R ( ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.pyt s
(PK ! +'\
\
linklockfile.pynu [ from __future__ import absolute_import
import time
import os
from . import (LockBase, LockFailed, NotLocked, NotMyLock, LockTimeout,
AlreadyLocked)
class LinkLockFile(LockBase):
"""Lock access to a file using atomic property of link(2).
>>> lock = LinkLockFile('somefile')
>>> lock = LinkLockFile('somefile', threaded=False)
"""
def acquire(self, timeout=None):
try:
open(self.unique_name, "wb").close()
except IOError:
raise LockFailed("failed to create %s" % self.unique_name)
timeout = timeout if timeout is not None else self.timeout
end_time = time.time()
if timeout is not None and timeout > 0:
end_time += timeout
while True:
# Try and create a hard link to it.
try:
os.link(self.unique_name, self.lock_file)
except OSError:
# Link creation failed. Maybe we've double-locked?
nlinks = os.stat(self.unique_name).st_nlink
if nlinks == 2:
# The original link plus the one I created == 2. We're
# good to go.
return
else:
# Otherwise the lock creation failed.
if timeout is not None and time.time() > end_time:
os.unlink(self.unique_name)
if timeout > 0:
raise LockTimeout("Timeout waiting to acquire"
" lock for %s" %
self.path)
else:
raise AlreadyLocked("%s is already locked" %
self.path)
time.sleep(timeout is not None and timeout / 10 or 0.1)
else:
# Link creation succeeded. We're good to go.
return
def release(self):
if not self.is_locked():
raise NotLocked("%s is not locked" % self.path)
elif not os.path.exists(self.unique_name):
raise NotMyLock("%s is locked, but not by me" % self.path)
os.unlink(self.unique_name)
os.unlink(self.lock_file)
def is_locked(self):
return os.path.exists(self.lock_file)
def i_am_locking(self):
return (self.is_locked() and
os.path.exists(self.unique_name) and
os.stat(self.unique_name).st_nlink == 2)
def break_lock(self):
if os.path.exists(self.lock_file):
os.unlink(self.lock_file)
PK ! | pidlockfile.pyonu [
abc @@ s d Z d d l m Z d d l Z d d l Z d d l Z d d l m Z m Z m Z m
Z
m Z m Z d e f d YZ
d Z d Z d
Z d S( s8 Lockfile behaviour implemented via Unix PID files.
i ( t absolute_importNi ( t LockBaset
AlreadyLockedt
LockFailedt NotLockedt NotMyLockt LockTimeoutt PIDLockFilec B@ sV e Z d Z e d d Z d Z d Z d Z d d Z d Z
d Z RS( sA Lockfile implemented as a Unix PID file.
The lock file is a normal file named by the attribute `path`.
A lock's PID file contains a single line of text, containing
the process ID (PID) of the process that acquired the lock.
>>> lock = PIDLockFile('somefile')
>>> lock = PIDLockFile('somefile')
c C@ s& t j | | t | | j | _ d S( N( R t __init__t Falset patht unique_name( t selfR
t threadedt timeout( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyR $ s c C@ s
t | j S( s- Get the PID from the lock file.
( t read_pid_from_pidfileR
( R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt read_pid* s c C@ s t j j | j S( sv Test if the lock is currently held.
The lock is held if the PID file for this lock exists.
( t osR
t exists( R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt is_locked/ s c C@ s" | j o! t j | j k S( s Test if the lock is held by the current process.
Returns ``True`` if the current process ID matches the
number stored in the PID file.
( R R t getpidR ( R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt i_am_locking7 s c C@ s) | d k r | n | j } t j } | d k rL | d k rL | | 7} n x t r$y t | j Wn t k
r } | j t j k rt j | k r | d k r | d k r t d | j q t
d | j n t j | d k r | d p d q!t d | j qO Xd SqO Wd S( s Acquire the lock.
Creates the PID file for this lock, or raises an error if
the lock could not be acquired.
i s& Timeout waiting to acquire lock for %ss %s is already lockedi
g?s failed to create %sN(
t NoneR t timet Truet write_pid_to_pidfileR
t OSErrort errnot EEXISTR R t sleepR ( R R t end_timet exc( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt acquire? s$
&c C@ sU | j s" t d | j n | j sD t d | j n t | j d S( s Release the lock.
Removes the PID file to release the lock, or raises an
error if the current process does not hold the lock.
s %s is not lockeds %s is locked, but not by meN( R R R
R R t remove_existing_pidfile( R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt release_ s
c C@ s t | j d S( s Break an existing lock.
Removes the PID file if it already exists, otherwise does
nothing.
N( R! R
( R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt
break_lockl s N( t __name__t
__module__t __doc__R R R R R R R R" R# ( ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyR s
c C@ sq d } y t | d } Wn t k
r, nA X| j j } y t | } Wn t k
rb n X| j | S( s 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 cannot be read, or if the content is
not a valid PID, return ``None``.
t rN( R t opent IOErrort readlinet stript intt
ValueErrort close( t pidfile_patht pidt pidfilet line( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyR v s
c C@ so t j t j Bt j B} d } t j | | | } t j | d } t j } | j d | | j d S( s 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.
i t ws %s
N( R t O_CREATt O_EXCLt O_WRONLYR( t fdopenR t writeR. ( R/ t
open_flagst open_modet
pidfile_fdR1 R0 ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyR s c C@ sC y t j | Wn+ t k
r> } | j t j k r8 q? n Xd S( s Remove the named PID file if it exists.
Removing a PID file that doesn't already exist puts us in the
desired state, so we ignore the condition if the file does not
exist.
N( R t removeR R t ENOENT( R/ R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyR! s ( R& t
__future__R R R R t R R R R R R R R R R! ( ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.pyt
s .] " PK ! Ǟ+P/ P/ __init__.pycnu [
abc
@@ s d Z d d l m Z d d l Z d d l Z d d l Z d d l Z d d l Z e e d sp e j e _
n e e j d s e j j e j _
n d d d d d
d d d
d d d d d g
Z d e f d YZ d e f d YZ d e f d YZ d e f d YZ d
e f d YZ d e f d YZ d e f d YZ d
e f d YZ d e f d YZ d e f d YZ d Z d Z d Z d! Z d d" Z e e d# rd$ d% l! m" Z# e# j$ Z% n d$ d& l! m& Z' e' j( Z% e% Z) d S(' s
lockfile.py - Platform-independent advisory file locks.
Requires Python 2.5 unless you apply 2.4.diff
Locking is done on a per-thread basis instead of a per-process basis.
Usage:
>>> lock = LockFile('somefile')
>>> try:
... lock.acquire()
... except AlreadyLocked:
... print 'somefile', 'is locked already.'
... except LockFailed:
... print 'somefile', 'can\'t be locked.'
... else:
... print 'got lock'
got lock
>>> print lock.is_locked()
True
>>> lock.release()
>>> lock = LockFile('somefile')
>>> print lock.is_locked()
False
>>> with lock:
... print lock.is_locked()
True
>>> print lock.is_locked()
False
>>> lock = LockFile('somefile')
>>> # It is okay to lock twice from the same thread...
>>> with lock:
... lock.acquire()
...
>>> # Though no counter is kept, so you can't unlock multiple times...
>>> print lock.is_locked()
False
Exceptions:
Error - base class for other exceptions
LockError - base class for all locking exceptions
AlreadyLocked - Another thread or process already holds the lock
LockFailed - Lock failed for some other reason
UnlockError - base class for all unlocking exceptions
AlreadyUnlocked - File was not locked.
NotMyLock - File was locked but not by the current thread/process
i ( t absolute_importNt current_threadt get_namet Errort LockErrort LockTimeoutt
AlreadyLockedt
LockFailedt UnlockErrort NotLockedt NotMyLockt LinkFileLockt
MkdirFileLockt SQLiteFileLockt LockBaset lockedc B@ s e Z d Z RS( sw
Base class for other exceptions.
>>> try:
... raise Error
... except Exception:
... pass
( t __name__t
__module__t __doc__( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR J s c B@ s e Z d Z RS( s
Base class for error arising from attempts to acquire the lock.
>>> try:
... raise LockError
... except Error:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR V s c B@ s e Z d Z RS( s Raised when lock creation fails within a user-defined period of time.
>>> try:
... raise LockTimeout
... except LockError:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR b s c B@ s e Z d Z RS( s Some other thread/process is locking the file.
>>> try:
... raise AlreadyLocked
... except LockError:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR m s c B@ s e Z d Z RS( s Lock file creation failed for some other reason.
>>> try:
... raise LockFailed
... except LockError:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR x s c B@ s e Z d Z RS( s
Base class for errors arising from attempts to release the lock.
>>> try:
... raise UnlockError
... except Error:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR s c B@ s e Z d Z RS( s Raised when an attempt is made to unlock an unlocked file.
>>> try:
... raise NotLocked
... except UnlockError:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR s c B@ s e Z d Z RS( s Raised when an attempt is made to unlock a file someone else locked.
>>> try:
... raise NotMyLock
... except UnlockError:
... pass
( R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR
s t _SharedBasec B@ sA e Z d Z d d Z d Z d Z d Z d Z RS( c C@ s
| | _ d S( N( t path( t selfR ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt __init__ s c C@ s t d d S( s
Acquire the lock.
* If timeout is omitted (or None), wait forever trying to lock the
file.
* If timeout > 0, try to acquire the lock for that many seconds. If
the lock period expires and the file is still locked, raise
LockTimeout.
* If timeout <= 0, raise AlreadyLocked immediately if the file is
already locked.
s implement in subclassN( t NotImplemented( R t timeout( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt acquire s c C@ s t d d S( sX
Release the lock.
If the file is not locked, raise NotLocked.
s implement in subclassN( R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt release s c C@ s | j | S( s*
Context manager support.
( R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt __enter__ s
c G@ s | j d S( s*
Context manager support.
N( R ( R t _exc( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt __exit__ s c C@ s d | j j | j f S( Ns <%s: %r>( t __class__R R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt __repr__ s N( R R R t NoneR R R R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR s c B@ sA e Z d Z e d d Z d Z d Z d Z d Z RS( s. Base class for platform-specific lock classes.c C@ s t t | j | t j j | d | _ t j | _ t j
| _ | r t j
} t | d t | } d | d @| _ n d | _ t j j | j } t j j | d | j | j | j t | j f | _ | | _ d S( si
>>> lock = LockBase('somefile')
>>> lock = LockBase('somefile', threaded=False)
s .lockt idents -%xI t s %s%s.%s%sN( t superR R t osR t abspatht lock_filet sockett gethostnamet hostnamet getpidt pidt threadingR t getattrt hasht tnamet dirnamet joint unique_nameR ( R R t threadedR t tR! R0 ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR s c C@ s t d d S( s9
Tell whether or not the file is locked.
s implement in subclassN( R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt is_locked s c C@ s t d d S( sA
Return True if this object is locking the file.
s implement in subclassN( R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt i_am_locking s c C@ s t d d S( sN
Remove a lock. Useful if a locking thread failed to unlock.
s implement in subclassN( R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyt
break_lock s c C@ s d | j j | j | j f S( Ns <%s: %r -- %r>( R R R2 R ( R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR s N(
R R R t TrueR R R5 R6 R7 R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.pyR s ! c O@ sm t j d | t d d t | d t s: | d } n t | d k r` | r` t | d 4 sF -: PK ! sqlitelockfile.pynu [ from __future__ import absolute_import, division
import time
import os
try:
unicode
except NameError:
unicode = str
from . import LockBase, NotLocked, NotMyLock, LockTimeout, AlreadyLocked
class SQLiteLockFile(LockBase):
"Demonstrate SQL-based locking."
testdb = None
def __init__(self, path, threaded=True, timeout=None):
"""
>>> lock = SQLiteLockFile('somefile')
>>> lock = SQLiteLockFile('somefile', threaded=False)
"""
LockBase.__init__(self, path, threaded, timeout)
self.lock_file = unicode(self.lock_file)
self.unique_name = unicode(self.unique_name)
if SQLiteLockFile.testdb is None:
import tempfile
_fd, testdb = tempfile.mkstemp()
os.close(_fd)
os.unlink(testdb)
del _fd, tempfile
SQLiteLockFile.testdb = testdb
import sqlite3
self.connection = sqlite3.connect(SQLiteLockFile.testdb)
c = self.connection.cursor()
try:
c.execute("create table locks"
"("
" lock_file varchar(32),"
" unique_name varchar(32)"
")")
except sqlite3.OperationalError:
pass
else:
self.connection.commit()
import atexit
atexit.register(os.unlink, SQLiteLockFile.testdb)
def acquire(self, timeout=None):
timeout = timeout if timeout is not None else self.timeout
end_time = time.time()
if timeout is not None and timeout > 0:
end_time += timeout
if timeout is None:
wait = 0.1
elif timeout <= 0:
wait = 0
else:
wait = timeout / 10
cursor = self.connection.cursor()
while True:
if not self.is_locked():
# Not locked. Try to lock it.
cursor.execute("insert into locks"
" (lock_file, unique_name)"
" values"
" (?, ?)",
(self.lock_file, self.unique_name))
self.connection.commit()
# Check to see if we are the only lock holder.
cursor.execute("select * from locks"
" where unique_name = ?",
(self.unique_name,))
rows = cursor.fetchall()
if len(rows) > 1:
# Nope. Someone else got there. Remove our lock.
cursor.execute("delete from locks"
" where unique_name = ?",
(self.unique_name,))
self.connection.commit()
else:
# Yup. We're done, so go home.
return
else:
# Check to see if we are the only lock holder.
cursor.execute("select * from locks"
" where unique_name = ?",
(self.unique_name,))
rows = cursor.fetchall()
if len(rows) == 1:
# We're the locker, so go home.
return
# Maybe we should wait a bit longer.
if timeout is not None and time.time() > end_time:
if timeout > 0:
# No more waiting.
raise LockTimeout("Timeout waiting to acquire"
" lock for %s" %
self.path)
else:
# Someone else has the lock and we are impatient..
raise AlreadyLocked("%s is already locked" % self.path)
# Well, okay. We'll give it a bit longer.
time.sleep(wait)
def release(self):
if not self.is_locked():
raise NotLocked("%s is not locked" % self.path)
if not self.i_am_locking():
raise NotMyLock("%s is locked, but not by me (by %s)" %
(self.unique_name, self._who_is_locking()))
cursor = self.connection.cursor()
cursor.execute("delete from locks"
" where unique_name = ?",
(self.unique_name,))
self.connection.commit()
def _who_is_locking(self):
cursor = self.connection.cursor()
cursor.execute("select unique_name from locks"
" where lock_file = ?",
(self.lock_file,))
return cursor.fetchone()[0]
def is_locked(self):
cursor = self.connection.cursor()
cursor.execute("select * from locks"
" where lock_file = ?",
(self.lock_file,))
rows = cursor.fetchall()
return not not rows
def i_am_locking(self):
cursor = self.connection.cursor()
cursor.execute("select * from locks"
" where lock_file = ?"
" and unique_name = ?",
(self.lock_file, self.unique_name))
return not not cursor.fetchall()
def break_lock(self):
cursor = self.connection.cursor()
cursor.execute("delete from locks"
" where lock_file = ?",
(self.lock_file,))
self.connection.commit()
PK ! f . . 0 __pycache__/symlinklockfile.cpython-36.opt-1.pycnu [ 3
Pf8
@ sL d dl mZ d dlZd dlZddlmZmZmZmZm Z G dd deZ
dS ) )absolute_importN )LockBase NotLocked NotMyLock LockTimeout
AlreadyLockedc @ sD e Zd ZdZdddZdddZdd Zd
d Zd d
Zdd Z dS )SymlinkLockFilez'Lock access to a file using symlink(2).TNc C s( t j| ||| tjj| jd | _d S )Nr )r __init__ospathsplit unique_name)selfr Zthreadedtimeout r %/usr/lib/python3.6/symlinklockfile.pyr
s zSymlinkLockFile.__init__c C s |d k r |n| j }tj }|d k r2|dkr2||7 }xytj| j| j W nt tk
r | j rdd S |d k rtj |kr|dkrtd| j nt
d| j tj |d k r|d nd Y q4X d S q4W d S )Nr z&Timeout waiting to acquire lock for %sz%s is already locked
g?) r timer symlinkr lock_fileOSError i_am_lockingr r r Zsleep)r r Zend_timer r r acquire s$
zSymlinkLockFile.acquirec C s> | j std| j n| j s.td| j tj| j d S )Nz%s is not lockedz%s is locked, but not by me) is_lockedr r r r r unlinkr )r r r r release6 s
zSymlinkLockFile.releasec C s t jj| jS )N)r r islinkr )r r r r r = s zSymlinkLockFile.is_lockedc C s t jj| jo t j| j| jkS )N)r r r r readlinkr )r r r r r @ s z SymlinkLockFile.i_am_lockingc C s t jj| jrt j| j d S )N)r r r r r )r r r r
break_lockD s zSymlinkLockFile.break_lock)TN)N)
__name__
__module__ __qualname____doc__r
r r r r r r r r r r
s
#r ) Z
__future__r r r r r r r r r r r r r s PK ! dF , __pycache__/pidlockfile.cpython-36.opt-1.pycnu [ 3
Pf @ st d Z ddlmZ ddlZddlZddlZddlmZmZm Z m
Z
m Z m Z G dd deZ
dd Zd
d Zd d
ZdS )z8 Lockfile behaviour implemented via Unix PID files.
)absolute_importN )LockBase
AlreadyLocked
LockFailed NotLocked NotMyLock LockTimeoutc @ sL e Zd ZdZdddZdd Zdd Zd
d Zdd d
Zdd Z dd Z
dS ) PIDLockFileaA Lockfile implemented as a Unix PID file.
The lock file is a normal file named by the attribute `path`.
A lock's PID file contains a single line of text, containing
the process ID (PID) of the process that acquired the lock.
>>> lock = PIDLockFile('somefile')
>>> lock = PIDLockFile('somefile')
FNc C s t j| |d| | j| _d S )NF)r __init__pathZ unique_name)selfr Zthreadedtimeout r !/usr/lib/python3.6/pidlockfile.pyr $ s zPIDLockFile.__init__c C s
t | jS )z- Get the PID from the lock file.
)read_pid_from_pidfiler )r
r r r read_pid* s zPIDLockFile.read_pidc C s t jj| jS )zv Test if the lock is currently held.
The lock is held if the PID file for this lock exists.
)osr exists)r
r r r is_locked/ s zPIDLockFile.is_lockedc C s | j otj | j kS )z Test if the lock is held by the current process.
Returns ``True`` if the current process ID matches the
number stored in the PID file.
)r r getpidr )r
r r r i_am_locking7 s zPIDLockFile.i_am_lockingc C s |dk r |n| j }tj }|dk r2|dkr2||7 }xyt| j W n tk
r } zv|jtjkrtj |kr|dk r|dkrtd| j ntd| j tj |dk r|d pd nt
d| j W Y dd}~X q4X dS q4W dS )z Acquire the lock.
Creates the PID file for this lock, or raises an error if
the lock could not be acquired.
Nr z&Timeout waiting to acquire lock for %sz%s is already locked
g?zfailed to create %s) r timewrite_pid_to_pidfiler OSErrorerrnoZEEXISTr r Zsleepr )r
r Zend_timeexcr r r acquire? s$
zPIDLockFile.acquirec C s: | j std| j | j s,td| j t| j dS )z Release the lock.
Removes the PID file to release the lock, or raises an
error if the current process does not hold the lock.
z%s is not lockedz%s is locked, but not by meN)r r r r r remove_existing_pidfile)r
r r r release_ s
zPIDLockFile.releasec C s t | j dS )z Break an existing lock.
Removes the PID file if it already exists, otherwise does
nothing.
N)r r )r
r r r
break_lockl s zPIDLockFile.break_lock)FN)N) __name__
__module__ __qualname____doc__r r r r r r r! r r r r r
s
r
c C sb d}yt | d}W n tk
r& Y n8X |j j }y t|}W n tk
rT Y nX |j |S )z 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 cannot be read, or if the content is
not a valid PID, return ``None``.
Nr)openIOErrorreadlinestripint
ValueErrorclose) pidfile_pathpidpidfileliner r r r v s r c C sR t jt jB t jB }d}t j| ||}t j|d}t j }|jd| |j dS )u 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.
i wz%s
N) r O_CREATO_EXCLO_WRONLYr' fdopenr writer- )r. Z
open_flagsZ open_modeZ
pidfile_fdr0 r/ r r r r s r c C sF yt j| W n2 tk
r@ } z|jtjkr.n W Y dd}~X nX dS )z Remove the named PID file if it exists.
Removing a PID file that doesn't already exist puts us in the
desired state, so we ignore the condition if the file does not
exist.
N)r remover r ENOENT)r. r r r r r s r )r% Z
__future__r r r r r r r r r r r
r r r r r r r
s ]"PK ! V V ) __pycache__/sqlitelockfile.cpython-36.pycnu [ 3
Pf @ sr d dl mZmZ d dlZd dlZye W n ek
r@ eZY nX ddlm Z m
Z
m Z m Z m
Z
G dd de ZdS ) )absolute_importdivisionN )LockBase NotLocked NotMyLock LockTimeout
AlreadyLockedc @ sP e Zd ZdZdZdddZdddZdd Zd
d Zd d
Z dd Z
dd Z dS )SQLiteLockFilez Demonstrate SQL-based locking.NTc
C s t j| ||| t| j| _t| j| _tjdkrdddl}|j \}}t j
| t j | ~~|t_ddl }|j
tj| _| jj }y|jd W n |jk
r Y n$X | jj ddl} | jt j tj dS )zu
>>> lock = SQLiteLockFile('somefile')
>>> lock = SQLiteLockFile('somefile', threaded=False)
Nr zGcreate table locks( lock_file varchar(32), unique_name varchar(32)))r __init__unicode lock_file unique_namer
testdbtempfileZmkstemposcloseunlinksqlite3Zconnect
connectioncursorexecuteZOperationalErrorcommitatexitregister)
selfpathZthreadedtimeoutr Z_fdr r cr r $/usr/lib/python3.6/sqlitelockfile.pyr s(
zSQLiteLockFile.__init__c C sH |d k r |n| j }tj }|d k r2|dkr2||7 }|d kr@d}n|dkrNd}n|d }| jj }x| j s|jd| j| jf | jj |jd| jf |j }t
|dkr|jd| jf | jj qd S n(|jd| jf |j }t
|dkrd S |d k r6tj |kr6|dkr(t d| j nt
d | j tj| qbW d S )
Nr g?
z;insert into locks (lock_file, unique_name) values (?, ?)z*select * from locks where unique_name = ?r z(delete from locks where unique_name = ?z&Timeout waiting to acquire lock for %sz%s is already locked)r timer r is_lockedr r
r r fetchalllenr r r Zsleep)r r Zend_timewaitr rowsr r r acquire5 sD
zSQLiteLockFile.acquirec C s\ | j std| j | j s4td| j| j f | jj }|j d| jf | jj
d S )Nz%s is not lockedz#%s is locked, but not by me (by %s)z(delete from locks where unique_name = ?) r# r r i_am_lockingr r _who_is_lockingr r r r )r r r r r releaset s
zSQLiteLockFile.releasec C s& | j j }|jd| jf |j d S )Nz2select unique_name from locks where lock_file = ?r )r r r r
Zfetchone)r r r r r r* s
z SQLiteLockFile._who_is_lockingc C s* | j j }|jd| jf |j }| S )Nz(select * from locks where lock_file = ?)r r r r
r$ )r r r' r r r r# s
zSQLiteLockFile.is_lockedc C s* | j j }|jd| j| jf |j S )Nz?select * from locks where lock_file = ? and unique_name = ?)r r r r
r r$ )r r r r r r) s
zSQLiteLockFile.i_am_lockingc C s( | j j }|jd| jf | j j d S )Nz&delete from locks where lock_file = ?)r r r r
r )r r r r r
break_lock s
zSQLiteLockFile.break_lock)TN)N) __name__
__module__ __qualname____doc__r r r( r+ r* r# r) r, r r r r r
s
"
? r
)Z
__future__r r r" r r NameErrorstr r r r r r r
r r r r s
PK ! f . . * __pycache__/symlinklockfile.cpython-36.pycnu [ 3
Pf8
@ sL d dl mZ d dlZd dlZddlmZmZmZmZm Z G dd deZ
dS ) )absolute_importN )LockBase NotLocked NotMyLock LockTimeout
AlreadyLockedc @ sD e Zd ZdZdddZdddZdd Zd
d Zd d
Zdd Z dS )SymlinkLockFilez'Lock access to a file using symlink(2).TNc C s( t j| ||| tjj| jd | _d S )Nr )r __init__ospathsplit unique_name)selfr Zthreadedtimeout r %/usr/lib/python3.6/symlinklockfile.pyr
s zSymlinkLockFile.__init__c C s |d k r |n| j }tj }|d k r2|dkr2||7 }xytj| j| j W nt tk
r | j rdd S |d k rtj |kr|dkrtd| j nt
d| j tj |d k r|d nd Y q4X d S q4W d S )Nr z&Timeout waiting to acquire lock for %sz%s is already locked
g?) r timer symlinkr lock_fileOSError i_am_lockingr r r Zsleep)r r Zend_timer r r acquire s$
zSymlinkLockFile.acquirec C s> | j std| j n| j s.td| j tj| j d S )Nz%s is not lockedz%s is locked, but not by me) is_lockedr r r r r unlinkr )r r r r release6 s
zSymlinkLockFile.releasec C s t jj| jS )N)r r islinkr )r r r r r = s zSymlinkLockFile.is_lockedc C s t jj| jo t j| j| jkS )N)r r r r readlinkr )r r r r r @ s z SymlinkLockFile.i_am_lockingc C s t jj| jrt j| j d S )N)r r r r r )r r r r
break_lockD s zSymlinkLockFile.break_lock)TN)N)
__name__
__module__ __qualname____doc__r
r r r r r r r r r r
s
#r ) Z
__future__r r r r r r r r r r r r r s PK ! dF & __pycache__/pidlockfile.cpython-36.pycnu [ 3
Pf @ st d Z ddlmZ ddlZddlZddlZddlmZmZm Z m
Z
m Z m Z G dd deZ
dd Zd
d Zd d
ZdS )z8 Lockfile behaviour implemented via Unix PID files.
)absolute_importN )LockBase
AlreadyLocked
LockFailed NotLocked NotMyLock LockTimeoutc @ sL e Zd ZdZdddZdd Zdd Zd
d Zdd d
Zdd Z dd Z
dS ) PIDLockFileaA Lockfile implemented as a Unix PID file.
The lock file is a normal file named by the attribute `path`.
A lock's PID file contains a single line of text, containing
the process ID (PID) of the process that acquired the lock.
>>> lock = PIDLockFile('somefile')
>>> lock = PIDLockFile('somefile')
FNc C s t j| |d| | j| _d S )NF)r __init__pathZ unique_name)selfr Zthreadedtimeout r !/usr/lib/python3.6/pidlockfile.pyr $ s zPIDLockFile.__init__c C s
t | jS )z- Get the PID from the lock file.
)read_pid_from_pidfiler )r
r r r read_pid* s zPIDLockFile.read_pidc C s t jj| jS )zv Test if the lock is currently held.
The lock is held if the PID file for this lock exists.
)osr exists)r
r r r is_locked/ s zPIDLockFile.is_lockedc C s | j otj | j kS )z Test if the lock is held by the current process.
Returns ``True`` if the current process ID matches the
number stored in the PID file.
)r r getpidr )r
r r r i_am_locking7 s zPIDLockFile.i_am_lockingc C s |dk r |n| j }tj }|dk r2|dkr2||7 }xyt| j W n tk
r } zv|jtjkrtj |kr|dk r|dkrtd| j ntd| j tj |dk r|d pd nt
d| j W Y dd}~X q4X dS q4W dS )z Acquire the lock.
Creates the PID file for this lock, or raises an error if
the lock could not be acquired.
Nr z&Timeout waiting to acquire lock for %sz%s is already locked
g?zfailed to create %s) r timewrite_pid_to_pidfiler OSErrorerrnoZEEXISTr r Zsleepr )r
r Zend_timeexcr r r acquire? s$
zPIDLockFile.acquirec C s: | j std| j | j s,td| j t| j dS )z Release the lock.
Removes the PID file to release the lock, or raises an
error if the current process does not hold the lock.
z%s is not lockedz%s is locked, but not by meN)r r r r r remove_existing_pidfile)r
r r r release_ s
zPIDLockFile.releasec C s t | j dS )z Break an existing lock.
Removes the PID file if it already exists, otherwise does
nothing.
N)r r )r
r r r
break_lockl s zPIDLockFile.break_lock)FN)N) __name__
__module__ __qualname____doc__r r r r r r r! r r r r r
s
r
c C sb d}yt | d}W n tk
r& Y n8X |j j }y t|}W n tk
rT Y nX |j |S )z 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 cannot be read, or if the content is
not a valid PID, return ``None``.
Nr)openIOErrorreadlinestripint
ValueErrorclose) pidfile_pathpidpidfileliner r r r v s r c C sR t jt jB t jB }d}t j| ||}t j|d}t j }|jd| |j dS )u 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.
i wz%s
N) r O_CREATO_EXCLO_WRONLYr' fdopenr writer- )r. Z
open_flagsZ open_modeZ
pidfile_fdr0 r/ r r r r s r c C sF yt j| W n2 tk
r@ } z|jtjkr.n W Y dd}~X nX dS )z Remove the named PID file if it exists.
Removing a PID file that doesn't already exist puts us in the
desired state, so we ignore the condition if the file does not
exist.
N)r remover r ENOENT)r. r r r r r s r )r% Z
__future__r r r r r r r r r r r
r r r r r r r
s ]"PK ! >> lock = MkdirLockFile('somefile')
>>> lock = MkdirLockFile('somefile', threaded=False)
z%s.%s%sN)
r __init__ospathjoin lock_fileZhostnameZtnamepid unique_name)selfr Zthreadedtimeout r #/usr/lib/python3.6/mkdirlockfile.pyr s
zMkdirLockFile.__init__c C s |d k r |n| j }tj }|d k r2|dkr2||7 }|d kr@d}ntd|d }xytj| j W n tk
r tj d }|j t j
krtj j | j
rd S |d k rtj |kr|dkrtd| j ntd| j tj| ntd| j Y qPX t| j
dj d S qPW d S ) Nr g?
r z&Timeout waiting to acquire lock for %sz%s is already lockedzfailed to create %swb)r timemaxr
mkdirr OSErrorsysexc_infoerrnoZEEXISTr existsr r r
Zsleepr openclose)r r Zend_timewaiterrr r r acquire s2
zMkdirLockFile.acquirec C sP | j std| j n tjj| js4td| j tj| j tj| j d S )Nz%s is not lockedz%s is locked, but not by me)
is_lockedr r r
r r r unlinkrmdirr )r r r r releaseA s zMkdirLockFile.releasec C s t jj| jS )N)r
r r r )r r r r r& I s zMkdirLockFile.is_lockedc C s | j otjj| jS )N)r& r
r r r )r r r r i_am_lockingL s zMkdirLockFile.i_am_lockingc C sJ t jj| jrFx*t j| jD ]}t jt jj| j| q W t j| j d S )N)r
r r r listdirr' r r( )r namer r r
break_lockP s zMkdirLockFile.break_lock)TN)N)
__name__
__module__ __qualname____doc__r r% r) r& r* r- r r r r r s
&r )Z
__future__r r r r
r r r r r r r r
r r r r r s PK ! ؚ - __pycache__/linklockfile.cpython-36.opt-1.pycnu [ 3
Pf\
@ sP d dl mZ d dlZd dlZddlmZmZmZmZm Z m
Z
G dd deZ dS ) )absolute_importN )LockBase
LockFailed NotLocked NotMyLock LockTimeout
AlreadyLockedc @ s: e Zd ZdZd
ddZdd Zdd Zd d
Zd d ZdS ) LinkLockFilezLock access to a file using atomic property of link(2).
>>> lock = LinkLockFile('somefile')
>>> lock = LinkLockFile('somefile', threaded=False)
Nc C s" yt | jdj W n" tk
r6 td| j Y nX |d k rD|n| j}tj }|d k rj|dkrj||7 }xytj| j| j W n t
k
r tj | jj }|dkrd S |d k rtj |krtj
| j |dkrtd| j ntd| j tj|d k r
|d p d Y qlX d S qlW d S ) Nwbzfailed to create %sr z&Timeout waiting to acquire lock for %sz%s is already locked
g?)open unique_namecloseIOErrorr timeouttimeoslink lock_fileOSErrorstatst_nlinkunlinkr pathr Zsleep)selfr Zend_timeZnlinks r "/usr/lib/python3.6/linklockfile.pyacquire s0
$zLinkLockFile.acquirec C sP | j std| j n tjj| js4td| j tj| j tj| j d S )Nz%s is not lockedz%s is locked, but not by me) is_lockedr r r existsr r r r )r r r r release7 s zLinkLockFile.releasec C s t jj| jS )N)r r r! r )r r r r r ? s zLinkLockFile.is_lockedc C s( | j o&tjj| jo&tj| jjdkS )Nr )r r r r! r r r )r r r r i_am_lockingB s zLinkLockFile.i_am_lockingc C s t jj| jrt j| j d S )N)r r r! r r )r r r r
break_lockG s zLinkLockFile.break_lock)N) __name__
__module__ __qualname____doc__r r" r r# r$ r r r r r
s
&r
) Z
__future__r r r r r r r r r r
r r r r s PK ! >> lock = MkdirLockFile('somefile')
>>> lock = MkdirLockFile('somefile', threaded=False)
z%s.%s%sN)
r __init__ospathjoin lock_fileZhostnameZtnamepid unique_name)selfr Zthreadedtimeout r #/usr/lib/python3.6/mkdirlockfile.pyr s
zMkdirLockFile.__init__c C s |d k r |n| j }tj }|d k r2|dkr2||7 }|d kr@d}ntd|d }xytj| j W n tk
r tj d }|j t j
krtj j | j
rd S |d k rtj |kr|dkrtd| j ntd| j tj| ntd| j Y qPX t| j
dj d S qPW d S ) Nr g?
r z&Timeout waiting to acquire lock for %sz%s is already lockedzfailed to create %swb)r timemaxr
mkdirr OSErrorsysexc_infoerrnoZEEXISTr existsr r r
Zsleepr openclose)r r Zend_timewaiterrr r r acquire s2
zMkdirLockFile.acquirec C sP | j std| j n tjj| js4td| j tj| j tj| j d S )Nz%s is not lockedz%s is locked, but not by me)
is_lockedr r r
r r r unlinkrmdirr )r r r r releaseA s zMkdirLockFile.releasec C s t jj| jS )N)r
r r r )r r r r r& I s zMkdirLockFile.is_lockedc C s | j otjj| jS )N)r& r
r r r )r r r r i_am_lockingL s zMkdirLockFile.i_am_lockingc C sJ t jj| jrFx*t j| jD ]}t jt jj| j| q W t j| j d S )N)r
r r r listdirr' r r( )r namer r r
break_lockP s zMkdirLockFile.break_lock)TN)N)
__name__
__module__ __qualname____doc__r r% r) r& r* r- r r r r r s
&r )Z
__future__r r r r
r r r r r r r r
r r r r r s PK ! V V / __pycache__/sqlitelockfile.cpython-36.opt-1.pycnu [ 3
Pf @ sr d dl mZmZ d dlZd dlZye W n ek
r@ eZY nX ddlm Z m
Z
m Z m Z m
Z
G dd de ZdS ) )absolute_importdivisionN )LockBase NotLocked NotMyLock LockTimeout
AlreadyLockedc @ sP e Zd ZdZdZdddZdddZdd Zd
d Zd d
Z dd Z
dd Z dS )SQLiteLockFilez Demonstrate SQL-based locking.NTc
C s t j| ||| t| j| _t| j| _tjdkrdddl}|j \}}t j
| t j | ~~|t_ddl }|j
tj| _| jj }y|jd W n |jk
r Y n$X | jj ddl} | jt j tj dS )zu
>>> lock = SQLiteLockFile('somefile')
>>> lock = SQLiteLockFile('somefile', threaded=False)
Nr zGcreate table locks( lock_file varchar(32), unique_name varchar(32)))r __init__unicode lock_file unique_namer
testdbtempfileZmkstemposcloseunlinksqlite3Zconnect
connectioncursorexecuteZOperationalErrorcommitatexitregister)
selfpathZthreadedtimeoutr Z_fdr r cr r $/usr/lib/python3.6/sqlitelockfile.pyr s(
zSQLiteLockFile.__init__c C sH |d k r |n| j }tj }|d k r2|dkr2||7 }|d kr@d}n|dkrNd}n|d }| jj }x| j s|jd| j| jf | jj |jd| jf |j }t
|dkr|jd| jf | jj qd S n(|jd| jf |j }t
|dkrd S |d k r6tj |kr6|dkr(t d| j nt
d | j tj| qbW d S )
Nr g?
z;insert into locks (lock_file, unique_name) values (?, ?)z*select * from locks where unique_name = ?r z(delete from locks where unique_name = ?z&Timeout waiting to acquire lock for %sz%s is already locked)r timer r is_lockedr r
r r fetchalllenr r r Zsleep)r r Zend_timewaitr rowsr r r acquire5 sD
zSQLiteLockFile.acquirec C s\ | j std| j | j s4td| j| j f | jj }|j d| jf | jj
d S )Nz%s is not lockedz#%s is locked, but not by me (by %s)z(delete from locks where unique_name = ?) r# r r i_am_lockingr r _who_is_lockingr r r r )r r r r r releaset s
zSQLiteLockFile.releasec C s& | j j }|jd| jf |j d S )Nz2select unique_name from locks where lock_file = ?r )r r r r
Zfetchone)r r r r r r* s
z SQLiteLockFile._who_is_lockingc C s* | j j }|jd| jf |j }| S )Nz(select * from locks where lock_file = ?)r r r r
r$ )r r r' r r r r# s
zSQLiteLockFile.is_lockedc C s* | j j }|jd| j| jf |j S )Nz?select * from locks where lock_file = ? and unique_name = ?)r r r r
r r$ )r r r r r r) s
zSQLiteLockFile.i_am_lockingc C s( | j j }|jd| jf | j j d S )Nz&delete from locks where lock_file = ?)r r r r
r )r r r r r
break_lock s
zSQLiteLockFile.break_lock)TN)N) __name__
__module__ __qualname____doc__r r r( r+ r* r# r) r, r r r r r
s
"
? r
)Z
__future__r r r" r r NameErrorstr r r r r r r
r r r r s
PK ! ؚ ' __pycache__/linklockfile.cpython-36.pycnu [ 3
Pf\
@ sP d dl mZ d dlZd dlZddlmZmZmZmZm Z m
Z
G dd deZ dS ) )absolute_importN )LockBase
LockFailed NotLocked NotMyLock LockTimeout
AlreadyLockedc @ s: e Zd ZdZd
ddZdd Zdd Zd d
Zd d ZdS ) LinkLockFilezLock access to a file using atomic property of link(2).
>>> lock = LinkLockFile('somefile')
>>> lock = LinkLockFile('somefile', threaded=False)
Nc C s" yt | jdj W n" tk
r6 td| j Y nX |d k rD|n| j}tj }|d k rj|dkrj||7 }xytj| j| j W n t
k
r tj | jj }|dkrd S |d k rtj |krtj
| j |dkrtd| j ntd| j tj|d k r
|d p d Y qlX d S qlW d S ) Nwbzfailed to create %sr z&Timeout waiting to acquire lock for %sz%s is already locked
g?)open unique_namecloseIOErrorr timeouttimeoslink lock_fileOSErrorstatst_nlinkunlinkr pathr Zsleep)selfr Zend_timeZnlinks r "/usr/lib/python3.6/linklockfile.pyacquire s0
$zLinkLockFile.acquirec C sP | j std| j n tjj| js4td| j tj| j tj| j d S )Nz%s is not lockedz%s is locked, but not by me) is_lockedr r r existsr r r r )r r r r release7 s zLinkLockFile.releasec C s t jj| jS )N)r r r! r )r r r r r ? s zLinkLockFile.is_lockedc C s( | j o&tjj| jo&tj| jjdkS )Nr )r r r r! r r r )r r r r i_am_lockingB s zLinkLockFile.i_am_lockingc C s t jj| jrt j| j d S )N)r r r! r r )r r r r
break_lockG s zLinkLockFile.break_lock)N) __name__
__module__ __qualname____doc__r r" r r# r$ r r r r r
s
&r
) Z
__future__r r r r r r r r r r
r r r r s PK ! -cf& f& # __pycache__/__init__.cpython-36.pycnu [ 3
Pf$
@ s d Z ddlmZ ddlZddlZddlZddlZddlZeedsJej e_
eej dsbej j ej _
dddd d
d d d
dddddg
ZG dd deZG dd deZG dd deZG dd d eZG dd
d
eZG dd d eZG dd d eZG dd
d
eZG dd d eZG d d deZd d Zd d Z d!d Z d"d Z d(d#dZ eed$rjd%d&l m!Z" e"j#Z$nd%d'l m%Z& e&j'Z$e$Z(dS ))a
lockfile.py - Platform-independent advisory file locks.
Requires Python 2.5 unless you apply 2.4.diff
Locking is done on a per-thread basis instead of a per-process basis.
Usage:
>>> lock = LockFile('somefile')
>>> try:
... lock.acquire()
... except AlreadyLocked:
... print 'somefile', 'is locked already.'
... except LockFailed:
... print 'somefile', 'can\'t be locked.'
... else:
... print 'got lock'
got lock
>>> print lock.is_locked()
True
>>> lock.release()
>>> lock = LockFile('somefile')
>>> print lock.is_locked()
False
>>> with lock:
... print lock.is_locked()
True
>>> print lock.is_locked()
False
>>> lock = LockFile('somefile')
>>> # It is okay to lock twice from the same thread...
>>> with lock:
... lock.acquire()
...
>>> # Though no counter is kept, so you can't unlock multiple times...
>>> print lock.is_locked()
False
Exceptions:
Error - base class for other exceptions
LockError - base class for all locking exceptions
AlreadyLocked - Another thread or process already holds the lock
LockFailed - Lock failed for some other reason
UnlockError - base class for all unlocking exceptions
AlreadyUnlocked - File was not locked.
NotMyLock - File was locked but not by the current thread/process
)absolute_importNcurrent_threadget_nameError LockError LockTimeout
AlreadyLocked
LockFailed UnlockError NotLocked NotMyLock LinkFileLock
MkdirFileLockSQLiteFileLockLockBaselockedc @ s e Zd ZdZdS )r zw
Base class for other exceptions.
>>> try:
... raise Error
... except Exception:
... pass
N)__name__
__module__ __qualname____doc__ r r /usr/lib/python3.6/__init__.pyr J s c @ s e Zd ZdZdS )r z
Base class for error arising from attempts to acquire the lock.
>>> try:
... raise LockError
... except Error:
... pass
N)r r r r r r r r r V s c @ s e Zd ZdZdS )r zRaised when lock creation fails within a user-defined period of time.
>>> try:
... raise LockTimeout
... except LockError:
... pass
N)r r r r r r r r r b s c @ s e Zd ZdZdS )r zSome other thread/process is locking the file.
>>> try:
... raise AlreadyLocked
... except LockError:
... pass
N)r r r r r r r r r m s c @ s e Zd ZdZdS )r zLock file creation failed for some other reason.
>>> try:
... raise LockFailed
... except LockError:
... pass
N)r r r r r r r r r x s c @ s e Zd ZdZdS )r
z
Base class for errors arising from attempts to release the lock.
>>> try:
... raise UnlockError
... except Error:
... pass
N)r r r r r r r r r
s c @ s e Zd ZdZdS )r zRaised when an attempt is made to unlock an unlocked file.
>>> try:
... raise NotLocked
... except UnlockError:
... pass
N)r r r r r r r r r s c @ s e Zd ZdZdS )r zRaised when an attempt is made to unlock a file someone else locked.
>>> try:
... raise NotMyLock
... except UnlockError:
... pass
N)r r r r r r r r r s c @ s> e Zd Zdd ZdddZdd Zdd Zd
d Zd d
ZdS ) _SharedBasec C s
|| _ d S )N)path)selfr r r r __init__ s z_SharedBase.__init__Nc C s t ddS )a
Acquire the lock.
* If timeout is omitted (or None), wait forever trying to lock the
file.
* If timeout > 0, try to acquire the lock for that many seconds. If
the lock period expires and the file is still locked, raise
LockTimeout.
* If timeout <= 0, raise AlreadyLocked immediately if the file is
already locked.
zimplement in subclassN)NotImplemented)r timeoutr r r acquire s z_SharedBase.acquirec C s t ddS )zX
Release the lock.
If the file is not locked, raise NotLocked.
zimplement in subclassN)r )r r r r release s z_SharedBase.releasec C s | j | S )z*
Context manager support.
)r )r r r r __enter__ s z_SharedBase.__enter__c G s | j dS )z*
Context manager support.
N)r )r Z_excr r r __exit__ s z_SharedBase.__exit__c C s d| j j| jf S )Nz<%s: %r>) __class__r r )r r r r __repr__ s z_SharedBase.__repr__)N) r r r r r r r r! r# r r r r r s
r c sB e Zd ZdZd fdd Zdd Zdd Zd
d Zd d
Z Z S )r z.Base class for platform-specific lock classes.TNc s t t| j| tjj|d | _tj | _ tj
| _ |rbt j
}t|dt|}d|d@ | _nd| _tjj| j}tjj|d| j | j| j t| jf | _|| _dS )zi
>>> lock = LockBase('somefile')
>>> lock = LockBase('somefile', threaded=False)
z.lockidentz-%xl z %s%s.%s%sN)superr r osr abspathZ lock_filesocketZ gethostnameZhostnamegetpidpid threadingr getattrhashZtnamedirnamejoin unique_namer )r r threadedr tr$ r/ )r" r r r s
zLockBase.__init__c C s t ddS )z9
Tell whether or not the file is locked.
zimplement in subclassN)r )r r r r is_locked s zLockBase.is_lockedc C s t ddS )zA
Return True if this object is locking the file.
zimplement in subclassN)r )r r r r i_am_locking s zLockBase.i_am_lockingc C s t ddS )zN
Remove a lock. Useful if a locking thread failed to unlock.
zimplement in subclassN)r )r r r r
break_lock s zLockBase.break_lockc C s d| j j| j| jf S )Nz<%s: %r -- %r>)r" r r1 r )r r r r r# s zLockBase.__repr__)TN)
r r r r r r4 r5 r6 r#
__classcell__r r )r" r r s !c O sR t jd| tdd t|d ts.|dd }t|dkrH| rHd|d< | ||S )Nz1Import from %s module instead of lockfile package )
stacklevelr Tr2 )warningswarnDeprecationWarning
isinstancestrlen)clsmodargskwdsr r r
_fl_helper s
rE c O s ddl m} t|jdf| |S )zFactory function provided for backwards compatibility.
Do not use in new code. Instead, import LinkLockFile from the
lockfile.linklockfile module.
r: ) linklockfilezlockfile.linklockfile)r% rF rE LinkLockFile)rC rD rF r r r r
s
c O s ddl m} t|jdf| |S )zFactory function provided for backwards compatibility.
Do not use in new code. Instead, import MkdirLockFile from the
lockfile.mkdirlockfile module.
r: )
mkdirlockfilezlockfile.mkdirlockfile)r% rH rE
MkdirLockFile)rC rD rH r r r r % s
c O s ddl m} t|jdf| |S )zFactory function provided for backwards compatibility.
Do not use in new code. Instead, import SQLiteLockFile from the
lockfile.mkdirlockfile module.
r: )sqlitelockfilezlockfile.sqlitelockfile)r% rJ rE ZSQLiteLockFile)rC rD rJ r r r r 0 s
c s fdd}|S )a Decorator which enables locks for decorated function.
Arguments:
- path: path for lockfile.
- timeout (optional): Timeout for acquiring lock.
Usage:
@locked('/var/run/myname', timeout=0)
def myname(...):
...
c s t j fdd}|S )Nc
s. t d}|j z
| |S |j X d S )N)r )FileLockr r )rC kwargslock)funcr r r r wrapperH s
z&locked..decor..wrapper) functoolswraps)rN rO )r r )rN r decorG s zlocked..decorr )r r rR r )r r r r ; s
linkr: )rF )rH )N))r Z
__future__r rP r' r) r, r; hasattrZ
currentThreadr ZThreadZgetNamer __all__ Exceptionr r r r r r
r r objectr r rE r
r r r r% rF Z_llfrG ZLockFilerH Z_mlfrI rK r r r r 4 sF
-:
PK ! -cf& f& ) __pycache__/__init__.cpython-36.opt-1.pycnu [ 3
Pf$
@ s d Z ddlmZ ddlZddlZddlZddlZddlZeedsJej e_
eej dsbej j ej _
dddd d
d d d
dddddg
ZG dd deZG dd deZG dd deZG dd d eZG dd
d
eZG dd d eZG dd d eZG dd
d
eZG dd d eZG d d deZd d Zd d Z d!d Z d"d Z d(d#dZ eed$rjd%d&l m!Z" e"j#Z$nd%d'l m%Z& e&j'Z$e$Z(dS ))a
lockfile.py - Platform-independent advisory file locks.
Requires Python 2.5 unless you apply 2.4.diff
Locking is done on a per-thread basis instead of a per-process basis.
Usage:
>>> lock = LockFile('somefile')
>>> try:
... lock.acquire()
... except AlreadyLocked:
... print 'somefile', 'is locked already.'
... except LockFailed:
... print 'somefile', 'can\'t be locked.'
... else:
... print 'got lock'
got lock
>>> print lock.is_locked()
True
>>> lock.release()
>>> lock = LockFile('somefile')
>>> print lock.is_locked()
False
>>> with lock:
... print lock.is_locked()
True
>>> print lock.is_locked()
False
>>> lock = LockFile('somefile')
>>> # It is okay to lock twice from the same thread...
>>> with lock:
... lock.acquire()
...
>>> # Though no counter is kept, so you can't unlock multiple times...
>>> print lock.is_locked()
False
Exceptions:
Error - base class for other exceptions
LockError - base class for all locking exceptions
AlreadyLocked - Another thread or process already holds the lock
LockFailed - Lock failed for some other reason
UnlockError - base class for all unlocking exceptions
AlreadyUnlocked - File was not locked.
NotMyLock - File was locked but not by the current thread/process
)absolute_importNcurrent_threadget_nameError LockError LockTimeout
AlreadyLocked
LockFailed UnlockError NotLocked NotMyLock LinkFileLock
MkdirFileLockSQLiteFileLockLockBaselockedc @ s e Zd ZdZdS )r zw
Base class for other exceptions.
>>> try:
... raise Error
... except Exception:
... pass
N)__name__
__module__ __qualname____doc__ r r /usr/lib/python3.6/__init__.pyr J s c @ s e Zd ZdZdS )r z
Base class for error arising from attempts to acquire the lock.
>>> try:
... raise LockError
... except Error:
... pass
N)r r r r r r r r r V s c @ s e Zd ZdZdS )r zRaised when lock creation fails within a user-defined period of time.
>>> try:
... raise LockTimeout
... except LockError:
... pass
N)r r r r r r r r r b s c @ s e Zd ZdZdS )r zSome other thread/process is locking the file.
>>> try:
... raise AlreadyLocked
... except LockError:
... pass
N)r r r r r r r r r m s c @ s e Zd ZdZdS )r zLock file creation failed for some other reason.
>>> try:
... raise LockFailed
... except LockError:
... pass
N)r r r r r r r r r x s c @ s e Zd ZdZdS )r
z
Base class for errors arising from attempts to release the lock.
>>> try:
... raise UnlockError
... except Error:
... pass
N)r r r r r r r r r
s c @ s e Zd ZdZdS )r zRaised when an attempt is made to unlock an unlocked file.
>>> try:
... raise NotLocked
... except UnlockError:
... pass
N)r r r r r r r r r s c @ s e Zd ZdZdS )r zRaised when an attempt is made to unlock a file someone else locked.
>>> try:
... raise NotMyLock
... except UnlockError:
... pass
N)r r r r r r r r r s c @ s> e Zd Zdd ZdddZdd Zdd Zd
d Zd d
ZdS ) _SharedBasec C s
|| _ d S )N)path)selfr r r r __init__ s z_SharedBase.__init__Nc C s t ddS )a
Acquire the lock.
* If timeout is omitted (or None), wait forever trying to lock the
file.
* If timeout > 0, try to acquire the lock for that many seconds. If
the lock period expires and the file is still locked, raise
LockTimeout.
* If timeout <= 0, raise AlreadyLocked immediately if the file is
already locked.
zimplement in subclassN)NotImplemented)r timeoutr r r acquire s z_SharedBase.acquirec C s t ddS )zX
Release the lock.
If the file is not locked, raise NotLocked.
zimplement in subclassN)r )r r r r release s z_SharedBase.releasec C s | j | S )z*
Context manager support.
)r )r r r r __enter__ s z_SharedBase.__enter__c G s | j dS )z*
Context manager support.
N)r )r Z_excr r r __exit__ s z_SharedBase.__exit__c C s d| j j| jf S )Nz<%s: %r>) __class__r r )r r r r __repr__ s z_SharedBase.__repr__)N) r r r r r r r r! r# r r r r r s
r c sB e Zd ZdZd fdd Zdd Zdd Zd
d Zd d
Z Z S )r z.Base class for platform-specific lock classes.TNc s t t| j| tjj|d | _tj | _ tj
| _ |rbt j
}t|dt|}d|d@ | _nd| _tjj| j}tjj|d| j | j| j t| jf | _|| _dS )zi
>>> lock = LockBase('somefile')
>>> lock = LockBase('somefile', threaded=False)
z.lockidentz-%xl z %s%s.%s%sN)superr r osr abspathZ lock_filesocketZ gethostnameZhostnamegetpidpid threadingr getattrhashZtnamedirnamejoin unique_namer )r r threadedr tr$ r/ )r" r r r s
zLockBase.__init__c C s t ddS )z9
Tell whether or not the file is locked.
zimplement in subclassN)r )r r r r is_locked s zLockBase.is_lockedc C s t ddS )zA
Return True if this object is locking the file.
zimplement in subclassN)r )r r r r i_am_locking s zLockBase.i_am_lockingc C s t ddS )zN
Remove a lock. Useful if a locking thread failed to unlock.
zimplement in subclassN)r )r r r r
break_lock s zLockBase.break_lockc C s d| j j| j| jf S )Nz<%s: %r -- %r>)r" r r1 r )r r r r r# s zLockBase.__repr__)TN)
r r r r r r4 r5 r6 r#
__classcell__r r )r" r r s !c O sR t jd| tdd t|d ts.|dd }t|dkrH| rHd|d< | ||S )Nz1Import from %s module instead of lockfile package )
stacklevelr Tr2 )warningswarnDeprecationWarning
isinstancestrlen)clsmodargskwdsr r r
_fl_helper s
rE c O s ddl m} t|jdf| |S )zFactory function provided for backwards compatibility.
Do not use in new code. Instead, import LinkLockFile from the
lockfile.linklockfile module.
r: ) linklockfilezlockfile.linklockfile)r% rF rE LinkLockFile)rC rD rF r r r r
s
c O s ddl m} t|jdf| |S )zFactory function provided for backwards compatibility.
Do not use in new code. Instead, import MkdirLockFile from the
lockfile.mkdirlockfile module.
r: )
mkdirlockfilezlockfile.mkdirlockfile)r% rH rE
MkdirLockFile)rC rD rH r r r r % s
c O s ddl m} t|jdf| |S )zFactory function provided for backwards compatibility.
Do not use in new code. Instead, import SQLiteLockFile from the
lockfile.mkdirlockfile module.
r: )sqlitelockfilezlockfile.sqlitelockfile)r% rJ rE ZSQLiteLockFile)rC rD rJ r r r r 0 s
c s fdd}|S )a Decorator which enables locks for decorated function.
Arguments:
- path: path for lockfile.
- timeout (optional): Timeout for acquiring lock.
Usage:
@locked('/var/run/myname', timeout=0)
def myname(...):
...
c s t j fdd}|S )Nc
s. t d}|j z
| |S |j X d S )N)r )FileLockr r )rC kwargslock)funcr r r r wrapperH s
z&locked..decor..wrapper) functoolswraps)rN rO )r r )rN r decorG s zlocked..decorr )r r rR r )r r r r ; s
linkr: )rF )rH )N))r Z
__future__r rP r' r) r, r; hasattrZ
currentThreadr ZThreadZgetNamer __all__ Exceptionr r r r r r
r r objectr r rE r
r r r r% rF Z_llfrG ZLockFilerH Z_mlfrI rK r r r r 4 sF
-:
PK ! 9 README.mdnu [ # lockfile
A very polite lock file utility, which endeavors to not litter, and to
wait patiently for others.
## Usage
```javascript
var lockFile = require('lockfile')
// opts is optional, and defaults to {}
lockFile.lock('some-file.lock', opts, function (er) {
// if the er happens, then it failed to acquire a lock.
// if there was not an error, then the file was created,
// and won't be deleted until we unlock it.
// do my stuff, free of interruptions
// then, some time later, do:
lockFile.unlock('some-file.lock', function (er) {
// er means that an error happened, and is probably bad.
})
})
```
## Methods
Sync methods return the value/throw the error, others don't. Standard
node fs stuff.
All known locks are removed when the process exits. Of course, it's
possible for certain types of failures to cause this to fail, but a best
effort is made to not be a litterbug.
### lockFile.lock(path, [opts], cb)
Acquire a file lock on the specified path
### lockFile.lockSync(path, [opts])
Acquire a file lock on the specified path
### lockFile.unlock(path, cb)
Close and unlink the lockfile.
### lockFile.unlockSync(path)
Close and unlink the lockfile.
### lockFile.check(path, [opts], cb)
Check if the lockfile is locked and not stale.
Callback is called with `cb(error, isLocked)`.
### lockFile.checkSync(path, [opts])
Check if the lockfile is locked and not stale.
Returns boolean.
## Options
### opts.wait
A number of milliseconds to wait for locks to expire before giving up.
Only used by lockFile.lock. Poll for `opts.wait` ms. If the lock is
not cleared by the time the wait expires, then it returns with the
original error.
### opts.pollPeriod
When using `opts.wait`, this is the period in ms in which it polls to
check if the lock has expired. Defaults to `100`.
### opts.stale
A number of milliseconds before locks are considered to have expired.
### opts.retries
Used by lock and lockSync. Retry `n` number of times before giving up.
### opts.retryWait
Used by lock. Wait `n` milliseconds before retrying.
PK ! O gen-changelog.shnu [ #!/bin/bash
(
echo '# Changes'
echo ''
git log --first-parent --pretty=format:'%s' \
| grep -v '^update changelog' \
| perl -p -e 's/^((v?[0-9]+\.?)+)$/\n## \1\n/g' \
| perl -p -e 's/^([^#\s].*)$/* \1/g'
)> CHANGELOG.md
PK ! gD lockfile.jsnu [ var fs = require('fs')
var wx = 'wx'
if (process.version.match(/^v0\.[0-6]/)) {
var c = require('constants')
wx = c.O_TRUNC | c.O_CREAT | c.O_WRONLY | c.O_EXCL
}
var os = require('os')
exports.filetime = 'ctime'
if (os.platform() == "win32") {
exports.filetime = 'mtime'
}
var debug
var util = require('util')
if (util.debuglog)
debug = util.debuglog('LOCKFILE')
else if (/\blockfile\b/i.test(process.env.NODE_DEBUG))
debug = function() {
var msg = util.format.apply(util, arguments)
console.error('LOCKFILE %d %s', process.pid, msg)
}
else
debug = function() {}
var locks = {}
function hasOwnProperty (obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop)
}
var onExit = require('signal-exit')
onExit(function () {
debug('exit listener')
// cleanup
Object.keys(locks).forEach(exports.unlockSync)
})
// XXX https://github.com/joyent/node/issues/3555
// Remove when node 0.8 is deprecated.
if (/^v0\.[0-8]\./.test(process.version)) {
debug('uncaughtException, version = %s', process.version)
process.on('uncaughtException', function H (er) {
debug('uncaughtException')
var l = process.listeners('uncaughtException').filter(function (h) {
return h !== H
})
if (!l.length) {
// cleanup
try { Object.keys(locks).forEach(exports.unlockSync) } catch (e) {}
process.removeListener('uncaughtException', H)
throw er
}
})
}
exports.unlock = function (path, cb) {
debug('unlock', path)
// best-effort. unlocking an already-unlocked lock is a noop
delete locks[path]
fs.unlink(path, function (unlinkEr) { cb && cb() })
}
exports.unlockSync = function (path) {
debug('unlockSync', path)
// best-effort. unlocking an already-unlocked lock is a noop
try { fs.unlinkSync(path) } catch (er) {}
delete locks[path]
}
// if the file can be opened in readonly mode, then it's there.
// if the error is something other than ENOENT, then it's not.
exports.check = function (path, opts, cb) {
if (typeof opts === 'function') cb = opts, opts = {}
debug('check', path, opts)
fs.open(path, 'r', function (er, fd) {
if (er) {
if (er.code !== 'ENOENT') return cb(er)
return cb(null, false)
}
if (!opts.stale) {
return fs.close(fd, function (er) {
return cb(er, true)
})
}
fs.fstat(fd, function (er, st) {
if (er) return fs.close(fd, function (er2) {
return cb(er)
})
fs.close(fd, function (er) {
var age = Date.now() - st[exports.filetime].getTime()
return cb(er, age <= opts.stale)
})
})
})
}
exports.checkSync = function (path, opts) {
opts = opts || {}
debug('checkSync', path, opts)
if (opts.wait) {
throw new Error('opts.wait not supported sync for obvious reasons')
}
try {
var fd = fs.openSync(path, 'r')
} catch (er) {
if (er.code !== 'ENOENT') throw er
return false
}
if (!opts.stale) {
try { fs.closeSync(fd) } catch (er) {}
return true
}
// file exists. however, might be stale
if (opts.stale) {
try {
var st = fs.fstatSync(fd)
} finally {
fs.closeSync(fd)
}
var age = Date.now() - st[exports.filetime].getTime()
return (age <= opts.stale)
}
}
var req = 1
exports.lock = function (path, opts, cb) {
if (typeof opts === 'function') cb = opts, opts = {}
opts.req = opts.req || req++
debug('lock', path, opts)
opts.start = opts.start || Date.now()
if (typeof opts.retries === 'number' && opts.retries > 0) {
debug('has retries', opts.retries)
var retries = opts.retries
opts.retries = 0
cb = (function (orig) { return function cb (er, fd) {
debug('retry-mutated callback')
retries -= 1
if (!er || retries < 0) return orig(er, fd)
debug('lock retry', path, opts)
if (opts.retryWait) setTimeout(retry, opts.retryWait)
else retry()
function retry () {
opts.start = Date.now()
debug('retrying', opts.start)
exports.lock(path, opts, cb)
}
}})(cb)
}
// try to engage the lock.
// if this succeeds, then we're in business.
fs.open(path, wx, function (er, fd) {
if (!er) {
debug('locked', path, fd)
locks[path] = fd
return fs.close(fd, function () {
return cb()
})
}
debug('failed to acquire lock', er)
// something other than "currently locked"
// maybe eperm or something.
if (er.code !== 'EEXIST') {
debug('not EEXIST error', er)
return cb(er)
}
// someone's got this one. see if it's valid.
if (!opts.stale) return notStale(er, path, opts, cb)
return maybeStale(er, path, opts, false, cb)
})
debug('lock return')
}
// Staleness checking algorithm
// 1. acquire $lock, fail
// 2. stat $lock, find that it is stale
// 3. acquire $lock.STALE
// 4. stat $lock, assert that it is still stale
// 5. unlink $lock
// 6. link $lock.STALE $lock
// 7. unlink $lock.STALE
// On any failure, clean up whatever we've done, and raise the error.
function maybeStale (originalEr, path, opts, hasStaleLock, cb) {
fs.stat(path, function (statEr, st) {
if (statEr) {
if (statEr.code === 'ENOENT') {
// expired already!
opts.stale = false
debug('lock stale enoent retry', path, opts)
exports.lock(path, opts, cb)
return
}
return cb(statEr)
}
var age = Date.now() - st[exports.filetime].getTime()
if (age <= opts.stale) return notStale(originalEr, path, opts, cb)
debug('lock stale', path, opts)
if (hasStaleLock) {
exports.unlock(path, function (er) {
if (er) return cb(er)
debug('lock stale retry', path, opts)
fs.link(path + '.STALE', path, function (er) {
fs.unlink(path + '.STALE', function () {
// best effort. if the unlink fails, oh well.
cb(er)
})
})
})
} else {
debug('acquire .STALE file lock', opts)
exports.lock(path + '.STALE', opts, function (er) {
if (er) return cb(er)
maybeStale(originalEr, path, opts, true, cb)
})
}
})
}
function notStale (er, path, opts, cb) {
debug('notStale', path, opts)
// if we can't wait, then just call it a failure
if (typeof opts.wait !== 'number' || opts.wait <= 0) {
debug('notStale, wait is not a number')
return cb(er)
}
// poll for some ms for the lock to clear
var now = Date.now()
var start = opts.start || now
var end = start + opts.wait
if (end <= now)
return cb(er)
debug('now=%d, wait until %d (delta=%d)', start, end, end-start)
var wait = Math.min(end - start, opts.pollPeriod || 100)
var timer = setTimeout(poll, wait)
function poll () {
debug('notStale, polling', path, opts)
exports.lock(path, opts, cb)
}
}
exports.lockSync = function (path, opts) {
opts = opts || {}
opts.req = opts.req || req++
debug('lockSync', path, opts)
if (opts.wait || opts.retryWait) {
throw new Error('opts.wait not supported sync for obvious reasons')
}
try {
var fd = fs.openSync(path, wx)
locks[path] = fd
try { fs.closeSync(fd) } catch (er) {}
debug('locked sync!', path, fd)
return
} catch (er) {
if (er.code !== 'EEXIST') return retryThrow(path, opts, er)
if (opts.stale) {
var st = fs.statSync(path)
var ct = st[exports.filetime].getTime()
if (!(ct % 1000) && (opts.stale % 1000)) {
// probably don't have subsecond resolution.
// round up the staleness indicator.
// Yes, this will be wrong 1/1000 times on platforms
// with subsecond stat precision, but that's acceptable
// in exchange for not mistakenly removing locks on
// most other systems.
opts.stale = 1000 * Math.ceil(opts.stale / 1000)
}
var age = Date.now() - ct
if (age > opts.stale) {
debug('lockSync stale', path, opts, age)
exports.unlockSync(path)
return exports.lockSync(path, opts)
}
}
// failed to lock!
debug('failed to lock', path, opts, er)
return retryThrow(path, opts, er)
}
}
function retryThrow (path, opts, er) {
if (typeof opts.retries === 'number' && opts.retries > 0) {
var newRT = opts.retries - 1
debug('retryThrow', path, opts, newRT)
opts.retries = newRT
return exports.lockSync(path, opts)
}
throw er
}
PK ! ]A
sockets.mdnu [ to ACQUIRE(lockname)
- create server, listen on lockname
- if enotsock, WATCH(lockname)
- if eaddrinuse,
- CONNECT(lockname)
- unref server
- lock has been acquired via server
! on connection, place sockets in queue
to RELEASE(lockname)
- if acquired via connection
- disconnect
- if acquired via server
- send "OK" to front-most connection
- when connection disconnects, RELEASE(lockname)
- if acquired via filename
- unlink file
to CONNECT(lockname)
- net.connect(lockname)
- if enoent or socket termination, ACQUIRE(lockname)
- when server says "OK",
- lock has been acquired via connection
to WATCH(lockname)
- fs.watch(lockname)
- on change, ACQUIRE(lockname)
PK ! ~ ~ .travis.ymlnu [ language: node_js
sudo: false
node_js:
- 8
- 6
- 4
notifications:
email: false
cache:
directories:
- $HOME/.npm
PK ! aGW LICENSEnu [ The ISC License
Copyright (c) Isaac Z. Schlueter and Contributors
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
PK ! 5! ! CHANGELOG.mdnu [ # Changes
## 1.0.4
* test parallel
* upgrade tap
* upgrade node versions in travis.yml
* Use signal-exit package to detect exit instead of process.on('exit')
* added some debugging lines
## v1.0.3
* handle the case where callback is not passed by user
## v1.0.2
* git ignore coverage and node_modules
* update tap to v7
* build a changelog
* package: fix repository link
* pass tests on 0.8
* before_script needs to be before_install
* tap 1.2.0 and travis
## v1.0.1
* isc license
* updated README.md
## v1.0.0
* Simulate staleness instead of waiting excessively
* whitespace
* manage 'retries' so it does not clash with 'wait' polling
* manage 'wait' timer properly
* Get rid of the excessive Object.create opts shadowing stuff
* failing test for the time taken for retries + wait options
* doc: add pollPeriod, correct opts.wait
* Fixed #6: polling period should be configurable
## v0.4.3
* Implement race-resistant stale lock detection
* set req id to 1 to start out
## v0.4.2
* stale option fix for windows file tunneling
## v0.4.1
* Fix version parsing
## v0.4.0
* Don't keep lockfiles open
## v0.3.4
* retry more aggressively
## v0.3.3
* Add debugging function
## v0.3.2
* remove console.error
## v0.3.1
* Support lack of subsecond fs precision
* Fix error closure overwriting in notStale
## v0.3.0
* Use polling instead of watchers
* Add more overhead buffer to contention test
## v0.2.2
* Fix wait calculation
* fixup
* Style: prefer early return to giant if/else
* unlock: Close before unlinking
* Don't get tripped up by locks named 'hasOwnProperty'
* test: Pathological extreme lock contention
* refactor license
## 0.2.1
* Handle race conditions more thoroughly
## 0.2.0
* Rename to 'lockfile'
## 0.0.2
* Add retries
* bsd
## 0.0.1
* tests
* package.json
* the code
* first
PK ! hb b speedtest.jsnu [ const path = require('path');
const async = require('async');
const lf = require('lockfile');
const fs = require('fs');
const n = +process.argv[3] || 300;
const a = Array.apply(null, {length: n}).map(function(_, i) {
return i
})
const file = path.resolve(__dirname, 'speed-test.lock');
try{
fs.unlinkSync(file);
}
catch(e){}
/// NOTE: this should run in about 30ms on a SSD Ubuntu 16.04, that is fast, because we are locking/unlocking 300 locks
/// *HOWEVER* if we change async.eachSeries to async.each, lockfile will barf immediately, and I can't get lockfile
/// to not barf, using any of the options {} available to lockfile#lock.
const parallel = process.argv[2] === 'parallel';
var fn, msg;
if(parallel){
msg = 'parallel';
fn = async.each;
}
else{
msg = 'series';
fn = async.eachSeries;
}
const start = Date.now();
console.log(' => locking/unlocking ' + a.length + ' times, in ' + msg);
fn(a, function (val, cb) {
console.log('try %d', val)
lf.lock(file, { retries: n * 3 }, function (err) {
if (err) {
cb(err);
}
else {
console.log('complete %d', val)
lf.unlock(file, cb);
}
});
}, function complete(err) {
if (err) {
throw err;
}
console.log(' => Time required for lockfile => ', Date.now() - start, 'ms');
process.exit(0);
});
PK ! ֭B package.jsonnu [ {
"_args": [
[
"lockfile@1.0.4",
"/Users/rebecca/code/npm"
]
],
"_from": "lockfile@1.0.4",
"_id": "lockfile@1.0.4",
"_inBundle": false,
"_integrity": "sha512-cvbTwETRfsFh4nHsL1eGWapU1XFi5Ot9E85sWAwia7Y7EgB7vfqcZhTKZ+l7hCGxSPoushMv5GKhT5PdLv03WA==",
"_location": "/lockfile",
"_phantomChildren": {},
"_requested": {
"type": "version",
"registry": true,
"raw": "lockfile@1.0.4",
"name": "lockfile",
"escapedName": "lockfile",
"rawSpec": "1.0.4",
"saveSpec": null,
"fetchSpec": "1.0.4"
},
"_requiredBy": [
"/"
],
"_resolved": "https://registry.npmjs.org/lockfile/-/lockfile-1.0.4.tgz",
"_spec": "1.0.4",
"_where": "/Users/rebecca/code/npm",
"author": {
"name": "Isaac Z. Schlueter",
"email": "i@izs.me",
"url": "http://blog.izs.me/"
},
"bugs": {
"url": "https://github.com/npm/lockfile/issues"
},
"dependencies": {
"signal-exit": "^3.0.2"
},
"description": "A very polite lock file utility, which endeavors to not litter, and to wait patiently for others.",
"devDependencies": {
"tap": "^11.1.3",
"touch": "0"
},
"directories": {
"test": "test"
},
"homepage": "https://github.com/npm/lockfile#readme",
"keywords": [
"lockfile",
"lock",
"file",
"fs",
"O_EXCL"
],
"license": "ISC",
"main": "lockfile.js",
"name": "lockfile",
"repository": {
"type": "git",
"url": "git+https://github.com/npm/lockfile.git"
},
"scripts": {
"changelog": "bash gen-changelog.sh",
"postversion": "npm run changelog && git add CHANGELOG.md && git commit -m 'update changelog - '${npm_package_version}",
"test": "tap test/*.js --cov -J"
},
"version": "1.0.4"
}
PK ! k tokenizer.rbnu [ # frozen_string_literal: true
require 'rubygems/request_set/lockfile/parser'
class Gem::RequestSet::Lockfile::Tokenizer
Token = Struct.new :type, :value, :column, :line
EOF = Token.new :EOF
def self.from_file file
new File.read(file), file
end
def initialize input, filename = nil, line = 0, pos = 0
@line = line
@line_pos = pos
@tokens = []
@filename = filename
tokenize input
end
def make_parser set, platforms
Gem::RequestSet::Lockfile::Parser.new self, set, platforms, @filename
end
def to_a
@tokens.map { |token| [token.type, token.value, token.column, token.line] }
end
def skip type
@tokens.shift while not @tokens.empty? and peek.type == type
end
##
# Calculates the column (by byte) and the line of the current token based on
# +byte_offset+.
def token_pos byte_offset # :nodoc:
[byte_offset - @line_pos, @line]
end
def empty?
@tokens.empty?
end
def unshift token
@tokens.unshift token
end
def next_token
@tokens.shift
end
alias :shift :next_token
def peek
@tokens.first || EOF
end
private
def tokenize input
require 'strscan'
s = StringScanner.new input
until s.eos? do
pos = s.pos
pos = s.pos if leading_whitespace = s.scan(/ +/)
if s.scan(/[<|=>]{7}/) then
message = "your #{@filename} contains merge conflict markers"
column, line = token_pos pos
raise Gem::RequestSet::Lockfile::ParseError.new message, column, line, @filename
end
@tokens <<
case
when s.scan(/\r?\n/) then
token = Token.new(:newline, nil, *token_pos(pos))
@line_pos = s.pos
@line += 1
token
when s.scan(/[A-Z]+/) then
if leading_whitespace then
text = s.matched
text += s.scan(/[^\s)]*/).to_s # in case of no match
Token.new(:text, text, *token_pos(pos))
else
Token.new(:section, s.matched, *token_pos(pos))
end
when s.scan(/([a-z]+):\s/) then
s.pos -= 1 # rewind for possible newline
Token.new(:entry, s[1], *token_pos(pos))
when s.scan(/\(/) then
Token.new(:l_paren, nil, *token_pos(pos))
when s.scan(/\)/) then
Token.new(:r_paren, nil, *token_pos(pos))
when s.scan(/<=|>=|=|~>|<|>|!=/) then
Token.new(:requirement, s.matched, *token_pos(pos))
when s.scan(/,/) then
Token.new(:comma, nil, *token_pos(pos))
when s.scan(/!/) then
Token.new(:bang, nil, *token_pos(pos))
when s.scan(/[^\s),!]*/) then
Token.new(:text, s.matched, *token_pos(pos))
else
raise "BUG: can't create token for: #{s.string[s.pos..-1].inspect}"
end
end
@tokens
end
end
PK ! 8㜕 parser.rbnu [ # frozen_string_literal: true
class Gem::RequestSet::Lockfile::Parser
###
# Parses lockfiles
def initialize tokenizer, set, platforms, filename = nil
@tokens = tokenizer
@filename = filename
@set = set
@platforms = platforms
end
def parse
until @tokens.empty? do
token = get
case token.type
when :section then
@tokens.skip :newline
case token.value
when 'DEPENDENCIES' then
parse_DEPENDENCIES
when 'GIT' then
parse_GIT
when 'GEM' then
parse_GEM
when 'PATH' then
parse_PATH
when 'PLATFORMS' then
parse_PLATFORMS
else
token = get until @tokens.empty? or peek.first == :section
end
else
raise "BUG: unhandled token #{token.type} (#{token.value.inspect}) at line #{token.line} column #{token.column}"
end
end
end
##
# Gets the next token for a Lockfile
def get expected_types = nil, expected_value = nil # :nodoc:
token = @tokens.shift
if expected_types and not Array(expected_types).include? token.type then
unget token
message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " +
"expected #{expected_types.inspect}"
raise Gem::RequestSet::Lockfile::ParseError.new message, token.column, token.line, @filename
end
if expected_value and expected_value != token.value then
unget token
message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " +
"expected [#{expected_types.inspect}, " +
"#{expected_value.inspect}]"
raise Gem::RequestSet::Lockfile::ParseError.new message, token.column, token.line, @filename
end
token
end
def parse_DEPENDENCIES # :nodoc:
while not @tokens.empty? and :text == peek.type do
token = get :text
requirements = []
case peek[0]
when :bang then
get :bang
requirements << pinned_requirement(token.value)
when :l_paren then
get :l_paren
loop do
op = get(:requirement).value
version = get(:text).value
requirements << "#{op} #{version}"
break unless peek.type == :comma
get :comma
end
get :r_paren
if peek[0] == :bang then
requirements.clear
requirements << pinned_requirement(token.value)
get :bang
end
end
@set.gem token.value, *requirements
skip :newline
end
end
def parse_GEM # :nodoc:
sources = []
while [:entry, 'remote'] == peek.first(2) do
get :entry, 'remote'
data = get(:text).value
skip :newline
sources << Gem::Source.new(data)
end
sources << Gem::Source.new(Gem::DEFAULT_HOST) if sources.empty?
get :entry, 'specs'
skip :newline
set = Gem::Resolver::LockSet.new sources
last_specs = nil
while not @tokens.empty? and :text == peek.type do
token = get :text
name = token.value
column = token.column
case peek[0]
when :newline then
last_specs.each do |spec|
spec.add_dependency Gem::Dependency.new name if column == 6
end
when :l_paren then
get :l_paren
token = get [:text, :requirement]
type = token.type
data = token.value
if type == :text and column == 4 then
version, platform = data.split '-', 2
platform =
platform ? Gem::Platform.new(platform) : Gem::Platform::RUBY
last_specs = set.add name, version, platform
else
dependency = parse_dependency name, data
last_specs.each do |spec|
spec.add_dependency dependency
end
end
get :r_paren
else
raise "BUG: unknown token #{peek}"
end
skip :newline
end
@set.sets << set
end
def parse_GIT # :nodoc:
get :entry, 'remote'
repository = get(:text).value
skip :newline
get :entry, 'revision'
revision = get(:text).value
skip :newline
type = peek.type
value = peek.value
if type == :entry and %w[branch ref tag].include? value then
get
get :text
skip :newline
end
get :entry, 'specs'
skip :newline
set = Gem::Resolver::GitSet.new
set.root_dir = @set.install_dir
last_spec = nil
while not @tokens.empty? and :text == peek.type do
token = get :text
name = token.value
column = token.column
case peek[0]
when :newline then
last_spec.add_dependency Gem::Dependency.new name if column == 6
when :l_paren then
get :l_paren
token = get [:text, :requirement]
type = token.type
data = token.value
if type == :text and column == 4 then
last_spec = set.add_git_spec name, data, repository, revision, true
else
dependency = parse_dependency name, data
last_spec.add_dependency dependency
end
get :r_paren
else
raise "BUG: unknown token #{peek}"
end
skip :newline
end
@set.sets << set
end
def parse_PATH # :nodoc:
get :entry, 'remote'
directory = get(:text).value
skip :newline
get :entry, 'specs'
skip :newline
set = Gem::Resolver::VendorSet.new
last_spec = nil
while not @tokens.empty? and :text == peek.first do
token = get :text
name = token.value
column = token.column
case peek[0]
when :newline then
last_spec.add_dependency Gem::Dependency.new name if column == 6
when :l_paren then
get :l_paren
token = get [:text, :requirement]
type = token.type
data = token.value
if type == :text and column == 4 then
last_spec = set.add_vendor_gem name, directory
else
dependency = parse_dependency name, data
last_spec.dependencies << dependency
end
get :r_paren
else
raise "BUG: unknown token #{peek}"
end
skip :newline
end
@set.sets << set
end
def parse_PLATFORMS # :nodoc:
while not @tokens.empty? and :text == peek.first do
name = get(:text).value
@platforms << name
skip :newline
end
end
##
# Parses the requirements following the dependency +name+ and the +op+ for
# the first token of the requirements and returns a Gem::Dependency object.
def parse_dependency name, op # :nodoc:
return Gem::Dependency.new name, op unless peek[0] == :text
version = get(:text).value
requirements = ["#{op} #{version}"]
while peek.type == :comma do
get :comma
op = get(:requirement).value
version = get(:text).value
requirements << "#{op} #{version}"
end
Gem::Dependency.new name, requirements
end
private
def skip type # :nodoc:
@tokens.skip type
end
##
# Peeks at the next token for Lockfile
def peek # :nodoc:
@tokens.peek
end
if [].respond_to? :flat_map
def pinned_requirement name # :nodoc:
requirement = Gem::Dependency.new name
specification = @set.sets.flat_map { |set|
set.find_all(requirement)
}.compact.first
specification && specification.version
end
else # FIXME: remove when 1.8 is dropped
def pinned_requirement name # :nodoc:
requirement = Gem::Dependency.new name
specification = @set.sets.map { |set|
set.find_all(requirement)
}.flatten(1).compact.first
specification && specification.version
end
end
##
# Ungets the last token retrieved by #get
def unget token # :nodoc:
@tokens.unshift token
end
end
PK ! #$ $ __init__.pynu [ PK ! Ǟ+P/ P/ $ __init__.pyonu [ PK ! !&~ bT mkdirlockfile.pynu [ PK ! | ` pidlockfile.pycnu [ PK ! iY] ] x linklockfile.pyonu [ PK ! _] symlinklockfile.pycnu [ PK ! _] symlinklockfile.pyonu [ PK ! 6$hb
b
C mkdirlockfile.pyonu [ PK ! 6$hb
b
mkdirlockfile.pycnu [ PK ! g}Ha_ _ sqlitelockfile.pyonu [ PK ! # 8
8
* symlinklockfile.pynu [ PK !