def receiveMessage(self, msg, sender):
"""
Handle a message on receipt. The message sender is used to
receive the results of any additional request
:param msg: The message received
:type msg: Message
:param sender: The message sender
:type sender: BaseActor
"""
try:
if isinstance(msg, Pull):
batch_size = msg.payload
self.on_next(batch_size, msg.sender)
elif isinstance(msg, Push):
self.handle_batch(msg)
elif isinstance(msg, SetSubscriber):
self.set_subscriber(msg, sender)
elif isinstance(msg, SetDropPolicy):
self.set_drop_policy(msg, sender)
elif isinstance(msg, GetDropPolicy):
self.get_drop_policy(msg, sender)
elif isinstance(msg, Peek):
self.peek(msg, sender)
elif isinstance(msg, Cancel):
self.cancel()
except Exception:
handle_actor_system_fail()
def receiveMessage(self, msg, sender):
"""
Receive a message.
:param msg: The Message
:type msg: Message
:param sender: The message sender
:type sender: BaseActor()
"""
try:
if isinstance(msg, RouteAsk):
sender = msg.sender
msg = msg.payload
if sender:
val = self.on_receive(msg, sender)
self.send(sender, val)
elif msg.sender:
val = self.on_receive(msg, msg.sender)
self.send(msg.sender, val)
elif isinstance(msg, RouteTell):
self.on_receive(msg, msg.sender)
elif isinstance(msg, Broadcast):
payload = msg.payload
sender = msg.sender
self.on_receive(payload, sender)
except Exception as e:
handle_actor_system_fail()
def handle_push(self, msg, sender):
"""
Handle a push on the result queue.
:param msg: The message to handle
:type msg: Message
:param sender: The sender
:type sender: BaseActor
"""
batch = msg.payload
if isinstance(batch, list):
for res in batch:
if self.get_result_q().full():
if self.__drop_policy == "pop":
try:
self.get_result_q().get_nowait()
except:
handle_actor_system_fail()
if self.get_result_q().full() is False:
self.get_result_q().put_nowait(res)
sp = None
for sub in self.get_subscriptions():
if sub.subscription == sender:
sp = sub
if sp:
if len(batch) is 0:
sp.rate = max([sp.rate - 1, 0])
else:
sp.rate = min([sp.rate + 1, sp.default_rate])
def receiveMessage(self, msg, sender):
"""
Handle message on receipt.
:param msg: The message to handle
:type msg: Message
:param sender: The sender
:tpye sender: BaseActor
"""
try:
if isinstance(msg, Subscribe):
sub = msg.payload
self.subscribe(sub)
elif isinstance(msg, DeSubscribe):
sub = msg.payload
self.remove_subscription(sub)
elif isinstance(msg, Pull):
self.next(msg, sender)
elif isinstance(msg, Push):
self.handle_push(msg, sender)
elif isinstance(msg, Cancel):
self.cancel(msg)
elif isinstance(msg, GetDropPolicy):
self.get_drop_policy(msg, sender)
elif isinstance(msg, GetSubscribers):
self.get_subscribers(msg, sender)
except Exception:
handle_actor_system_fail()
def receiveMessage(self, msg, sender):
"""
Handle the incoming messages
:param msg: The incoming message
:type msg: Message()
:param sender: The sender
:type sender: Actor
"""
try:
self.check_message_and_sender(msg, sender)
if isinstance(msg, Subscribe):
self.handle_subscription(msg, sender)
elif isinstance(msg, RouteAsk) or isinstance(msg, RouteTell):
self.handle_message(msg, sender)
elif isinstance(msg, DeSubscribe):
self.handle_desubscribe(msg, sender)
elif isinstance(msg, Broadcast):
self.handle_broadcast(msg, sender)
elif isinstance(msg, GetNumRoutees):
self.handle_get_num_actors(msg, sender)
else:
self.handle_unexpected_message(msg, sender)
except:
handle_actor_system_fail()
def handle_get_num_actors(self, msg, sender):
"""
Get the number of actors in the router
"""
try:
self.send(sender, len(self.__actor_set))
except:
handle_actor_system_fail()
def desubscribe(self, subscription):
"""
DeSubscribe a subscription actor
:param subscription: The actor to use
:type subscription: Subscription
"""
try:
if isinstance(subscription, Subscription):
sub = DeSubscribe(subscription, self.__pool, self.myAddress)
self.send(self.__pool, sub)
except Exception:
handle_actor_system_fail()
def handle_desubscribe(self, msg, sender):
"""
Handle a desubscription message.
:param msg: The Message to handle
:type msg: Message()
:param sender: Sender of a Desubscribe message
:type sender: Actor()
"""
try:
if isinstance(msg, DeSubscribe):
payload = msg.payload
self.de_subscribe(payload)
except:
handle_actor_system_fail()
def receiveMessage(self, msg, sender):
try:
if isinstance(msg, Subscribe):
payload = msg.payload
self.__subpool = payload
elif isinstance(msg, Pull):
payload_size = msg.payload
self.send(sender, Push(self.results, sender, self.myAddress))
self.results = []
self.send(self.__subpool,
Pull(payload_size, self.__subpool, self.myAddress))
elif isinstance(msg, Push):
payload = msg.payload
self.results.extend(payload)
except Exception:
handle_actor_system_fail()
def next(self, msg, sender):
"""
Get the next n elements in the batch.
:param msg: The message to handle
:type msg: Message
:param sender: The message sender
:type sender: BaseActor
"""
if msg.sender:
sender = msg.sender
batch_size = msg.payload
batch = []
rq = super().get_result_q()
pull_size = 0
if batch_size > 0:
if rq.empty() is False:
i = 0
while rq.empty() is False and i < batch_size:
try:
pull_size += 1
val = rq.get_nowait()
batch.append(val)
except Exception:
handle_actor_system_fail()
finally:
i += 1
msg = Push(batch, sender, self)
self.send(sender, msg)
subs = self.get_subscriptions()
if pull_size > 0:
if subs and len(subs) > 0:
if self.__index >= len(subs):
self.__index = 0
sub = subs[self.__index]
self.__index += 1
msg = Pull(pull_size, sub, self.myAddress)
self.send(sub, msg)
elif rq.empty() and len(subs) > 0:
def_q_size = self.get_default_queue_size()
pull_size = int(def_q_size / len(subs))
for sub in subs:
msg = Pull(pull_size, sub, self.myAddress)
self.send(sub, msg)
def next(self, msg, sender):
"""
Get the next n elements in the batch.
:param msg: The message to handle
:type msg: Message
:param sender: The sender
:type sender: BaseActor
"""
if msg.sender:
sender = msg.sender
batch_size = msg.payload
batch = []
rq = super().get_result_q()
pull_size = 0
if batch_size > 0:
if rq.empty() is False:
i = 0
while rq.empty() is False and i < batch_size:
try:
pull_size += 1
val = rq.get_nowait()
batch.append(val)
except Exception:
handle_actor_system_fail()
finally:
i += 1
msg = Push(batch, sender, self)
self.send(sender, msg)
subs = self.get_subscriptions()
if pull_size > 0:
if len(self.__priority_queue) == 0:
self.remake_priority_queue()
sub = self.__priority_queue.pop(0)
outsub = sub.subscription
self.__waiting_queue.append(sub)
msg = Pull(pull_size, self)
self.send(outsub, msg)
elif rq.empty() and len(subs) > 0:
pull_size = int(self.get_default_queue_size() / len(subs))
for sub in subs:
outsub = sub.subscription
msg = Pull(pull_size, outsub, self.myAddress)
self.send(outsub, msg)
def receiveMessage(self, msg, sender):
"""
Handle a message receipt
:param msg: The message to handle
:type msg: Message
:param sender: The message sender
:type sender: BaseActor
"""
super().receiveMessage(self, msg, sender)
try:
if isinstance(msg, Pull):
self.on_pull(msg, sender)
elif isinstance(msg, Push):
self.on_push(msg, sender)
elif isinstance(msg, SetDropPolicy):
self.set_drop_policy(msg, sender)
except Exception:
handle_actor_system_fail()
def on_push(self, msg, sender):
"""
Handle the push message.
:param msg: The message to handle on push
:type msg: Message
:param sender: The sender of the message
:type sender: BaseActor
"""
payload = msg.payload
if isinstance(payload, list):
for res in payload:
if self.queue.full() is True:
if self.__drop_policy == "pop":
try:
self.queue.get_nowait()
except Exception:
handle_actor_system_fail()
if self.queue.full() is False:
self.queue.put_nowait(res)
def handle_broadcast(self, msg, sender):
"""
Handle a message.
:param msg: Message to support
:type msg: Message()
:param sender: The sender to build
:type sender: Actor()
"""
try:
if isinstance(msg, Broadcast):
payload = msg.payload()
if payload and isinstance(payload, Message):
for actor in self.__actor_set:
self.send(actor, msg)
else:
err_msg = "Broadcast Requires Message Payload"
err_msg = format_send_receive_error(err_msg, sender, self)
raise ValueError(err_msg)
except:
handle_actor_system_fail()
def receiveMessage(self, msg, sender):
"""
Handle message on receipt.
:param msg: The message received
:type msg: Message
:param sender: The sender of the message
:type sender: BaseActor
"""
try:
if isinstance(msg, Subscribe):
actor = msg.payload
self.subscribe(actor)
elif isinstance(msg, DeSubscribe):
actor = msg.payload
self.desubscribe(actor)
elif isinstance(msg, SetPublisher):
self.set_publisher(msg, sender)
elif isinstance(msg, SetDropPolicy):
self.set_drop_policy(msg, sender)
except Exception:
handle_actor_system_fail()
def next(self, msg, sender):
"""
Get the next batch
:param msg: The message
:type msg: Message
:param sender: The message sender
:type sender: BaseActor
"""
if msg.sender:
sender = msg.sender
batch_size = msg.payload
batch = []
rq = self.get_result_q()
pull_size = 0
if rq.empty() is False:
while rq.empty() is False and pull_size < batch_size:
try:
val = rq.get_nowait()
batch.append(val)
pull_size += 1
except Exception:
handle_actor_system_fail()
msg = Push(batch, sender, self)
self.send(sender, msg)
subs = self.get_subscriptions()
if pull_size > 0:
if len(self.__avail) == 0:
self.__remake_available()
sub = self.__avail.pop(0)
subscription = sub.subscription
msg = Pull(pull_size, subscription, self.myAddress)
self.send(subscription, msg)
elif rq.empty() and len(subs) > 0:
pull_size = int(500 / len(subs))
for sub in subs:
subscription = sub.subscription
msg = Pull(pull_size, subscription, self.myAddress)
self.send(subscription, msg)
def receiveMessage(self, msg, sender):
"""
Handle a message.
:param msg: Handle a receive message
:type msg: Message
:param sender: The message sender
:type sender: BaseActor
"""
try:
if isinstance(msg, PullBySubscription):
self.on_pull(msg, sender)
elif isinstance(msg, Push):
self.on_push(msg, sender)
elif isinstance(msg, SetPublisher):
self.set_publisher(msg, sender)
elif isinstance(msg, SubscribeWithLogic):
self.subscribe(msg, sender)
elif isinstance(msg, DeSubscribe):
subscription = msg.payload
self.desubscribe(subscription)
except Exception:
handle_actor_system_fail()
def receiveMessage(self, msg, sender):
try:
if isinstance(msg, Pull):
self.next(msg, sender)
except Exception:
handle_actor_system_fail()
def receiveMessage(self, msg, sender):
super().receiveMessage(self, msg, sender)
try:
pass
except Exception:
handle_actor_system_fail()
