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 __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 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 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 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 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_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 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 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')