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(port, **kwargs):
reactor = Reactor()
server = be(dna(reactor, port, **kwargs))
list(compose(server.once.observer_init()))
print("Ready to rumble at", port)
stdout.flush()
reactor.loop()
def startServer(**kwargs):
reactor = Reactor()
server = be(dna(reactor=reactor, **kwargs))
list(compose(server.once.observer_init()))
print "Ready to rumble at", kwargs['port']
reactor.loop()
def startServer(**kwargs):
reactor = Reactor()
server = be(dna(reactor=reactor, **kwargs))
list(compose(server.once.observer_init()))
print "Ready to rumble at", kwargs['port']
reactor.loop()
def startServer(port, **kwargs):
reactor = Reactor()
server = be(dna(reactor, port, **kwargs))
list(compose(server.once.observer_init()))
print "Ready to rumble at", port
stdout.flush()
reactor.loop()
def main():
parser = ParseArguments()
parser.addOption('', '--port', type='int', mandatory=True)
parser.addOption('', '--solrPort', type='int', mandatory=True)
options, arguments = parser.parse()
reactor = Reactor()
server = createServer(reactor, **vars(options))
list(compose(server.once.observer_init()))
reactor.loop()
def main():
parser = ParseArguments()
parser.addOption('', '--port', type='int', mandatory=True)
parser.addOption('', '--solrPort', type='int', mandatory=True)
options, arguments = parser.parse()
reactor = Reactor()
server = createServer(reactor, **vars(options))
list(compose(server.once.observer_init()))
reactor.loop()
def _asProcess(g):
if not is_generator(g):
raise TypeError("asProcess() expects a generator, got %s" % repr(g))
reactor = Reactor() # Between creating and reactor.loop() there should be no statements that can raise exceptions (otherwise (epoll) fd-leaking occurs).
wrapper(g, reactor)
try:
reactor.loop()
except StopIteration, e:
if e.args:
return e.args[0]
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(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 startServer(stateDir, **kwargs):
setSignalHandlers()
print 'Firing up Meresco Lucene Server.'
reactor = Reactor()
databasePath = realpath(abspath(stateDir))
#main
dna = main(reactor, databasePath=databasePath, **kwargs)
#/main
server = be(dna)
list(compose(server.once.observer_init()))
print "Ready to rumble"
stdout.flush()
reactor.loop()
def startServer(configFile):
config = readConfig(configFile)
hostName = config['hostName']
portNumber = int(config['portNumber'])
databasePath = config['databasePath']
reactor = Reactor()
observableHttpServer = ObservableHttpServer(reactor, portNumber)
server = be(dna(reactor, observableHttpServer, config))
list(compose(server.once.observer_init()))
print "Server listening on", hostName, "at port", portNumber
print " - database:", databasePath, "\n"
stdout.flush()
reactor.loop()
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, stateDir, **kwargs):
setSignalHandlers()
print 'Firing up Meresco Lucene Server.'
reactor = Reactor()
databasePath = realpath(abspath(stateDir))
#main
dna = main(reactor, port=port, databasePath=databasePath)
#/main
server = be(dna)
list(compose(server.once.observer_init()))
print "Ready to rumble"
stdout.flush()
reactor.loop()
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 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 main(port):
reactor = Reactor()
dna = (Observable(), (ObservableHttpServer(reactor,
int(port)), (DynamicHtml(
[join(mydir, "dynamic")],
reactor=reactor,
indexPage="/index",
additionalGlobals={
'httpget': httpget,
'urlencode': urlencode,
'json_loads': loads,
'namespaces': namespaces
}), )))
server = be(dna)
list(compose(server.once.observer_init()))
reactor.loop()
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, 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, **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 main(port):
reactor = Reactor()
dna = (Observable(),
(ObservableHttpServer(reactor, int(port)),
(DynamicHtml(
[join(mydir, "dynamic")],
reactor=reactor,
indexPage="/index",
additionalGlobals={
'httpget': httpget,
'urlencode': urlencode,
'json_loads': loads,
'namespaces': namespaces
}),
)
)
)
server = be(dna)
list(compose(server.once.observer_init()))
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()
yield answer
def _findLastNumber(self):
return max([int(basename(f)[:5]) for f in glob(join(self._dumpdir, '*.updateRequest'))]+[0])
def main(reactor, portNumber, dumpdir):
isdir(dumpdir) or makedirs(dumpdir)
server = be(
(Observable(),
(ObservableHttpServer(reactor, portNumber),
(Dump(dumpdir),)
)
)
)
list(compose(server.once.observer_init()))
if __name__== '__main__':
args = argv[1:]
if len(args) != 2:
print "Usage %s <portnumber> <dumpdir>" % argv[0]
exit(1)
portNumber = int(args[0])
dumpdir = args[1]
reactor = Reactor()
main(reactor, portNumber, dumpdir)
print 'Ready to rumble the dumpserver at', portNumber
print ' - dumps are written to', dumpdir
stdout.flush()
reactor.loop()
