def publishRoutedDeliverSmContent(self, routing_key, DeliverSM, msgid,
                                   scid, routedConnector):
     content = RoutedDeliverSmContent(DeliverSM, msgid, scid,
                                      routedConnector)
     yield self.amqpBroker.publish(exchange='messaging',
                                   routing_key=routing_key,
                                   content=content)
    def test_using_SmppServerSystemIdConnector_dc(self):
        dc = SmppServerSystemIdConnector('ghi')
        c = RoutedDeliverSmContent(self.body, self.msgid, self.scid, dc)

        self.assertEquals(pickle.loads(c.body), self.body)
        self.assertEquals(c['message-id'], self.msgid)
        self.assertEquals(c['headers']['src-connector-id'], self.scid)
        self.assertEquals(c['headers']['dst-connector-id'], dc.cid)

        dc = pickle.loads(c['headers']['dst-connector'])
        self.assertEquals(dc.cid, dc.cid)
    def test_using_HttpConnector_dc(self):
        dc = HttpConnector('def', 'http://127.0.0.1')
        c = RoutedDeliverSmContent(self.body, self.msgid, self.scid, dc)

        self.assertEquals(pickle.loads(c.body), self.body)
        self.assertEquals(c['message-id'], self.msgid)
        self.assertEquals(c['headers']['src-connector-id'], self.scid)
        self.assertEquals(c['headers']['dst-connector-id'], dc.cid)

        dc = pickle.loads(c['headers']['dst-connector'])
        self.assertEquals(dc.cid, dc.cid)
Beispiel #4
0
    def test_using_SmppServerSystemIdConnector_dc(self):
        dcs = [SmppServerSystemIdConnector('ghi')]
        c = RoutedDeliverSmContent(self.body, self.msgid, self.scid, dcs)

        self.assertEquals(pickle.loads(c.body), self.body)
        self.assertEquals(c['message-id'], self.msgid)
        self.assertEquals(c['headers']['src-connector-id'], self.scid)
        self.assertEquals(c['headers']['route-type'], 'simple')

        _dcs = pickle.loads(c['headers']['dst-connectors'])
        self.assertEquals(_dcs[0].cid, dcs[0].cid)
Beispiel #5
0
    def test_using_HttpConnector_dc(self):
        dcs = [HttpConnector('def', 'http://127.0.0.1')]
        c = RoutedDeliverSmContent(self.body, self.msgid, self.scid, dcs)

        self.assertEquals(pickle.loads(c.body), self.body)
        self.assertEquals(c['message-id'], self.msgid)
        self.assertEquals(c['headers']['src-connector-id'], self.scid)
        self.assertEquals(c['headers']['route-type'], 'simple')

        _dcs = pickle.loads(c['headers']['dst-connectors'])
        self.assertEquals(_dcs[0].cid, dcs[0].cid)
Beispiel #6
0
    def test_using_failover_route_type(self):
        dcs = [SmppServerSystemIdConnector('ghi'),SmppServerSystemIdConnector('ijk')]
        c = RoutedDeliverSmContent(self.body, self.msgid, self.scid, dcs, 'failover')

        self.assertEquals(pickle.loads(c.body), self.body)
        self.assertEquals(c['message-id'], self.msgid)
        self.assertEquals(c['headers']['src-connector-id'], self.scid)
        self.assertEquals(c['headers']['route-type'], 'failover')

        _dcs = pickle.loads(c['headers']['dst-connectors'])
        self.assertEquals(_dcs[0].cid, dcs[0].cid)
        self.assertEquals(len(_dcs), len(dcs))
Beispiel #7
0
    def deliver_sm_callback(self, message):
        """This callback is a queue listener
        It will only decide where to send the input message and republish it to the routedConnector
        The consumer will execute the remaining job of final delivery 
        c.f. test_router.DeliverSmDeliveryTestCases for use cases
        """
        msgid = message.content.properties['message-id']
        scid = message.content.properties['headers']['connector-id']
        concatenated = message.content.properties['headers']['concatenated']
        will_be_concatenated = message.content.properties['headers'][
            'will_be_concatenated']
        connector = Connector(scid)
        DeliverSmPDU = pickle.loads(message.content.body)
        self.log.debug(
            "Callbacked a deliver_sm with a DeliverSmPDU[%s] (?): %s" %
            (msgid, DeliverSmPDU))

        # @todo: Implement MO throttling here, same as in jasmin.managers.listeners.SMPPClientSMListener.submit_sm_callback
        self.deliver_sm_q.get().addCallback(
            self.deliver_sm_callback).addErrback(self.deliver_sm_errback)

        # Routing
        routable = RoutableDeliverSm(DeliverSmPDU, connector)
        route = self.getMORoutingTable().getRouteFor(routable)
        if route is None:
            self.log.debug(
                "No route matched this DeliverSmPDU with scid:%s and msgid:%s"
                % (scid, msgid))
            yield self.rejectMessage(message)
        else:
            # Get connector from selected route
            self.log.debug("RouterPB selected %s for this SubmitSmPDU" % route)
            routedConnector = route.getConnector()

            # Smpps will not route any concatenated content, it must instead route
            # multiparted messages
            # Only http connector needs concatenated content
            if concatenated and routedConnector.type != 'http':
                self.log.debug(
                    "DeliverSmPDU [msgid:%s] not routed because its content is concatenated and the routedConnector is not http: %s"
                    % (msgid, routedConnector.type))
                yield self.rejectMessage(message)

            # Http will not route any multipart messages, it must instead route
            # concatenated messages
            # Only smpps connector needs multipart content
            elif will_be_concatenated and routedConnector.type == 'http':
                self.log.debug(
                    "DeliverSmPDU [msgid:%s] not routed because there will be a one concatenated message for all parts: %s"
                    % (msgid))
                yield self.rejectMessage(message)

            else:
                self.log.debug(
                    "Connector '%s'(%s) is set to be a route for this DeliverSmPDU"
                    % (routedConnector.cid, routedConnector.type))
                yield self.ackMessage(message)

                # Enqueue DeliverSm for delivery through publishing it to deliver_sm_thrower.(type)
                content = RoutedDeliverSmContent(DeliverSmPDU, msgid, scid,
                                                 routedConnector)
                self.log.debug(
                    "Publishing RoutedDeliverSmContent [msgid:%s] in deliver_sm_thrower.%s with [dcid:%s]"
                    % (msgid, routedConnector.type, routedConnector.cid))
                yield self.amqpBroker.publish(
                    exchange='messaging',
                    routing_key='deliver_sm_thrower.%s' % routedConnector.type,
                    content=content)
Beispiel #8
0
    def deliver_sm_callback(self, message):
        """This callback is a queue listener
        It will only decide where to send the input message and republish it to the routedConnector
        The consumer will execute the remaining job of final delivery
        c.f. test_router.DeliverSmDeliveryTestCases for use cases
        """
        msgid = message.content.properties['message-id']
        scid = message.content.properties['headers']['connector-id']
        concatenated = message.content.properties['headers']['concatenated']
        will_be_concatenated = message.content.properties['headers']['will_be_concatenated']
        routable = pickle.loads(message.content.body)
        self.log.debug("Callbacked a deliver_sm with a DeliverSmPDU[%s] (?): %s", msgid, routable.pdu)

        # @todo: Implement MO throttling here, same as in
        # jasmin.managers.listeners.SMPPClientSMListener.submit_sm_callback
        self.deliver_sm_q.get().addCallback(self.deliver_sm_callback).addErrback(self.deliver_sm_errback)

        # Routing
        route = self.getMORoutingTable().getRouteFor(routable)
        if route is None:
            self.log.info("No route matched this DeliverSmPDU with scid:%s and msgid:%s", scid, msgid)
            yield self.rejectMessage(message)
        else:
            # Get connector from selected route
            self.log.debug("RouterPB selected %s for this SubmitSmPDU", route)
            if repr(route) == 'FailoverMORoute':
                # The failover route will return all connectors, we don't care about
                #   connectors statuses, this will be the thrower responsability
                routedConnectors = route.getConnectors()
                route_type = 'failover'
            else:
                routedConnectors = [route.getConnector()]
                route_type = 'simple'

            # Smpps will not route any concatenated content, it must instead route
            # multiparted messages
            # Only http connector needs concatenated content
            if concatenated and routedConnectors[0].type != 'http':
                self.log.debug(
                    "DeliverSmPDU [msgid:%s] not routed because its content is concatenated and the routedConnector is not http: %s",
                    msgid, routedConnectors[0].type)
                yield self.rejectMessage(message)

            # Http will not route any multipart messages, it must instead route
            # concatenated messages
            # Only smpps connector needs multipart content
            elif will_be_concatenated and routedConnectors[0].type == 'http':
                self.log.debug(
                    "DeliverSmPDU [msgid:%s] not routed because there will be a one concatenated message for all parts",
                    msgid)
                yield self.rejectMessage(message)

            else:
                if len(routedConnectors) == 1:
                    self.log.debug("Connector '%s'(%s) is set to be a route for this DeliverSmPDU",
                                   routedConnectors[0].cid, routedConnectors[0].type)
                else:
                    self.log.debug("%s %s connectors (failover route) are set to be a route for this DeliverSmPDU",
                                   len(routedConnectors), routedConnectors[0].type)
                yield self.ackMessage(message)

                # Enqueue DeliverSm for delivery through publishing it to deliver_sm_thrower.(type)
                content = RoutedDeliverSmContent(routable.pdu, msgid, scid, routedConnectors, route_type)
                self.log.debug("Publishing RoutedDeliverSmContent [msgid:%s] in deliver_sm_thrower.%s",
                               msgid, routedConnectors[0].type)
                yield self.amqpBroker.publish(exchange='messaging', routing_key='deliver_sm_thrower.%s' %
                                                                                routedConnectors[0].type,
                                              content=content)