def endLongSubmitSmTransaction(self, _SMPPOutboundTxnResult):
reqPDU = _SMPPOutboundTxnResult.request
respPDU = _SMPPOutboundTxnResult.response
# Do we have txn with the given ref ?
if reqPDU.LongSubmitSm['msg_ref_num'] not in self.longSubmitSmTxns:
self.log.error(
'Received a submit_sm_resp in a unknown transaction with msg_ref_num [%s], open longSubmitSmTxns count: %s',
reqPDU.LongSubmitSm['msg_ref_num'], len(self.longSubmitSmTxns))
raise LongSubmitSmTransactionError(
'Received a submit_sm_resp in a unknown transaction with msg_ref_num [%s].'
% reqPDU.LongSubmitSm['msg_ref_num'])
# Decrement pending ACKs
if self.longSubmitSmTxns[
reqPDU.LongSubmitSm['msg_ref_num']]['nack_count'] > 0:
self.longSubmitSmTxns[
reqPDU.LongSubmitSm['msg_ref_num']]['nack_count'] -= 1
self.log.debug(
"Long submit_sm transaction with msg_ref_num %s has been updated, nack_count: %s",
reqPDU.LongSubmitSm['msg_ref_num'], self.longSubmitSmTxns[
reqPDU.LongSubmitSm['msg_ref_num']]['nack_count'])
# End the transaction if no more pending ACKs
if self.longSubmitSmTxns[
reqPDU.LongSubmitSm['msg_ref_num']]['nack_count'] == 0:
txn = self.closeLongSubmitSmTransaction(
reqPDU.LongSubmitSm['msg_ref_num'])
#Do callback
txn.ackDeferred.callback(
SMPPOutboundTxnResult(self, txn.request, respPDU))
def test_graceful_unbind(self):
smpp = self.getProtocolObject()
smpp.sendPDU = Mock()
smpp.sessionState = SMPPSessionStates.BOUND_TRX
#setup outbound txn
outPdu = SubmitSM(
seqNum=98790,
source_addr='mobileway',
destination_addr='1208230',
short_message='HELLO1',
)
outRespPdu = outPdu.requireAck(seqNum=outPdu.seqNum)
outDeferred = smpp.startOutboundTransaction(outPdu, 1)
#setup inbound txn
inPdu = DeliverSM(
seqNum=764765,
source_addr='mobileway',
destination_addr='1208230',
short_message='HELLO1',
)
inDeferred = smpp.startInboundTransaction(inPdu)
#Call unbind
unbindDeferred = smpp.unbind()
#Assert unbind request not sent and deferred not fired
self.assertEquals(0, smpp.sendPDU.call_count)
self.assertFalse(unbindDeferred.called)
#Simulate inbound txn finishing
smpp.endInboundTransaction(inPdu)
#Assert unbind request not sent and deferred not fired
self.assertEquals(0, smpp.sendPDU.call_count)
self.assertFalse(unbindDeferred.called)
#Simulate outbound txn finishing
smpp.endOutboundTransaction(outRespPdu)
#Assert unbind request was sent but deferred not yet fired
self.assertEquals(1, smpp.sendPDU.call_count)
sentPdu = smpp.sendPDU.call_args[0][0]
self.assertTrue(isinstance(sentPdu, Unbind))
self.assertFalse(unbindDeferred.called)
bindResp = UnbindResp(seqNum=sentPdu.seqNum)
#Simulate unbind_resp
smpp.endOutboundTransaction(bindResp)
#Assert unbind deferred fired
self.assertTrue(unbindDeferred.called)
self.assertTrue(isinstance(unbindDeferred.result, SMPPOutboundTxnResult))
expectedResult = SMPPOutboundTxnResult(smpp, sentPdu, bindResp)
self.assertEquals(expectedResult, unbindDeferred.result)
def endOutboundTransaction(self, respPDU):
txn = self.closeOutboundTransaction(respPDU.seqNum)
# Any status of a SubmitSMResp must be handled as a normal status
if isinstance(txn.request, SubmitSM) or respPDU.status == CommandStatus.ESME_ROK:
if not isinstance(respPDU, txn.request.requireAck):
txn.ackDeferred.errback(
SMPPProtocolError("Invalid PDU response type [%s] returned for request type [%s]" % (
type(respPDU), type(txn.request))))
return
#Do callback
txn.ackDeferred.callback(SMPPOutboundTxnResult(self, txn.request, respPDU))
return
if isinstance(respPDU, GenericNack):
txn.ackDeferred.errback(SMPPGenericNackTransactionError(respPDU, txn.request))
return
txn.ackDeferred.errback(SMPPTransactionError(respPDU, txn.request))
