def get_handler(self):
if self.handler is None:
self._worker = pulsar.get_actor()
if not self.cms:
self.cms = CMS(self)
async_middleware, wsgi = self._build_handler()
self.handler = wsgi
self.fire('on_loaded')
#
# Using a green pool
if self.green_pool:
from pulsar.apps.greenio.wsgi import GreenWSGI
wsgi = GreenWSGI(wsgi, self.green_pool)
async_middleware.append(wsgi)
else:
if self.config['THREAD_POOL']:
wsgi = middleware_in_executor(wsgi)
else:
wsgi = as_async_wsgi(wsgi)
async_middleware.append(wait_for_body_middleware)
async_middleware.append(wsgi)
self.handler = WsgiHandler(async_middleware, async=True)
return self.handler
def test_registered(self):
'''Test the arbiter in its process domain'''
arbiter = pulsar.get_actor()
self.assertTrue(arbiter.is_arbiter())
self.assertTrue(arbiter.registered)
self.assertTrue('arbiter' in arbiter.registered)
self.assertTrue('test' in arbiter.registered)
def testTestSuiteMonitor(self):
arbiter = pulsar.get_actor()
self.assertTrue(len(arbiter.monitors) >= 1)
monitor = arbiter.monitors['test']
app = monitor.app
self.assertTrue(isinstance(app, TestSuite))
self.assertFalse(monitor.cpubound)
def test_ping_monitor(self):
worker = get_actor()
future = yield send('monitor', 'ping')
self.assertEqual(future, 'pong')
yield self.async.assertEqual(send(worker.monitor, 'ping'), 'pong')
response = yield send('monitor', 'notify', worker.info())
self.assertTrue(response <= time.time())
def load_config(self):
'''Load the application configuration from a file and/or
from the command line.
Called during application initialisation. The parameters
overriding order is the following:
* default parameters.
* the key-valued params passed in the initialisation.
* the parameters in the optional configuration file
* the parameters passed in the command line.
'''
# get the actor if available and override default cfg values with those
# from the actor
actor = get_actor()
if actor and actor.is_running():
# actor available and running.
# Unless argv is set, skip parsing
if self.argv is None:
self.console_parsed = False
# copy global settings
self.cfg.copy_globals(actor.cfg)
#
for name in list(self.cfg.params):
if name in self.cfg.settings:
value = self.cfg.params.pop(name)
if value is not None:
self.cfg.set(name, value)
# parse console args
if self.console_parsed:
self.cfg.parse_command_line(self.argv)
else:
self.cfg.params.update(self.cfg.import_from_module())
def get_clients():
actor = pulsar.get_actor()
clients = actor.params.clients
if clients is None:
clients = set()
actor.params.clients = clients
return clients
def test_registered(self):
'''Test the arbiter in its process domain'''
arbiter = pulsar.get_actor()
self.assertTrue(arbiter.is_arbiter())
self.assertTrue(arbiter.registered)
self.assertTrue('arbiter' in arbiter.registered)
self.assertTrue('test' in arbiter.registered)
def __call__(self, actor=None):
'''Register this application with the (optional) calling ``actor``.
If an ``actor`` is available (either via the function argument or via
the :func:`~pulsar.async.actor.get_actor` function) it must be
:class:`.Arbiter`, otherwise this call is no-op.
If no actor is available, it means this application starts
pulsar engine by creating the :class:`.Arbiter` with its
:ref:`global settings <setting-section-global-server-settings>`
copied to the arbiter :class:`.Config` container.
:return: the ``start`` one time event fired once this application
has fired it.
'''
if actor is None:
actor = get_actor()
monitor = None
if actor and actor.is_arbiter():
monitor = actor.get_actor(self.name)
if monitor is None and (not actor or actor.is_arbiter()):
self.cfg.on_start()
self.logger = self.cfg.configured_logger()
if not actor:
actor = pulsar.arbiter(cfg=self.cfg.clone())
else:
self.update_arbiter_params(actor)
self.cfg.set('exc_id', actor.cfg.exc_id)
if self.on_config(actor) is not False:
start = Future(loop=actor._loop)
actor.bind_event('start', partial(self._add_monitor, start))
return start
else:
return
raise ImproperlyConfigured('Already started or not in arbiter domain')
def get_handler(self):
if self.handler is None:
self._worker = pulsar.get_actor()
if not self.cms:
self.cms = CMS(self)
async_middleware, wsgi = self._build_handler()
self.handler = wsgi
self.fire('on_loaded')
#
# Using a green pool
if self.green_pool:
from pulsar.apps.greenio.wsgi import GreenWSGI
wsgi = GreenWSGI(wsgi, self.green_pool)
async_middleware.append(wsgi)
else:
if self.config['THREAD_POOL']:
wsgi = middleware_in_executor(wsgi)
else:
wsgi = as_async_wsgi(wsgi)
async_middleware.append(wait_for_body_middleware)
async_middleware.append(wsgi)
self.handler = WsgiHandler(async_middleware, async=True)
return self.handler
def test_sorted_tags(self):
app = get_actor().app
loader = TestLoader(app.root_dir, app.cfg.modules, app.runner)
modules = list(loader.testmodules())
self.assertTrue(modules)
tags = [m[0] for m in modules]
self.assertEqual(tags, sorted(tags))
def testPing(self):
c = self.client()
self.assertEqual(c.ping(), 'pong')
self.assertEqual(c.received, 1)
self.assertEqual(c.ping(), 'pong')
self.assertEqual(c.received, 2)
actor = pulsar.get_actor()
def test_testsuite(self):
app = pulsar.get_actor().app
self.assertTrue(app.script)
#self.assertEqual(app.script, sys.argv[0])
self.assertEqual(os.path.dirname(app.script), app.root_dir)
self.assertEqual(app.cfg.modules, ('tests', ('examples', 'tests'),
('examples', 'test_*')))
def test_tasks(self):
worker = pulsar.get_actor()
backend = worker.app.backend
self.assertTrue(worker.app.backend)
self.assertEqual(backend.name, worker.app.name)
self.assertEqual(len(backend.registry), 1)
self.assertTrue('test' in backend.registry)
def testWorkerMonitor(self):
worker = pulsar.get_actor()
monitor = worker.monitor
arbiter = worker.arbiter
mailbox = monitor.mailbox
self.assertEqual(mailbox, arbiter.mailbox)
self.assertTrue(mailbox.async)
def test_suite_event_loop(self):
'''Test event loop in test worker'''
worker = pulsar.get_actor()
loop = get_event_loop()
self.assertTrue(loop.is_running())
self.assertTrue(worker._loop.is_running())
self.assertNotEqual(worker._loop, loop)
def test_ping_monitor(self):
worker = get_actor()
future = yield send('monitor', 'ping')
self.assertEqual(future, 'pong')
yield self.async.assertEqual(send(worker.monitor, 'ping'), 'pong')
response = yield send('monitor', 'notify', worker.info())
self.assertTrue(response <= time.time())
def load_config(self):
"""Load the application configuration from a file and/or
from the command line.
Called during application initialisation. The parameters
overriding order is the following:
* default parameters.
* the key-valued params passed in the initialisation.
* the parameters in the optional configuration file
* the parameters passed in the command line.
"""
# get the actor if available and override default cfg values with those
# from the actor
actor = get_actor()
if actor and actor.is_running():
# actor available and running.
# Unless argv is set, skip parsing
if self.argv is None:
self.console_parsed = False
# copy global settings
self.cfg.copy_globals(actor.cfg)
#
for name in list(self.cfg.params):
if name in self.cfg.settings:
value = self.cfg.params.pop(name)
if value is not None:
self.cfg.set(name, value)
# parse console args
if self.console_parsed:
self.cfg.parse_command_line(self.argv)
else:
self.cfg.params.update(self.cfg.import_from_module())
def test_actor_coverage(self):
'''test case for coverage'''
actor = pulsar.get_actor()
try:
yield send(send, 'sjdcbhjscbhjdbjsj', 'bla')
except CommandNotFound:
pass
def test_sorted_tags(self):
app = get_actor().app
loader = TestLoader(app.root_dir, app.cfg.modules, app.runner)
modules = list(loader.testmodules())
self.assertTrue(modules)
tags = [m[0] for m in modules]
self.assertEqual(tags, sorted(tags))
def run(self, callable):
actor = get_actor()
if actor.is_monitor():
return callable(actor)
else:
# send the callable to the actor monitor
return actor.send(actor.monitor, 'run', callable)
def test_ping_monitor(self):
worker = get_actor()
future = yield send("monitor", "ping")
self.assertEqual(future, "pong")
yield self.async.assertEqual(send(worker.monitor, "ping"), "pong")
response = yield send("monitor", "notify", worker.info())
self.assertTrue(response <= time.time())
def test_dummy_proxy(self):
p = pulsar.concurrency('thread', pulsar.Actor, pulsar.get_actor(),
pulsar.Config())
self.assertEqual(p.mailbox, None)
self.assertEqual(p.spawning_start, None)
self.assertEqual(p.stopping_start, None)
self.assertEqual(p.callback, None)
self.assertEqual(str(p), 'actor(%s)' % p.aid)
def testMeta(self):
app = yield get_application(self.name())
self.assertEqual(app.name, self.name())
monitor = get_actor().get_actor(app.name)
self.assertTrue(monitor.is_running())
self.assertEqual(app, monitor.app)
self.assertEqual(str(app), app.name)
self.assertEqual(app.cfg.bind, '127.0.0.1:0')
def server(callable=None, name=None, data_store=None, **params):
name = name or "wsgi"
if not data_store:
actor = get_actor()
if actor:
data_store = actor.cfg.data_store
data_store = pulsards_url(data_store)
return WSGIServer(callable=WebChat(name), name=name, data_store=data_store, **params)
def test_arbiter_mailbox(self):
arbiter = pulsar.get_actor()
mailbox = arbiter.mailbox
self.assertFalse(hasattr(mailbox, 'request'))
# Same for all monitors mailboxes
for monitor in arbiter.monitors.values():
mailbox = monitor.mailbox
self.assertFalse(hasattr(mailbox, 'request'))
def test_arbiter_mailbox(self):
arbiter = pulsar.get_actor()
mailbox = arbiter.mailbox
self.assertFalse(hasattr(mailbox, 'request'))
# Same for all monitors mailboxes
for monitor in arbiter.monitors.values():
mailbox = monitor.mailbox
self.assertFalse(hasattr(mailbox, 'request'))
def testNOT_DONE(self):
worker = pulsar.get_actor()
count = worker.requestloop.num_loops
yield pulsar.NOT_DONE
self.assertFalse(worker.requestloop._callbacks)
self.assertEqual(worker.requestloop.num_loops, count+1)
yield pulsar.NOT_DONE
self.assertEqual(worker.requestloop.num_loops, count+2)
def test_dummy_proxy(self):
p = pulsar.concurrency('thread', pulsar.Actor, pulsar.get_actor(),
pulsar.Config())
self.assertEqual(p.mailbox, None)
self.assertEqual(p.spawning_start, None)
self.assertEqual(p.stopping_start, None)
self.assertEqual(p.callback, None)
self.assertEqual(str(p), 'actor(%s)' % p.aid)
def test_testsuite(self):
app = pulsar.get_actor().app
self.assertTrue(app.script)
#self.assertEqual(app.script, sys.argv[0])
self.assertEqual(os.path.dirname(app.script), app.root_dir)
self.assertEqual(app.cfg.modules, ('tests',
('examples', 'tests'),
('examples', 'test_*')))
def test_NOT_DONE(self):
worker = pulsar.get_actor()
loop = pulsar.get_request_loop()
count = loop.num_loops
yield pulsar.NOT_DONE
self.assertEqual(loop.num_loops, count+1)
yield pulsar.NOT_DONE
self.assertEqual(loop.num_loops, count+2)
def testFakeSignal(self):
arbiter = pulsar.get_actor()
self.assertTrue(arbiter.is_arbiter())
# Now put the signal in the queue
arbiter.signal_queue.put('foooooo')
self.assertTrue(arbiter.signal_queue.qsize() >= 1)
# we need to yield so that the arbiter has a chance to process the signal
yield pulsar.NOT_DONE
def testFunctionFromConfigFile(self):
worker = get_actor()
cfg = Config()
self.assertEqual(cfg.worker_task(worker), None)
self.assertTrue(cfg.import_from_module(__file__))
self.assertEqual(cfg.worker_task(worker), worker)
cfg1 = pickle.loads(pickle.dumps(cfg))
self.assertEqual(cfg1.worker_task(worker), worker)
def testMeta(self):
app = yield get_application(self.name())
self.assertEqual(app.name, self.name())
monitor = get_actor().get_actor(app.name)
self.assertTrue(monitor.is_running())
self.assertEqual(app, monitor.app)
self.assertEqual(str(app), app.name)
self.assertEqual(app.cfg.bind, '127.0.0.1:0')
def server(callable=None, name=None, data_store=None, **params):
name = name or 'wsgi'
if not data_store:
actor = get_actor()
if actor:
data_store = actor.cfg.data_store
data_store = pulsards_url(data_store)
return WSGIServer(callable=WebChat(name), name=name,
data_store=data_store, **params)
def test_ping_test_worker(self):
arbiter = pulsar.get_actor()
info = arbiter.info()
test = info['monitors']['test']
workers = [w['actor']['actor_id'] for w in test['workers']]
self.assertTrue(workers)
result = yield multi_async((arbiter.send(w, 'ping') for w in workers))
self.assertEqual(len(result), len(workers))
self.assertEqual(result, len(result) * ['pong'])
def testFunctionFromConfigFile(self):
worker = get_actor()
cfg = config()
self.assertEqual(cfg.connection_made(worker), None)
module_name = 'tests.utils'
self.assertEqual(cfg.import_from_module(module_name)[0], ('foo', 5))
self.assertEqual(cfg.connection_made(worker), worker)
cfg1 = pickle.loads(pickle.dumps(cfg))
self.assertEqual(cfg1.connection_made(worker), worker)
def test_ping_test_worker(self):
arbiter = pulsar.get_actor()
info = arbiter.info()
test = info['monitors']['test']
workers = [w['actor']['actor_id'] for w in test['workers']]
self.assertTrue(workers)
result = yield multi_async((arbiter.send(w, 'ping') for w in workers))
self.assertEqual(len(result), len(workers))
self.assertEqual(result, len(result)*['pong'])
def __call__(self, test, timeout):
test = SafeTest(test)
callable = TestCallable(test, self.method_name, self.istest, timeout)
actor = get_actor()
if actor.is_monitor():
return callable(actor)
else:
# send the callable to the actor monitor
return actor.send(actor.monitor, 'run', callable)
def __call__(self, test, timeout):
test = SafeTest(test)
callable = TestCallable(test, self.method_name, self.istest, timeout)
actor = get_actor()
if actor.is_monitor():
return callable(actor)
else:
# send the callable to the actor monitor
return actor.send(actor.monitor, 'run', callable)
def test_load_exclude(self):
app = get_actor().app
loader = TestLoader(app.root_dir, app.cfg.modules, app.runner)
modules = dict(
loader.testmodules(exclude_tags=('taskqueue', 'apps.pubsub')))
self.assertTrue(modules)
for module in modules:
self.assertTrue('taskqueue' not in module)
self.assertTrue('apps.pubsub' not in module)
def testFunction(self):
cfg = Config()
worker = get_actor()
self.assertTrue(cfg.arbiter_task)
self.assertEqual(cfg.arbiter_task(worker), None)
cfg.set('arbiter_task', worker_task)
self.assertEqual(cfg.arbiter_task(worker), worker)
cfg1 = pickle.loads(pickle.dumps(cfg))
self.assertEqual(cfg1.arbiter_task(worker), worker)
def get_application(name):
'''Invoked in the arbiter domain, this function will return
the :class:`Application` associated with *name* if available. If not in the
:class:`Arbiter` domain it returns nothing.'''
actor = get_actor()
if actor and actor.is_arbiter():
monitor = actor.monitors.get(name)
if monitor:
return getattr(monitor, 'app', None)
def testFunction(self):
cfg = Config()
worker = get_actor()
self.assertTrue(cfg.post_fork)
self.assertEqual(cfg.post_fork(worker), None)
cfg.set('post_fork', post_fork)
self.assertEqual(cfg.post_fork(worker), worker)
cfg1 = pickle.loads(pickle.dumps(cfg))
self.assertEqual(cfg1.post_fork(worker), worker)
def __testFunctionFromConfigFile(self):
# TODO, fails in pypy for some odd reasons
worker = get_actor()
cfg = Config()
self.assertEqual(cfg.connection_made(worker), None)
self.assertTrue(cfg.import_from_module(__file__))
self.assertEqual(cfg.connection_made(worker), worker)
cfg1 = pickle.loads(pickle.dumps(cfg))
self.assertEqual(cfg1.connection_made(worker), worker)
def get_params(*names):
cfg = get_actor().cfg
values = []
for name in names:
value = cfg.get(name)
if value:
values.append(value)
else:
return None
return values
def test_mailbox(self):
worker = pulsar.get_actor()
mailbox = worker.mailbox
self.assertTrue(mailbox)
self.assertTrue(hasattr(mailbox, 'request'))
self.assertTrue(mailbox._loop)
self.assertTrue(mailbox._loop.is_running())
self.assertEqual(worker._loop, mailbox._loop)
self.assertTrue(mailbox.address)
self.assertTrue(mailbox.name)
def stop(self, actor=None):
'''Stop the application
'''
if actor is None:
actor = get_actor()
if actor and actor.is_arbiter():
monitor = actor.get_actor(self.name)
if monitor:
return monitor.stop()
raise RuntimeError('Cannot stop application')
def __call__(self, argv, start=True):
app = self.app
server = self.pulsar_app(argv, wsgi.WSGIServer)
if start and not server.logger: # pragma nocover
if not pulsar.get_actor():
clear_logger()
app._started = server()
app.on_start(server)
arbiter = pulsar.arbiter()
arbiter.start()
return app
def get(cls, id, actor=None, backend=None):
actor = actor or get_actor()
if not actor:
raise RuntimeError('Cannot initialise pubsub when no actor.')
if 'pubsub' not in actor.params:
actor.params.pubsub = {}
be = actor.params.pubsub.get(id)
if not be and backend:
be = backend
actor.params.pubsub[id] = be
return be
def dont_run_with_thread(obj):
'''Decorator for disabling process based test cases when the test suite
runs in threading, rather than processing, mode.
'''
actor = pulsar.get_actor()
if actor:
d = unittest.skipUnless(actor.cfg.concurrency == 'process',
'Run only when concurrency is process')
return d(obj)
else:
return obj
def _init(self, namespace=None, parser_class=None, pool_size=50,
decode_responses=False, **kwargs):
self._decode_responses = decode_responses
if not parser_class:
actor = get_actor()
pyparser = actor.cfg.redis_py_parser if actor else False
parser_class = redis_parser(pyparser)
self._parser_class = parser_class
if namespace:
self._urlparams['namespace'] = namespace
self._pool = Pool(self.connect, pool_size=pool_size, loop=self._loop)
self.loaded_scripts = {}
def test_mailbox(self):
worker = pulsar.get_actor()
mailbox = worker.mailbox
self.assertTrue(mailbox)
self.assertTrue(hasattr(mailbox, 'request'))
self.assertTrue(mailbox.event_loop)
self.assertTrue(mailbox.event_loop.running)
self.assertEqual(worker.event_loop, mailbox.event_loop)
self.assertEqual(worker.tid, mailbox.event_loop.tid)
self.assertTrue(mailbox.address)
self.assertTrue(mailbox.name)
self.assertEqual(mailbox.concurrent_connections, 1)
def test_event_loop(self):
'''Test event loop in test worker'''
worker = pulsar.get_actor()
loop = pulsar.get_request_loop()
event_loop = get_event_loop()
self.assertTrue(loop.running)
self.assertTrue(event_loop.running)
self.assertNotEqual(loop, event_loop)
self.assertEqual(worker.event_loop, event_loop)
self.assertEqual(worker.tid, worker.event_loop.tid)
self.assertNotEqual(worker.tid, loop.tid)
self.assertTrue(str(event_loop))
def testArbiterObject(self):
'''Test the arbiter in its process domain'''
arbiter = pulsar.get_actor()
self.assertEqual(arbiter, pulsar.arbiter())
self.assertTrue(arbiter.is_arbiter())
self.assertEqual(arbiter.impl.kind, 'arbiter')
self.assertTrue(arbiter.monitors)
self.assertEqual(arbiter.exit_code, None)
info = arbiter.info()
self.assertTrue('server' in info)
server = info['server']
self.assertEqual(server['state'], 'running')
