async def _arbiter_work(self):
self.actors = []
if not self._actors_init_tasks:
self._actors_init_tasks = [_default_actor_init_task] * len(self._actors_counts)
if not self._actors_last_tasks:
self._actors_last_tasks = [_default_actor_last_task] * len(self._actors_counts)
for i in range(len(self._actors_counts)):
for j in range(self._actors_counts[i]):
actor_name = 'actor({}, {})'.format(i, j)
print(get_actor().name + ': Tworzę aktora ' + actor_name + '...')
actor = await spawn(name=actor_name, start=partial(ArbiterHelper._init_actor, number=i,
init_func=partial(self._actors_init_tasks[i]),
last_job=partial(self._actors_last_tasks[i])))
self.actors.append(actor)
while True in [actor.is_alive() for actor in self.actors]:
await asyncio.sleep(1)
await self._arbiter_last_task()
await asyncio.sleep(5)
try:
arbiter().stop()
except PermissionError: # Windows
quit()
async def _work(self, a=None):
if a is None:
a = await spawn(name='greeter')
if names:
name = names.pop()
await send(a, 'greetme', {'name': name})
self._loop.call_later(1, self, a)
else:
arbiter().stop()
async def app():
# Spawn a new actor
proxy = await spawn(name='actor1')
print(proxy.name)
# Execute inner method in actor1
result = await send(proxy, 'run', inner_method)
print(result)
await send(proxy, 'run', set_value, 10)
value = await send(proxy, 'run', get_value)
print(value)
# Stop the application
arbiter().stop()
def __init__(self, transport_loop):
"""Initialize member variables."""
self.arbiter = arbiter(start=self._start, stopping=self._stop)
self.image_plotter = Plotter()
self.camera = Camera(image_receivers=[self.image_plotter])
self.protocol = Protocol('Y-Axis', 'y')
self.translator = BasicTranslator(message_receivers=[self.protocol])
self.protocol.command_receivers.append(self.translator)
self.response_receiver = ResponseReceiver(
response_receivers=[self.translator])
self.transport_manager = TransportManager(
self.arbiter,
transport_loop,
response_receiver=self.response_receiver)
self.translator.serialized_message_receivers.append(
self.transport_manager.command_sender)
self.batch_execution_manager = BatchExecutionManager(
self.arbiter,
self.transport_manager.command_sender,
self.test_routine,
header=batch.OUTPUT_HEADER,
ready_waiter=self.transport_manager.connection_synchronizer.
wait_connected)
print('Showing webcam display...')
self.image_plotter.show()
def __call__(self, argv, start=True, get_app=False):
self.app.callable.command = self.name
app = self.app
server = self.pulsar_app(argv, self.wsgiApp,
server_software=app.config['SERVER_NAME'])
if server.cfg.nominify:
app.params['MINIFIED_MEDIA'] = False
if start and not server.logger: # pragma nocover
if not get_actor():
clear_logger()
app._started = server()
app.fire_event('on_start', data=server)
arbiter().start()
if not start:
return app if get_app else server
def __init__(self, transport_loop):
"""Initialize member variables."""
self.arbiter = arbiter(start=self._start, stopping=self._stop)
self.translator = BasicTranslator()
self.response_receiver = ResponseReceiver(
response_receivers=[self.translator])
self.transport_manager = TransportManager(
self.arbiter,
transport_loop,
response_receiver=self.response_receiver)
self.translator.serialized_message_receivers.append(
self.transport_manager.command_sender)
self.command_sender = self.transport_manager.command_sender
self.connection_synchronizer = self.transport_manager.connection_synchronizer
self.execution_managers = []
async def _arbiter_work(self):
actors = []
for i in range(self._actors_count):
actor_name = 'actor{}'.format(i)
print(get_actor().name + ': Tworzę aktora ' + actor_name + '...')
actor = await spawn(name=actor_name,
start=partial(
Agency._init_actor,
init_func=partial(self._actor_init_task),
last_job=partial(self._actor_last_task)))
actors.append(actor)
while True in [actor.is_alive() for actor in actors]:
await asyncio.sleep(1)
await self._arbiter_last_task()
await asyncio.sleep(5)
try:
arbiter().stop()
except PermissionError: # Windows
quit()
def __init__(self, transport_loop):
"""Initialize member variables."""
self.arbiter = arbiter(start=self._start, stopping=self._stop)
self.response_printer = SerializedMessagePrinter(
prefix=batch.RESPONSE_PREFIX)
self.command_printer = SerializedMessagePrinter(prefix=' Sending: ')
self.response_receiver = ResponseReceiver(
response_receivers=[self.response_printer])
self.transport_manager = TransportManager(
self.arbiter,
transport_loop,
response_receiver=self.response_receiver)
self.batch_execution_manager = BatchExecutionManager(
self.arbiter,
self.transport_manager.command_sender,
self.test_routine,
header=batch.OUTPUT_HEADER,
ready_waiter=self.transport_manager.connection_synchronizer.
wait_connected)
def wait_for_stop(test, aid, terminating=False):
'''Wait for an actor to stop'''
actor = arbiter()
waiter = create_future(loop=actor._loop)
def remove():
test.assertEqual(actor.event('periodic_task').unbind(check), 1)
waiter.set_result(None)
def check(caller, **kw):
test.assertEqual(caller, actor)
if not terminating:
test.assertFalse(aid in actor.managed_actors)
elif aid in actor.managed_actors:
return
actor._loop.call_soon(remove)
actor.event('periodic_task').bind(check)
return waiter
def wait_for_stop(test, aid, terminating=False):
'''Wait for an actor to stop'''
actor = arbiter()
waiter = create_future(loop=actor._loop)
def remove():
test.assertEqual(actor.event('periodic_task').unbind(check), 1)
waiter.set_result(None)
def check(caller, **kw):
test.assertEqual(caller, actor)
if not terminating:
test.assertFalse(aid in actor.managed_actors)
elif aid in actor.managed_actors:
return
actor._loop.call_soon(remove)
actor.event('periodic_task').bind(check)
return waiter
def __init__(self, transport_loop):
"""Initialize member variables."""
self.arbiter = arbiter(start=self._start, stopping=self._stop)
self.command_printer = MessagePrinter(prefix=' Sending: ')
self.echo_response_printer = MessagePrinter(
prefix=('\t' * batch.OUTPUT_WIDTH + '[Echo]\t')
)
self.reset_response_printer = MessagePrinter(
prefix=('\t' * batch.OUTPUT_WIDTH + '[Reset]\t')
)
self.version_response_printer = MessagePrinter(
prefix=('\t' * batch.OUTPUT_WIDTH + '[Version]\t')
)
self.builtin_led_response_printer = MessagePrinter(
prefix=('\t' * batch.OUTPUT_WIDTH + '[BuiltinLED]\t')
)
self.response_dispatcher = Dispatcher(
receivers={
'e': [self.echo_response_printer],
'r': [self.reset_response_printer]
},
prefix_receivers={
'v': [self.version_response_printer],
'l': [self.builtin_led_response_printer],
}
)
self.translator = BasicTranslator(
message_receivers=[self.response_dispatcher]
)
self.response_receiver = ResponseReceiver(
response_receivers=[self.translator]
)
self.transport_manager = TransportManager(
self.arbiter, transport_loop, response_receiver=self.response_receiver
)
self.translator.serialized_message_receivers.append(
self.transport_manager.command_sender
)
self.batch_execution_manager = BatchExecutionManager(
self.arbiter, self.transport_manager.command_sender, self.test_routine,
header=batch.OUTPUT_HEADER,
ready_waiter=self.transport_manager.connection_synchronizer.wait_connected
)
def __init__(self, transport_loop):
"""Initialize member variables."""
self.arbiter = arbiter(start=self._start, stopping=self._stop)
self.response_printer = MessagePrinter(prefix=('\t' *
cli.CONSOLE_WIDTH))
self.translator = BasicTranslator(
message_receivers=[self.response_printer])
self.response_receiver = ResponseReceiver(
response_receivers=[self.translator])
self.transport_manager = TransportManager(
self.arbiter,
transport_loop,
response_receiver=self.response_receiver)
self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
self.console_manager = ConsoleManager(
self.arbiter,
self.transport_manager.command_sender,
self.translator,
console_header=cli.CONSOLE_HEADER,
executor=self.executor,
ready_waiter=self.transport_manager.connection_synchronizer.
wait_connected)
def __init__(self, transport_loop):
"""Initialize member variables."""
self.arbiter = arbiter(start=self._start, stopping=self._stop)
self.echo_response_printer = MessagePrinter(
prefix=('\t' * cli.CONSOLE_WIDTH + '[Echo]\t'))
self.reset_response_printer = MessagePrinter(
prefix=('\t' * cli.CONSOLE_WIDTH + '[Reset]\t'))
self.version_response_printer = MessagePrinter(
prefix=('\t' * cli.CONSOLE_WIDTH + '[Version]\t'))
self.builtin_led_response_printer = MessagePrinter(
prefix=('\t' * cli.CONSOLE_WIDTH + '[BuiltinLED]\t'))
self.response_dispatcher = Dispatcher(
receivers={
'e': [self.echo_response_printer],
'r': [self.reset_response_printer]
},
prefix_receivers={
'v': [self.version_response_printer],
'l': [self.builtin_led_response_printer],
})
self.translator = BasicTranslator(
message_receivers=[self.response_dispatcher])
self.response_receiver = ResponseReceiver(
response_receivers=[self.translator])
self.transport_manager = TransportManager(
self.arbiter,
transport_loop,
response_receiver=self.response_receiver)
self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
self.console_manager = ConsoleManager(
self.arbiter,
self.transport_manager.command_sender,
self.translator,
console_header=cli.CONSOLE_HEADER,
executor=self.executor,
ready_waiter=self.transport_manager.connection_synchronizer.
wait_connected)
def __init__(self):
a = arbiter()
self._loop = a._loop
self._loop.call_later(1, self)
a.start()
from pulsar.api import arbiter, command, Config
names = ['john', 'luca', 'carl', 'jo', 'alex']
@command()
def greetme(request, message):
echo = 'Hello {}!'.format(message['name'])
request.actor.logger.warning(echo)
return echo
class Greeter:
def __call__(self, arb):
self._greater_task = arb._loop.create_task(self._work(arb))
async def _work(self, arb):
a = await arb.spawn(name='greeter')
while names:
name = names.pop()
await arb.send(a, 'greetme', {'name': name})
await asyncio.sleep(1)
arb.stop()
if __name__ == '__main__':
cfg = Config()
cfg.parse_command_line()
arbiter(cfg=cfg, start=Greeter()).start()
proxy = await spawn(name='actor1')
print(proxy.name)
# Execute inner method in actor1
result = await send(proxy, 'run', inner_method)
print(result)
await send(proxy, 'run', set_value, 10)
value = await send(proxy, 'run', get_value)
print(value)
# Stop the application
arbiter().stop()
def inner_method(actor):
return 42
def set_value(actor, value):
actor.saved_value = value
def get_value(actor):
return actor.saved_value
if __name__ == '__main__':
cfg = Config()
cfg.parse_command_line()
arbiter(cfg=cfg, start=start).start()
def __init__(self):
main_arbiter = arbiter()
self._loop = main_arbiter._loop # kod z przykladu w dokumentacji
self._loop.call_later(1, self)
main_arbiter.start()
def _initialize_arbiter(self):
arbiter(cfg=Config(workers=4, timeout=120))
arbiter().extra['gen'] = self._work_gen
self._arbiter_init_task()
arbiter()._loop.call_later(1, self)
arbiter().start()
import asyncio
import json
import logging
import pulsar.api as pulsar
import pulsar.apps.wsgi as wsgi
from pulsar.apps.wsgi import AccessControl
import classifier_managers.network_manager, classifier_managers.bayes_manager, classifier_managers.svm_manager
from data_provider import init_data_provider
app = wsgi.Router('/')
arbiter = pulsar.arbiter()
algorithm_opts = ['svm', 'bayes', 'network', 'all']
svm_manager_actor, bayes_manager_actor, network_manager_actor = None, None, None
data_provider = None
async def spawn_managers(algo='all'):
global arbiter, svm_manager_actor, bayes_manager_actor, network_manager_actor
if not svm_manager_actor and algo in ['svm', 'all']:
svm_manager_actor = await pulsar.spawn(name='svm_manager_actor',
aid='svm_manager_actor')
if not bayes_manager_actor and algo in ['bayes', 'all']:
bayes_manager_actor = await pulsar.spawn(name='bayes_manager_actor',
aid='bayes_manager_actor')
proxy = await spawn(name='actor1')
print(proxy.name)
# Execute inner method in actor1
result = await send(proxy, 'run', inner_method)
print(result)
await send(proxy, 'run', set_value, 10)
value = await send(proxy, 'run', get_value)
print(value)
# Stop the application
arbiter.stop()
def inner_method(actor):
return 42
def set_value(actor, value):
actor.saved_value = value
def get_value(actor):
return actor.saved_value
if __name__ == '__main__':
cfg = Config()
cfg.parse_command_line()
arbiter(cfg=cfg, start=start).start()
from pulsar.api import arbiter
from arbiter_control import *
if __name__ == '__main__':
arbiter(start=ArbiterControl()).start()
names = ['john', 'luca', 'carl', 'jo', 'alex']
@command()
def greetme(request, message):
echo = 'Hello {}!'.format(message['name'])
request.actor.logger.warning(echo)
return echo
class Greeter:
def __call__(self, arb):
self._greater_task = arb._loop.create_task(self._work(arb))
async def _work(self, arb):
a = await arb.spawn(name='greeter')
while names:
name = names.pop()
await arb.send(a, 'greetme', {'name': name})
await asyncio.sleep(1)
arb.stop()
if __name__ == '__main__':
cfg = Config()
cfg.parse_command_line()
arbiter(cfg=cfg, start=Greeter()).start()
'''Write Hello there! every second
'''
from pulsar.api import arbiter
def hello(actor, **kw):
print('Hello there!')
actor._loop.call_later(1, hello, actor)
if __name__ == '__main__':
arbiter(start=hello).start()