Python: mô-đun để tạo lockfile dựa trên PID?

Question

Tôi đang viết một tập lệnh Python có thể hoặc không thể (tùy thuộc vào một loạt các thứ) chạy trong một thời gian dài, và tôi muốn đảm bảo rằng nhiều phiên bản (bắt đầu qua cron) không thực hiện từng bước những ngón chân khác. Cách hợp lý để làm điều này có vẻ là một lockfile dựa trên PID… Nhưng tôi không muốn tái phát minh ra bánh xe nếu đã có mã để làm điều này.

Vì vậy, có một mô-đun Python nào ở đó sẽ quản lý chi tiết của một tệp khóa dựa trên PID không?

Answer 1

Nếu bạn có thể sử dụng GPLv2, Mercurial có một mô-đun cho rằng:

http://bitbucket.org/mirror/mercurial/src/tip/mercurial/lock.py

Ví dụ sử dụng:

from mercurial import error, lock 

try: 
    l = lock.lock("/path/to/lock", timeout=600) # wait at most 10 minutes 
    # do something 
except error.LockHeld: 
    # couldn't take the lock 
else: 
    l.release() 

Answer 2

Điều này có thể trợ giúp cho bạn: lockfile

Answer 3

tôi tin rằng bạn sẽ tìm thấy thông tin cần thiết here. Trang được đề cập là một gói để xây dựng các trình tiện ích trong python: quá trình này liên quan đến việc tạo một tệp khóa PID.

Answer 4

Có một số recipe on ActiveState on creating lockfiles.

Để tạo tên tệp, bạn có thể sử dụng os.getpid() để lấy PID.

Answer 5

tôi đã khá hài lòng với tất cả những người, vì vậy tôi đã viết này:

class Pidfile(): 
    def __init__(self, path, log=sys.stdout.write, warn=sys.stderr.write): 
     self.pidfile = path 
     self.log = log 
     self.warn = warn 

    def __enter__(self): 
     try: 
      self.pidfd = os.open(self.pidfile, os.O_CREAT|os.O_WRONLY|os.O_EXCL) 
      self.log('locked pidfile %s' % self.pidfile) 
     except OSError as e: 
      if e.errno == errno.EEXIST: 
       pid = self._check() 
       if pid: 
        self.pidfd = None 
        raise ProcessRunningException('process already running in %s as pid %s' % (self.pidfile, pid)); 
       else: 
        os.remove(self.pidfile) 
        self.warn('removed staled lockfile %s' % (self.pidfile)) 
        self.pidfd = os.open(self.pidfile, os.O_CREAT|os.O_WRONLY|os.O_EXCL) 
      else: 
       raise 

     os.write(self.pidfd, str(os.getpid())) 
     os.close(self.pidfd) 
     return self 

    def __exit__(self, t, e, tb): 
     # return false to raise, true to pass 
     if t is None: 
      # normal condition, no exception 
      self._remove() 
      return True 
     elif t is PidfileProcessRunningException: 
      # do not remove the other process lockfile 
      return False 
     else: 
      # other exception 
      if self.pidfd: 
       # this was our lockfile, removing 
       self._remove() 
      return False 

    def _remove(self): 
     self.log('removed pidfile %s' % self.pidfile) 
     os.remove(self.pidfile) 

    def _check(self): 
     """check if a process is still running 

the process id is expected to be in pidfile, which should exist. 

if it is still running, returns the pid, if not, return False.""" 
     with open(self.pidfile, 'r') as f: 
      try: 
       pidstr = f.read() 
       pid = int(pidstr) 
      except ValueError: 
       # not an integer 
       self.log("not an integer: %s" % pidstr) 
       return False 
      try: 
       os.kill(pid, 0) 
      except OSError: 
       self.log("can't deliver signal to %s" % pid) 
       return False 
      else: 
       return pid 

class ProcessRunningException(BaseException): 
    pass 

sẽ được sử dụng một cái gì đó như thế này:

try: 
    with Pidfile(args.pidfile): 
     process(args) 
except ProcessRunningException: 
    print "the pid file is in use, oops." 

Answer 6

Tôi biết đây là một chủ đề cũ, nhưng Tôi cũng đã tạo một khóa đơn giản chỉ dựa trên thư viện gốc python:

import fcntl 
import errno 


class FileLock: 
    def __init__(self, filename=None): 
     self.filename = os.path.expanduser('~') + '/LOCK_FILE' if filename is None else filename 
     self.lock_file = open(self.filename, 'w+') 

    def unlock(self): 
     fcntl.flock(self.lock_file, fcntl.LOCK_UN) 

    def lock(self, maximum_wait=300): 
     waited = 0 
     while True: 
      try: 
       fcntl.flock(self.lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB) 
       return True 
      except IOError as e: 
       if e.errno != errno.EAGAIN: 
        raise e 
       else: 
        time.sleep(1) 
        waited += 1 
        if waited >= maximum_wait: 
         return False