def testIsLocked(self):
lockf = self.mktemp()
self.failIf(lockfile.isLocked(lockf))
lock = lockfile.FilesystemLock(lockf)
self.failUnless(lock.lock())
self.failUnless(lockfile.isLocked(lockf))
lock.unlock()
self.failIf(lockfile.isLocked(lockf))
def testIsLocked(self):
lockf = self.mktemp()
self.failIf(lockfile.isLocked(lockf))
lock = lockfile.FilesystemLock(lockf)
self.failUnless(lock.lock())
self.failUnless(lockfile.isLocked(lockf))
lock.unlock()
self.failIf(lockfile.isLocked(lockf))
def test_isLocked(self):
"""
L{isLocked} returns C{True} if the named lock is currently locked,
C{False} otherwise.
"""
lockf = self.mktemp()
self.assertFalse(lockfile.isLocked(lockf))
lock = lockfile.FilesystemLock(lockf)
self.assertTrue(lock.lock())
self.assertTrue(lockfile.isLocked(lockf))
lock.unlock()
self.assertFalse(lockfile.isLocked(lockf))
def test_isLocked(self):
"""
L{isLocked} returns C{True} if the named lock is currently locked,
C{False} otherwise.
"""
lockf = self.mktemp()
self.assertFalse(lockfile.isLocked(lockf))
lock = lockfile.FilesystemLock(lockf)
self.assertTrue(lock.lock())
self.assertTrue(lockfile.isLocked(lockf))
lock.unlock()
self.assertFalse(lockfile.isLocked(lockf))
def testPIDFile(self):
filename = self.mktemp()
f = Factory(self, filename)
l = reactor.listenUNIX(filename, f, mode = 0600, wantPID=1)
self.failUnless(lockfile.isLocked(filename + ".lock"))
tcf = TestClientFactory(self, filename)
c = reactor.connectUNIX(filename, tcf, checkPID=1)
spinUntil(lambda :getattr(f.protocol, 'made', None) and
getattr(tcf.protocol, 'made', None))
self._addPorts(l, c.transport, tcf.protocol.transport, f.protocol.transport)
self.cleanPorts(*self.ports)
self.failIf(lockfile.isLocked(filename + ".lock"))
def testPIDFile(self):
filename = self.mktemp()
f = Factory(self, filename)
l = reactor.listenUNIX(filename, f, mode = 0600, wantPID=1)
self.failUnless(lockfile.isLocked(filename + ".lock"))
tcf = TestClientFactory(self, filename)
c = reactor.connectUNIX(filename, tcf, checkPID=1)
spinUntil(lambda :getattr(f.protocol, 'made', None) and
getattr(tcf.protocol, 'made', None))
self._addPorts(l, c.transport, tcf.protocol.transport, f.protocol.transport)
self.cleanPorts(*self.ports)
self.failIf(lockfile.isLocked(filename + ".lock"))
def __init__(self, filename, connector, reactor=None, checkPID = 0):
self.connector = connector
self.realAddress = self.addr = filename
if checkPID and not lockfile.isLocked(filename + ".lock"):
self._finishInit(None, None, error.BadFileError(filename), reactor)
self._finishInit(self.doConnect, self.createInternetSocket(),
None, reactor)
def __init__(self, filename, connector, reactor=None, checkPID=0):
self.connector = connector
self.realAddress = self.addr = filename
if checkPID and not lockfile.isLocked(filename + ".lock"):
self._finishInit(None, None, error.BadFileError(filename), reactor)
self._finishInit(self.doConnect, self.createInternetSocket(), None,
reactor)
def __init__(self, filename, connector, reactor=None, checkPID=0):
_SendmsgMixin.__init__(self)
# Normalise the filename using UNIXAddress
filename = address.UNIXAddress(filename).name
self.connector = connector
self.realAddress = self.addr = filename
if checkPID and not lockfile.isLocked(filename + b".lock"):
self._finishInit(None, None, error.BadFileError(filename), reactor)
self._finishInit(self.doConnect, self.createInternetSocket(), None, reactor)
def __init__(self, filename, connector, reactor=None, checkPID = 0):
_SendmsgMixin.__init__(self)
# Normalise the filename using UNIXAddress
filename = address.UNIXAddress(filename).name
self.connector = connector
self.realAddress = self.addr = filename
if checkPID and not lockfile.isLocked(filename + b".lock"):
self._finishInit(None, None, error.BadFileError(filename), reactor)
self._finishInit(self.doConnect, self.createInternetSocket(),
None, reactor)
def testPIDFile(self):
filename = self.mktemp()
f = Factory(self, filename)
l = reactor.listenUNIX(filename, f, mode = 0600, wantPID=1)
self.failUnless(lockfile.isLocked(filename + ".lock"))
tcf = TestClientFactory(self, filename)
c = reactor.connectUNIX(filename, tcf, checkPID=1)
d = defer.gatherResults([f.deferred, tcf.deferred])
def _portStuff(ignored):
self._addPorts(l, c.transport, tcf.protocol.transport,
f.protocol.transport)
return self.cleanPorts(*self.ports)
def _check(ignored):
self.failIf(lockfile.isLocked(filename + ".lock"), 'locked')
d.addCallback(_portStuff)
d.addCallback(_check)
return d
def test_pidFile(self):
"""
A lockfile is created and locked when L{IReactorUNIX.listenUNIX} is
called and released when the Deferred returned by the L{IListeningPort}
provider's C{stopListening} method is called back.
"""
filename = self.mktemp()
serverFactory = MyServerFactory()
serverConnMade = defer.Deferred()
serverFactory.protocolConnectionMade = serverConnMade
unixPort = reactor.listenUNIX(filename, serverFactory, wantPID=True)
self.assertTrue(lockfile.isLocked(filename + ".lock"))
# XXX This part would test something about the checkPID parameter, but
# it doesn't actually. It should be rewritten to test the several
# different possible behaviors. -exarkun
clientFactory = MyClientFactory()
clientConnMade = defer.Deferred()
clientFactory.protocolConnectionMade = clientConnMade
reactor.connectUNIX(filename, clientFactory, checkPID=1)
d = defer.gatherResults([serverConnMade, clientConnMade])
def _portStuff(args):
serverProtocol, clientProto = args
# Incidental assertion which may or may not be redundant with some
# other test. This probably deserves its own test method.
self.assertEqual(
clientFactory.peerAddresses, [address.UNIXAddress(filename)]
)
clientProto.transport.loseConnection()
serverProtocol.transport.loseConnection()
return unixPort.stopListening()
d.addCallback(_portStuff)
def _check(ignored):
self.assertFalse(lockfile.isLocked(filename + ".lock"), "locked")
d.addCallback(_check)
return d
def test_pidFile(self):
"""
A lockfile is created and locked when L{IReactorUNIX.listenUNIX} is
called and released when the Deferred returned by the L{IListeningPort}
provider's C{stopListening} method is called back.
"""
filename = self.mktemp()
serverFactory = MyServerFactory()
serverConnMade = defer.Deferred()
serverFactory.protocolConnectionMade = serverConnMade
unixPort = reactor.listenUNIX(filename, serverFactory, wantPID=True)
self.assertTrue(lockfile.isLocked(filename + ".lock"))
# XXX This part would test something about the checkPID parameter, but
# it doesn't actually. It should be rewritten to test the several
# different possible behaviors. -exarkun
clientFactory = MyClientFactory()
clientConnMade = defer.Deferred()
clientFactory.protocolConnectionMade = clientConnMade
reactor.connectUNIX(filename, clientFactory, checkPID=1)
d = defer.gatherResults([serverConnMade, clientConnMade])
def _portStuff((serverProtocol, clientProto)):
# Incidental assertion which may or may not be redundant with some
# other test. This probably deserves its own test method.
self.assertEqual(clientFactory.peerAddresses, [address.UNIXAddress(filename)])
clientProto.transport.loseConnection()
serverProtocol.transport.loseConnection()
return unixPort.stopListening()
d.addCallback(_portStuff)
def _check(ignored):
self.failIf(lockfile.isLocked(filename + ".lock"), "locked")
d.addCallback(_check)
return d
class CtxFactory(ssl.ClientContextFactory):
def getContext(self):
self.method = SSL.TLSv1_METHOD
ctx = ssl.ClientContextFactory.getContext(self)
ctx.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT,
verifyCallback)
#print dir(ctx)
#raise SystemExit
return ctx
from os import path
if __name__ == '__main__':
lock = FilesystemLock("treestatusbot.lock")
if isLocked("treestatusbot.lock"):
raise SystemExit("There's already a bot running. If this is not the "
"case, please remove treestatusbot.lock manually")
else:
lock.lock()
def unlock():
lock.unlock()
f = GaiaBotFactory()
reactor.connectSSL(SERVER, int(PORT), f, CtxFactory())
print "Connecting to", SERVER, PORT
# run bot
reactor.addSystemEventTrigger('before', 'shutdown', unlock)
reactor.run()
def _check(ignored):
self.assertFalse(lockfile.isLocked(filename + ".lock"), 'locked')
def _check(ignored):
self.failIf(lockfile.isLocked(filename + ".lock"), 'locked')
def getContext(self):
self.method = SSL.TLSv1_METHOD
ctx = ssl.ClientContextFactory.getContext(self)
ctx.set_verify(
SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT,
verifyCallback
)
#print dir(ctx)
#raise SystemExit
return ctx
from os import path
if __name__ == '__main__':
lock = FilesystemLock("treestatusbot.lock")
if isLocked("treestatusbot.lock"):
raise SystemExit("There's already a bot running. If this is not the "
"case, please remove treestatusbot.lock manually")
else:
lock.lock()
def unlock():
lock.unlock()
f = GaiaBotFactory()
reactor.connectSSL(SERVER, int(PORT), f, CtxFactory())
print "Connecting to", SERVER, PORT
# run bot
reactor.addSystemEventTrigger('before', 'shutdown', unlock)
reactor.run()
def _check(ignored):
self.assertFalse(lockfile.isLocked(filename + ".lock"), 'locked')
def test_holds_file_system_lock(self):
lock = self.make_lock()
self.assertFalse(lockfile.isLocked(lock.path))
with lock:
self.assertTrue(lockfile.isLocked(lock.path))
self.assertFalse(lockfile.isLocked(lock.path))
def _check(ignored):
self.failIf(lockfile.isLocked(filename + ".lock"), 'locked')
