def lock_cleanup_slave(lock_dir, lock_id, pidfile):
os.closerange(0, resource.RLIMIT_NOFILE)
pid = os.fork()
if pid == 0:
l = Lock(lock_dir, lock_id)
l.acquire()
with open(pidfile, "w") as f:
f.write(str(os.getpid()) + "\n")
while True:
time.sleep(1)
else:
sys.exit(0)
def test_lock_cleanup(self):
l = Lock(self.dir, "id1")
pidfile = os.path.join(self.dir, "cleanup.pid")
subprocess.check_call([sys.executable, __file__, "--slave", self.dir, "id1", pidfile], shell=False)
while True:
logger.debug("Checking for pidfile %s" % pidfile)
if os.path.exists(pidfile):
with open(pidfile, "r") as f:
d = f.read()
if d.endswith("\n"):
pid = int(d.rstrip())
break
time.sleep(1)
os.kill(pid, 9)
logger.debug("Attempting to acquire lock %s requiring cleanup of process %d" % (l.path, pid))
l.acquire() # can only get after slave process exits
def lock_getter1(lock_dir, lock_id, qs2m, qm2s):
l = Lock(lock_dir, lock_id)
got_lock = l.acquire_if_available()
qs2m.put(got_lock)
l.acquire()
qs2m.put(True)
d = qm2s.get()
l.release()
def __init__(self, hash_funct, encrypt_factory, window, client=True):
self.source_name = self.SSVName("SSV Stub name")
self.hash = hash_funct
self.encrypt = encrypt_factory
self.window = window
self.local = client # True for client, False for server
self.ssv_len = hash_funct().digest_size
self.ssvs = collections.deque()
self.ssv_seq = 0 # This basically counts the number of SET_SSV calls
self.lock = Lock("ssv")
# Per draft 26:
# "Before SET_SSV is called the first time on a client ID,
# the SSV is zero"
self._add_ssv('\0' * self.ssv_len)
def __init__(self, file):
self.lock = lock = Lock("StateLock_%i" % file.id)
self.file = file
self.types = (ShareState(file, lock), ByteState(file, lock),
DelegState(file, lock), LayoutState(file, lock),
AnonState(file, lock))
# Pass through the following attributes
self.anon0 = self.types[ANON][(0,)]
self.anon1 = self.types[ANON][(1,)]
self.add_share = self.types[SHARE].add_share
self.recall_conflicting_delegations = \
self.types[DELEG].recall_conflicting_delegations
self.grant_delegation = self.types[DELEG].grant_delegation
self._create_lockowner = self.types[BYTE]._create_lockowner
#self.delegreturn = self.types[DELEG].delegreturn
self.grant_layout = self.types[LAYOUT].grant_layout
def test_multiproc1(self):
l = Lock(self.dir, "id1")
l.acquire()
qs2m = Queue()
qm2s = Queue()
p = Process(target=lock_getter1, args=(self.dir, "id1", qs2m, qm2s))
p.start()
r = qs2m.get()
self.assertFalse(r, "Slave process was able to get lock!")
l.release()
d = qs2m.get()
got_lock = l.acquire_if_available()
self.assertFalse(got_lock)
qm2s.put(True)
l.acquire()
l.release()
l.cleanup()
def test_self_deadlock(self):
l1 = Lock(self.dir, "id1")
l2 = Lock(self.dir, "id2")
l1.acquire()
l2.acquire()
l1.release()
l2.release()
l1.acquire()
l2.acquire()
l2.release()
l1.release()
def test_sequential_locking(self):
l = Lock(self.dir, "id1")
self.assertFalse(l.is_locked())
l.acquire()
self.assertTrue(l.is_locked())
l.release()
self.assertFalse(l.is_locked())
got_lock = l.acquire_if_available()
self.assertTrue(got_lock)
got_exception = False
try:
l.acquire()
except LockError:
got_exception = True
self.assertTrue(got_exception)
l.release()
l.cleanup()
self.assertFalse(os.path.exists(l.path))
