def subscribe(cls, connection, subscription):
if connection == None:
raise custom_exceptions.PubsubException("Subscriber not connected")
key = subscription.get_key()
session = ConnectionRegistry.get_session(connection)
if session == None:
raise custom_exceptions.PubsubException("No session found")
subscription.connection_ref = weakref.ref(connection)
session.setdefault('subscriptions', {})
if key in session['subscriptions']:
raise custom_exceptions.AlreadySubscribedException(
"This connection is already subscribed for such event.")
session['subscriptions'][key] = subscription
cls.__subscriptions.setdefault(subscription.event,
weakref.WeakKeyDictionary())
cls.__subscriptions[subscription.event][subscription] = None
if hasattr(subscription, 'after_subscribe'):
if connection.on_finish != None:
# If subscription is processed during the request, wait to
# finish and then process the callback
connection.on_finish.addCallback(subscription.after_subscribe)
else:
# If subscription is NOT processed during the request (any real use case?),
# process callback instantly (better now than never).
subscription.after_subscribe(True)
# List of 2-tuples is prepared for future multi-subscriptions
return ((subscription.event, key, subscription), )
def subscribe(cls, connection, subscription):
if connection == None:
raise custom_exceptions.PubsubException("Subscriber not connected")
key = subscription.get_key()
session = ConnectionRegistry.get_session(connection)
if session == None:
raise custom_exceptions.PubsubException("No session found")
subscription.connection_ref = weakref.ref(connection)
session.setdefault('subscriptions', {})
if key in session['subscriptions']:
raise custom_exceptions.AlreadySubscribedException("This connection is already subscribed for such event.")
session['subscriptions'][key] = subscription
cls.__subscriptions.setdefault(subscription.event, weakref.WeakKeyDictionary())
cls.__subscriptions[subscription.event][subscription] = None
if hasattr(subscription, 'after_subscribe'):
if connection.on_finish != None:
# If subscription is processed during the request, wait to
# finish and then process the callback
connection.on_finish.addCallback(subscription.after_subscribe)
else:
# If subscription is NOT processed during the request (any real use case?),
# process callback instantly (better now than never).
subscription.after_subscribe(True)
# List of 2-tuples is prepared for future multi-subscriptions
return ((subscription.event, key, subscription),)
def subscribe(cls, connection, subscription):
if connection is None:
raise PubsubException("Subscriber not connected")
key = subscription.get_key()
session = ConnectionRegistry.get_session(connection)
if session is None:
raise PubsubException("No session found")
subscription.connection_ref = weakref.ref(connection)
session.setdefault("subscriptions", {})
if key in session["subscriptions"]:
raise AlreadySubscribed("This connection is already subscribed")
session["subscriptions"][key] = subscription
cls.__subscriptions.setdefault(subscription.event,
weakref.WeakKeyDictionary())
cls.__subscriptions[subscription.event][subscription] = None
if hasattr(subscription, "after_subscribe"):
if connection.on_finish is not None:
# If subscription is processed during the request, wait to finish
# and then process the callback
connection.on_finish.addCallback(subscription.after_subscribe)
else:
# If subscription is not processed during the request, process callback
# instantly
subscription.after_subscribe(True)
return ((subscription.event, key), )
def get_subscription(cls, connection, event, key=None):
'''Return subscription object for given connection and event'''
session = ConnectionRegistry.get_session(connection)
if session == None:
raise custom_exceptions.PubsubException("No session found")
if key == None:
sub = [ sub for sub in session.get('subscriptions', {}).values() if sub.event == event ]
try:
return sub[0]
except IndexError:
raise custom_exceptions.PubsubException("Not subscribed for event %s" % event)
else:
raise Exception("Searching subscriptions by key is not implemented yet")
def get_subscription(cls, connection, event, key=None):
"""Return subscription object for given connection and event"""
session = ConnectionRegistry.get_session(connection)
if session is None:
raise PubsubException("No session found")
if key is None:
sub = [
sub for sub in session.get("subscriptions", {}).values()
if sub.event == event
]
try:
return sub[0]
except IndexError:
raise PubsubException(f"Not subscribed for event {event}")
def unsubscribe(cls, connection, subscription=None, key=None):
if connection == None:
raise custom_exceptions.PubsubException("Subscriber not connected")
session = ConnectionRegistry.get_session(connection)
if session == None:
raise custom_exceptions.PubsubException("No session found")
if subscription:
key = subscription.get_key()
try:
# Subscription don't need to be removed from cls.__subscriptions,
# because it uses weak reference there.
del session['subscriptions'][key]
except KeyError:
print "Warning: Cannot remove subscription from connection session"
return False
return True
def get_subscription(cls, connection, event, key=None):
'''Return subscription object for given connection and event'''
session = ConnectionRegistry.get_session(connection)
if session == None:
raise custom_exceptions.PubsubException("No session found")
if key == None:
sub = [
sub for sub in session.get('subscriptions', {}).values()
if sub.event == event
]
try:
return sub[0]
except IndexError:
raise custom_exceptions.PubsubException(
"Not subscribed for event %s" % event)
else:
raise Exception(
"Searching subscriptions by key is not implemented yet")
def unsubscribe(cls, connection, subscription=None, key=None):
if connection == None:
raise custom_exceptions.PubsubException("Subscriber not connected")
session = ConnectionRegistry.get_session(connection)
if session == None:
raise custom_exceptions.PubsubException("No session found")
if subscription:
key = subscription.get_key()
try:
# Subscription don't need to be removed from cls.__subscriptions,
# because it uses weak reference there.
del session['subscriptions'][key]
except KeyError:
print "Warning: Cannot remove subscription from connection session"
return False
return True
def unsubscribe(cls, connection, subscription=None, key=None):
if connection is None:
raise PubsubException("Subscriber not connected")
session = ConnectionRegistry.get_session(connection)
if session is None:
raise PubsubException("No session found")
if subscription:
key = subscription.get_key()
try:
# Subscription do not need to be remoived from cls.__subscriptions,
# because it uses weak reference
del session["subscriptions"][key]
except KeyError:
logger.warning(
"Cannot remove subscriptions from connection session")
return False
return True
