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(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