Beispiel #1
0
 def __init__(self, rremain):
     self.rcodes = []
     self.rremain = rremain
     self.nsent = 0
     global_config = {}
     self.prand_cid = pickrandom(kind = 'call_id')
     self.prand_tags = pickrandom(kind = 'to_from_tags')
     self.rtppc = Rtp_proxy_client_local(global_config, \
       address = '/var/run/rtpproxy.sock', nworkers = 2)
Beispiel #2
0
 def __init__(self, rremain):
     self.rcodes = []
     self.rremain = rremain
     self.nsent = 0
     global_config = {}
     self.prand_cid = pickrandom(kind="call_id")
     self.prand_tags = pickrandom(kind="to_from_tags")
     self.rtppc = Rtp_proxy_client_local(global_config, address="/var/run/rtpproxy.sock")
Beispiel #3
0
from twisted.internet import reactor

import sys
sys.path.append('~/projects/sippy.git')

from sippy.Rtp_proxy_client_local import Rtp_proxy_client_local

def caps_query2(rval, res_res):
    res_res.rcodes.append(rval)
    #print 'caps_query2:', res_res
    res_res.rremain -= 1
    if res_res.rremain == 0:
        reactor.stop()

global_config = {}
rtppc = Rtp_proxy_client_local(global_config, address = '/var/run/rtpproxy.sock')
res = []

class res(object):
    rcodes = None
    rremain = None

    def __init__(self, rremain):
        self.rcodes = []
        self.rremain = rremain

rres = res(0)
for command in INVALID_CMDS:
    command += ' aVF 20080403'
    rres.rremain += 1
    rtppc.send_command(command, caps_query2, rres)
Beispiel #4
0
class res(object):
    rcodes = None
    rremain = None
    nsent = None
    rtppc = None
    prand_cid = None
    prand_tags = None

    def __init__(self, rremain):
        self.rcodes = []
        self.rremain = rremain
        self.nsent = 0
        global_config = {}
        self.prand_cid = pickrandom(kind="call_id")
        self.prand_tags = pickrandom(kind="to_from_tags")
        self.rtppc = Rtp_proxy_client_local(global_config, address="/var/run/rtpproxy.sock")

    def issue_command(self):
        call_id = self.prand_cid.get()
        ftag = self.prand_tags.get()
        ttag = self.prand_tags.get()
        sd = sess_data()
        sd.command_u = CMD_TEMPLATE_U % (call_id, self.nsent + 1000, ftag)
        sd.command_l = CMD_TEMPLATE_L % (call_id, self.nsent + 2000, ftag, ttag)
        self.rtppc.send_command(sd.command_u, self.rtpp_reply_u, sd)
        # print command

    def rtpp_reply_u(self, rval, sdata):
        # print 'rtpp_reply'
        if rval == "E72":
            print "bingo 1"
            Timeout(self.issue_command, 3 * random())
            return
        if rval == None or rval.startswith("E"):
            print ("error: %s" % str(rval))
            reactor.stop()
            return

        self.rcodes.append(rval)
        self.issue_command_l(sdata)

    def issue_command_l(self, sdata):
        self.rtppc.send_command(sdata.command_l, self.rtpp_reply_l, sdata)
        # print command
        self.nsent += 1

    def rtpp_reply_l(self, rval, sdata):
        # print 'rtpp_reply'
        if rval == "E71":
            print "bingo 2"
            Timeout(self.issue_command_l, 2 * random(), 1, sdata)
            return
        if rval == None or rval.startswith("E"):
            print ("error: %s" % str(rval))
            reactor.stop()
            return

        self.rcodes.append(rval)
        self.rremain -= 1
        if self.rremain == 0:
            reactor.stop()
        self.issue_command()
Beispiel #5
0
class res(object):
    rcodes = None
    rremain = None
    nsent = None
    rtppc = None
    prand_cid = None
    prand_tags = None

    def __init__(self, rremain):
        self.rcodes = []
        self.rremain = rremain
        self.nsent = 0
        global_config = {}
        self.prand_cid = pickrandom(kind = 'call_id')
        self.prand_tags = pickrandom(kind = 'to_from_tags')
        self.rtppc = Rtp_proxy_client_local(global_config, \
          address = '/var/run/rtpproxy.sock', nworkers = 2)
        #self.rtppc = Rtp_proxy_client_udp(global_config, \
        #  address = ('127.0.0.1', 1234), nworkers = 2)

    def issue_command(self):
        call_id = self.prand_cid.get()
        ftag = self.prand_tags.get()
        ttag = self.prand_tags.get()
        sd = sess_data()
        sd.command_u = CMD_TEMPLATE_U % (call_id, self.nsent + 1000, ftag)
        sd.command_l = CMD_TEMPLATE_L % (call_id, self.nsent + 2000, ftag, ttag)
        sd.command_d_c = CMD_TEMPLATE_D_C % (call_id, ftag)
        sd.command_d_b1 = CMD_TEMPLATE_D_B % (call_id, ftag, ttag)
        sd.command_d_b2 = CMD_TEMPLATE_D_B % (call_id, ttag, ftag)
        self.rtppc.send_command(sd.command_u, self.rtpp_reply_u, sd)
        #print command

    def rtpp_reply_u(self, rval, sdata):
        #print 'rtpp_reply'
        if rval == 'E72':
            print 'bingo 1'
            Timeout(self.issue_command, 3 * random())
            return
        if rval == None or rval.startswith('E'):
            print ('rtpp_reply_u: error: %s, original command: %s' % \
              (str(rval), sdata.command_u))
            reactor.stop()
            return

        self.rcodes.append(rval)

        if random() < 0.1:
             Timeout(self.issue_command_d, 10 * random(), 1, sdata.command_d_c)
             self.issue_command()
        else:
             self.issue_command_l(sdata)

    def issue_command_l(self, sdata):
        self.rtppc.send_command(sdata.command_l, self.rtpp_reply_l, sdata)
        #print command
        self.nsent += 1

    def rtpp_reply_l(self, rval, sdata):
        #print 'rtpp_reply', sdata
        if rval == 'E71':
            print 'bingo 2'
            Timeout(self.issue_command_l, 2 * random(), 1, sdata)
            return
        if rval == None or rval.startswith('E'):
            print ('rtpp_reply_l: error: %s, original command: %s' % \
              (str(rval), sdata.command_l))
            reactor.stop()
            return

        if random() > 0.5:
            # let 50% of the sessions timeout, disconnect the rest after
            # 8.5-58.5 seconds explicitly
            tout = 8.5 + (50.0 * random())
            if random() > 0.5:
                Timeout(self.issue_command_d, tout, 1, sdata.command_d_b1)
            else:
                Timeout(self.issue_command_d, tout, 1, sdata.command_d_b2)
        self.rcodes.append(rval)
        self.rremain -= 1
        if self.rremain == 0:
            reactor.stop()
        self.issue_command()

    def issue_command_d(self, command_d):
        self.rtppc.send_command(command_d, self.rtpp_reply_d, command_d)

    def rtpp_reply_d(self, rval, command_d):
        if rval != '0':
            print ('rtpp_reply_d: error: %s, original command: %s' % \
              (str(rval), command_d))
            reactor.stop()
            return
Beispiel #6
0
class res(object):
    rcodes = None
    rremain = None
    nsent = None
    rtppc = None
    prand_cid = None
    prand_tags = None

    def __init__(self, rremain):
        self.rcodes = []
        self.rremain = rremain
        self.nsent = 0
        global_config = {}
        self.prand_cid = pickrandom(kind='call_id')
        self.prand_tags = pickrandom(kind='to_from_tags')
        self.rtppc = Rtp_proxy_client_local(global_config,
                                            address='/var/run/rtpproxy.sock')

    def issue_command(self):
        call_id = self.prand_cid.get()
        ftag = self.prand_tags.get()
        ttag = self.prand_tags.get()
        sd = sess_data()
        sd.command_u = CMD_TEMPLATE_U % (call_id, self.nsent + 1000, ftag)
        sd.command_l = CMD_TEMPLATE_L % (call_id, self.nsent + 2000, ftag,
                                         ttag)
        self.rtppc.send_command(sd.command_u, self.rtpp_reply_u, sd)
        #print command

    def rtpp_reply_u(self, rval, sdata):
        #print 'rtpp_reply'
        if rval == 'E72':
            print 'bingo 1'
            Timeout(self.issue_command, 3 * random())
            return
        if rval == None or rval.startswith('E'):
            print('error: %s' % str(rval))
            reactor.stop()
            return

        self.rcodes.append(rval)
        self.issue_command_l(sdata)

    def issue_command_l(self, sdata):
        self.rtppc.send_command(sdata.command_l, self.rtpp_reply_l, sdata)
        #print command
        self.nsent += 1

    def rtpp_reply_l(self, rval, sdata):
        #print 'rtpp_reply'
        if rval == 'E71':
            print 'bingo 2'
            Timeout(self.issue_command_l, 2 * random(), 1, sdata)
            return
        if rval == None or rval.startswith('E'):
            print('error: %s' % str(rval))
            reactor.stop()
            return

        self.rcodes.append(rval)
        self.rremain -= 1
        if self.rremain == 0:
            reactor.stop()
        self.issue_command()