Beispiel #1
0
    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), )
Beispiel #2
0
    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")
Beispiel #3
0
    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"
                  )  # Python3
            return False

        return True