def startServer(port, stateDir, luceneserverPort, gatewayPort, quickCommit=False, **ignored):
setSignalHandlers()
print 'Firing up Index Server.'
statePath = abspath(stateDir)
writerReactor = Reactor()
writer = writerMain(
writerReactor=writerReactor,
statePath=statePath,
luceneserverPort=luceneserverPort,
gatewayPort=gatewayPort,
quickCommit=quickCommit,
)
writerServer = be(writer)
# Start writer in main (this) thread:
consume(writerServer.once.observer_init())
registerShutdownHandler(statePath=statePath, server=writerServer, reactor=writerReactor, shutdownMustSucceed=False)
print "Ready to rumble at port %s" % port
stdout.flush()
writerReactor.loop()
def startServer(port,
stateDir,
lucenePort,
gatewayPort,
quickCommit=False,
**kwargs):
setSignalHandlers()
print 'Firing up API Server.'
reactor = Reactor()
statePath = abspath(stateDir)
dna = main(reactor=reactor,
port=port,
statePath=statePath,
lucenePort=lucenePort,
gatewayPort=gatewayPort,
quickCommit=quickCommit,
**kwargs)
server = be(dna)
consume(server.once.observer_init())
registerShutdownHandler(statePath=statePath,
server=server,
reactor=reactor,
shutdownMustSucceed=False)
print "Ready to rumble at %s" % port
sys.stdout.flush()
reactor.loop()
def startServer(port, stateDir, luceneserverPort, gatewayPort, quickCommit=False, **ignored):
setSignalHandlers()
print 'Firing up Index Server.'
statePath = abspath(stateDir)
writerReactor = Reactor()
writer = writerMain(
writerReactor=writerReactor,
statePath=statePath,
luceneserverPort=luceneserverPort,
gatewayPort=gatewayPort,
quickCommit=quickCommit,
)
writerServer = be(writer)
# Start writer in main (this) thread:
consume(writerServer.once.observer_init())
registerShutdownHandler(statePath=statePath, server=writerServer, reactor=writerReactor, shutdownMustSucceed=False)
print "Ready to rumble at port %s" % port
stdout.flush()
writerReactor.loop()
def startServer(configFile, stateDir):
setSignalHandlers()
statePath = abspath(stateDir)
config = readConfig(configFile)
reactor = Reactor()
server = be(dna(reactor=reactor, config=config, statePath=statePath))
consume(server.once.observer_init())
registerShutdownHandler(statePath=statePath, server=server, reactor=reactor)
print "Server listening on port", config['erfgeoEnrich.portNumber']
print " - local state:", statePath
stdout.flush()
reactor.loop()
def testShouldUnregister(self):
# ... for testing purposes.
def getRelevantHandlers():
return [getsignal(sh)
for sh in SHUTDOWN_SIGNALS] # SIGTERM, SIGINT
persistable = CallTrace('Observer',
emptyGeneratorMethods=['handleShutdown'])
top = be((
Observable(),
(persistable, ),
))
reactor = CallTrace('reactor')
pre = getRelevantHandlers()
handler = registerShutdownHandler(statePath=self.tempdir,
server=top,
reactor=reactor)
_with = getRelevantHandlers()
handler.unregister()
post = getRelevantHandlers()
# shutdownHandler set
ourHandlerSet = set(_with).difference(set(pre))
self.assertEqual(1, len(ourHandlerSet))
ourHandler = ourHandlerSet.pop()
# shutdownHandler removed on .unregister()
self.assertEqual(pre, post)
# shutdownHandler is who he's supposed to be.
self.assertEqual('_handleShutdown', ourHandler.__func__.__name__)
self.assertEqual(handler, ourHandler.__self__)
def startServer(port, dataDir, dataDirFirst=None, dataDirLast=None, batchSize=None):
batchSize = batchSize or DEFAULT_BATCH_SIZE
setSignalHandlers()
tempDir = mkdtemp(prefix='mockoai-')
storage = DataStorage()
try:
reactor = Reactor()
oaiPmh = prepareOaiPmh(dataDirs=[d for d in [dataDirFirst, dataDir, dataDirLast] if d], tempDir=tempDir, storage=storage, batchSize=batchSize)
server = be(dna(reactor, port, oaiPmh, storage))
print 'Ready to rumble the mock plein server at', port
consume(server.once.observer_init())
registerShutdownHandler(statePath=tempDir, server=server, reactor=reactor)
stdout.flush()
reactor.loop()
finally:
rmtree(tempDir)
def startServer(port, dataDir=None, jsonConfig=None, batchSize=None):
batchSize = batchSize or DEFAULT_BATCH_SIZE
setSignalHandlers()
tempDir = mkdtemp(prefix='mockoai-')
config = JsonList.loads(jsonConfig or '[]')
if dataDir:
config.append({'dirs': dataDir, 'path': '/'})
try:
reactor = Reactor()
server = be(dna(reactor, port, config=config, tempDir=tempDir, batchSize=batchSize))
print 'Ready to rumble the mock plein server at', port
list(compose(server.once.observer_init()))
registerShutdownHandler(statePath=tempDir, server=server, reactor=reactor)
stdout.flush()
reactor.loop()
finally:
rmtree(tempDir)
def testShouldNotRegisteredTwice(self):
reactor = Reactor()
trace = CallTrace('Observer')
top = be((
Observable(),
(
Observable(), # Only once calls walk the observer tree.
(trace, ),
),
))
self._createShutdownHandler(statePath=self.tempdir,
server=top,
reactor=reactor)
try:
registerShutdownHandler(statePath=self.tempdir,
server='ignored',
reactor='ignored')
except AssertionError as e:
self.assertEqual('Handler already registered, aborting.', str(e))
else:
self.fail()
reactor.addTimer(0.01, lambda: None)
with stdout_replaced() as output:
try:
kill(getpid(), SIGTERM)
reactor.loop()
self.fail('should terminate')
except SystemExit as e:
self.assertEqual((0, ), e.args)
self.assertTrue(
'Scheduled for immediate shutdown.\n' in output.getvalue(),
output.getvalue())
self.assertTrue('Shutdown completed.\n' in output.getvalue(),
output.getvalue())
# Only once!
self.assertEqual(['handleShutdown'], trace.calledMethodNames())
self.assertEqual(
((), {}),
(trace.calledMethods[0].args, trace.calledMethods[0].kwargs))
def startServer(port, stateDir, **kwargs):
setSignalHandlers()
print 'Firing up Gateway Server.'
statePath = abspath(stateDir)
isdir(statePath) or makedirs(statePath)
reactor = Reactor()
dna = main(reactor=reactor, port=port, statePath=statePath, **kwargs)
server = be(dna)
consume(server.once.observer_init())
registerShutdownHandler(statePath=statePath,
server=server,
reactor=reactor,
shutdownMustSucceed=False)
print 'Ready to rumble at %s' % port
stdout.flush()
reactor.loop()
def testShouldCallPreviouslyRegisteredSignalHandlersAfterHandleShutdown(
self):
reactor = Reactor()
called = []
def handleShutdown():
called.append('handleShutdown')
testCoName = currentframe().f_code.co_name
def prevIntHandler(signum, frame):
self.assertEqual(SIGINT, signum)
self.assertEqual(testCoName, frame.f_code.co_name)
called.append('prevIntHandler')
trace = CallTrace('Observer',
methods={'handleShutdown': handleShutdown})
top = be((
Observable(),
(
Observable(), # Only once calls walk the observer tree.
(trace, ),
),
))
origIntHandler = signal(SIGINT, prevIntHandler)
try:
shutdownHandler = registerShutdownHandler(statePath=self.tempdir,
server=top,
reactor=reactor)
reactor.addTimer(0.01, lambda: None)
with stdout_replaced() as output:
try:
kill(getpid(), SIGINT)
reactor.loop()
self.fail('should terminate')
except KeyboardInterrupt:
pass
self.assertTrue(
'Scheduled for immediate shutdown.\n' in output.getvalue(),
output.getvalue())
self.assertTrue('Shutdown completed.\n' in output.getvalue(),
output.getvalue())
finally:
shutdownHandler.unregister()
signal(SIGINT, origIntHandler)
self.assertEqual(['handleShutdown'], trace.calledMethodNames())
self.assertEqual(
((), {}),
(trace.calledMethods[0].args, trace.calledMethods[0].kwargs))
self.assertEqual(['handleShutdown', 'prevIntHandler'], called)
def startServer(port, stateDir, **kwargs):
setSignalHandlers()
print 'Firing up Gateway Server.'
statePath=abspath(stateDir)
isdir(statePath) or makedirs(statePath)
reactor = Reactor()
dna = main(
reactor=reactor,
port=port,
statePath=statePath,
**kwargs
)
server = be(dna)
consume(server.once.observer_init())
registerShutdownHandler(statePath=statePath, server=server, reactor=reactor, shutdownMustSucceed=False)
print 'Ready to rumble at %s' % port
stdout.flush()
reactor.loop()
def startServer(port, stateDir, lucenePort, **kwargs):
setSignalHandlers()
print 'Firing up SRU-slave.'
reactor = Reactor()
statePath = abspath(stateDir)
dna = main(
reactor=reactor,
port=port,
statePath=statePath,
lucenePort=lucenePort,
**kwargs
)
server = be(dna)
consume(server.once.observer_init())
registerShutdownHandler(statePath=statePath, server=server, reactor=reactor, shutdownMustSucceed=False)
print "Ready to rumble at %s" % port
sys.stdout.flush()
reactor.loop()
def startServer(port, stateDir, serverPort, gatewayPort, **ignored):
setSignalHandlers()
print 'Firing up Index Server.'
statePath = abspath(stateDir)
writerReactor = Reactor()
readerReactor = Reactor()
reader, writer = writerMain(
writerReactor=writerReactor,
readerReactor=readerReactor,
readerPort=port,
statePath=statePath,
serverPort=serverPort,
gatewayPort=gatewayPort,
)
readerServer = be(reader)
writerServer = be(writer)
def startReader():
LUCENE_VM.attachCurrentThread()
consume(readerServer.once.observer_init())
readerReactor.loop()
consume(writerServer.once.observer_init())
registerShutdownHandler(statePath=statePath, server=writerServer, reactor=writerReactor, shutdownMustSucceed=False)
tReader = Thread(target=startReader)
tReader.setDaemon(True)
tReader.start()
print "Ready to rumble at port %s" % port
stdout.flush()
writerReactor.loop()
def _createShutdownHandler(self, *args, **kwargs):
self._shutdownHandler = registerShutdownHandler(*args, **kwargs)
return self._shutdownHandler
