def reconnect(self, address, bind_address=None): self.address = address if bind_address != self.uopts.laddress: self.uopts.laddress = bind_address self.worker.shutdown() self.worker = Udp_server(self.global_config, self.uopts) self.delay_flt = recfilter(0.95, 0.25)
def reconnect(self, address, bind_address=None): self.address = address if bind_address != self.bind_address: self.worker.shutdown() self.worker = Udp_server(self.global_config, bind_address, \ self.process_reply, flags = 0) self.bind_address = bind_address
def __init__(self, global_config, address, bind_address=None): self.address = address self.is_local = False self.worker = Udp_server(global_config, bind_address, \ self.process_reply, flags = 0) self.pending_requests = {} self.bind_address = bind_address self.global_config = global_config
def __init__(self, global_config, address, bind_address = None, nworkers = None): self.address = address self.is_local = False if nworkers == None: self.worker = Udp_server(global_config, bind_address, \ self.process_reply, flags = 0) else: self.worker = Udp_server(global_config, bind_address, \ self.process_reply, flags = 0, nworkers = nworkers) self.pending_requests = {} self.bind_address = bind_address self.global_config = global_config
class Rtp_proxy_client_udp(object): pending_requests = None is_local = False worker = None bind_address = None global_config = None def __init__(self, global_config, address, bind_address = None, nworkers = None): self.address = address self.is_local = False if nworkers == None: self.worker = Udp_server(global_config, bind_address, \ self.process_reply, flags = 0) else: self.worker = Udp_server(global_config, bind_address, \ self.process_reply, flags = 0, nworkers = nworkers) self.pending_requests = {} self.bind_address = bind_address self.global_config = global_config def send_command(self, command, result_callback = None, *callback_parameters): cookie = md5(str(random()) + str(time())).hexdigest() command = '%s %s' % (cookie, command) timer = Timeout(self.retransmit, 1, -1, cookie) self.pending_requests[cookie] = [3, timer, command, result_callback, callback_parameters] self.worker.send_to(command, self.address) def retransmit(self, cookie): triesleft, timer, command, result_callback, callback_parameters = self.pending_requests[cookie] if triesleft == 0: timer.cancel() del self.pending_requests[cookie] self.go_offline() if result_callback != None: result_callback(None, *callback_parameters) return self.worker.send_to(command, self.address) self.pending_requests[cookie][0] -= 1 def process_reply(self, data, address, worker): cookie, result = data.split(None, 1) parameters = self.pending_requests.pop(cookie, None) if parameters == None: return parameters[1].cancel() if parameters[3] != None: parameters[3](result.strip(), *parameters[4]) def reconnect(self, address, bind_address = None): self.address = address if bind_address != self.bind_address: self.worker.shutdown() self.worker = Udp_server(self.global_config, bind_address, \ self.process_reply, flags = 0) self.bind_address = bind_address def shutdown(self): self.worker.shutdown() self.worker = None
def __init__(self, global_config, address, bind_address=None, family=None, nworkers=None): self.address = address self.is_local = False self.uopts = Udp_server_opts(bind_address, self.process_reply, family) self.uopts.flags = 0 if nworkers != None: self.uopts.nworkers = nworkers self.worker = Udp_server(global_config, self.uopts) self.pending_requests = {} self.global_config = global_config self.delay_flt = recfilter(0.95, 0.25)
def reconnect(self, address, bind_address = None): self.address = address if bind_address != self.bind_address: self.worker.shutdown() self.worker = Udp_server(self.global_config, bind_address, \ self.process_reply, flags = 0) self.bind_address = bind_address
def __init__(self, global_config, handleIncoming): self.global_config = global_config self.cache_r2l = {} self.cache_r2l_old = {} self.cache_l2s = {} self.handleIncoming = handleIncoming try: # Python can be compiled with IPv6 support, but if kernel # has not we would get exception creating the socket. # Workaround that by trying create socket and checking if # we get an exception. socket.socket(socket.AF_INET6, socket.SOCK_DGRAM) except: socket.has_ipv6 = False if 'my' in dir(global_config['_sip_address']): if socket.has_ipv6: laddresses = (('0.0.0.0', global_config['_sip_port']), ('[::]', global_config['_sip_port'])) else: laddresses = (('0.0.0.0', global_config['_sip_port']), ) else: laddresses = ((global_config['_sip_address'], global_config['_sip_port']), ) self.fixed = True for laddress in laddresses: server = Udp_server(laddress, handleIncoming) self.cache_l2s[laddress] = server
def reconnect(self, address, bind_address = None): self.address = address if bind_address != self.uopts.laddress: self.uopts.laddress = bind_address self.worker.shutdown() self.worker = Udp_server(self.global_config, self.uopts) self.delay_flt = recfilter(0.95, 0.25)
class Rtp_proxy_client_udp(object): pending_requests = None is_local = False def __init__(self, global_config, address): self.address = address self.is_local = False self.udp_server = Udp_server(None, self.process_reply) self.pending_requests = {} self.proxy_address = address[0] def send_command(self, command, result_callback=None, *callback_parameters): cookie = md5(str(random()) + str(time())).hexdigest() command = '%s %s' % (cookie, command) timer = Timeout(self.retransmit, 1, -1, cookie) self.pending_requests[cookie] = [ 3, timer, command, result_callback, callback_parameters ] self.udp_server.send_to(command, self.address) def retransmit(self, cookie): triesleft, timer, command, result_callback, callback_parameters = self.pending_requests[ cookie] if triesleft == 0: timer.cancel() del self.pending_requests[cookie] self.go_offline() if result_callback != None: result_callback(None, *callback_parameters) return self.udp_server.send_to(command, self.address) self.pending_requests[cookie][0] -= 1 def process_reply(self, data, address, udp_server): cookie, result = data.split(None, 1) parameters = self.pending_requests.pop(cookie, None) if parameters == None: return parameters[1].cancel() if parameters[3] != None: parameters[3](result.strip(), *parameters[4])
def __init__(self, global_config, address, bind_address=None, family=AF_INET, nworkers=None): # print('Rtp_proxy_client_udp(family=%s)' % family) self.address = self.getdestbyaddr(address, family) self.is_local = False self.uopts = Udp_server_opts(bind_address, self.process_reply, family) self.uopts.flags = 0 self.uopts.ploss_out_rate = self.ploss_out_rate self.uopts.pdelay_out_max = self.pdelay_out_max if nworkers != None: self.uopts.nworkers = nworkers self.worker = Udp_server(global_config, self.uopts) self.pending_requests = {} self.global_config = global_config self.delay_flt = recfilter(0.95, 0.25)
def __init__(self, global_config, address, bind_address = None, family = None, nworkers = None): self.address = address self.is_local = False self.uopts = Udp_server_opts(bind_address, self.process_reply, family) self.uopts.flags = 0 if nworkers != None: self.uopts.nworkers = nworkers self.worker = Udp_server(global_config, self.uopts) self.pending_requests = {} self.global_config = global_config self.delay_flt = recfilter(0.95, 0.25)
def __init__(self, global_config, address, bind_address = None, family = AF_INET, nworkers = None): #print('Rtp_proxy_client_udp(family=%s)' % family) self.address = self.getdestbyaddr(address, family) self.is_local = False self.uopts = Udp_server_opts(bind_address, self.process_reply, family) self.uopts.flags = 0 self.uopts.ploss_out_rate = self.ploss_out_rate self.uopts.pdelay_out_max = self.pdelay_out_max if nworkers != None: self.uopts.nworkers = nworkers self.worker = Udp_server(global_config, self.uopts) self.pending_requests = {} self.global_config = global_config self.delay_flt = recfilter(0.95, 0.25)
def getServer(self, address, is_local=False): if self.fixed: return self.cache_l2s.items()[0][1] if not is_local: laddress = self.cache_r2l.get(address[0], None) if laddress == None: laddress = self.cache_r2l_old.get(address[0], None) if laddress != None: self.cache_r2l[address[0]] = laddress if laddress != None: #print 'local4remot-1: local address for %s is %s' % (address[0], laddress[0]) return self.cache_l2s[laddress] if address[0].startswith('['): family = socket.AF_INET6 lookup_address = address[0][1:-1] else: family = socket.AF_INET lookup_address = address[0] self.skt = socket.socket(family, socket.SOCK_DGRAM) ai = socket.getaddrinfo(lookup_address, None, family) if family == socket.AF_INET: _address = (ai[0][4][0], address[1]) else: _address = (ai[0][4][0], address[1], ai[0][4][2], ai[0][4][3]) self.skt.connect(_address) if family == socket.AF_INET: laddress = (self.skt.getsockname()[0], self.global_config['_sip_port']) else: laddress = ('[%s]' % self.skt.getsockname()[0], self.global_config['_sip_port']) self.cache_r2l[address[0]] = laddress else: laddress = address server = self.cache_l2s.get(laddress, None) if server == None: server = Udp_server(laddress, self.handleIncoming) self.cache_l2s[laddress] = server #print 'local4remot-2: local address for %s is %s' % (address[0], laddress[0]) return server
class Rtp_proxy_client_udp(object): pending_requests = None is_local = False worker = None uopts = None global_config = None delay_flt = None def __init__(self, global_config, address, bind_address=None, family=None, nworkers=None): self.address = address self.is_local = False self.uopts = Udp_server_opts(bind_address, self.process_reply, family) self.uopts.flags = 0 ##self.uopts.ploss_in_rate = 0.025 ##self.uopts.pdelay_out_max = 1.0 if nworkers != None: self.uopts.nworkers = nworkers self.worker = Udp_server(global_config, self.uopts) self.pending_requests = {} self.global_config = global_config self.delay_flt = recfilter(0.95, 0.025) def send_command(self, command, result_callback=None, *callback_parameters): cookie = md5(str(random()) + str(time())).hexdigest() next_retr = self.delay_flt.lastval * 4.0 rtime = 3.0 if isinstance(command, Rtp_proxy_cmd): if command.type == 'I': rtime = 10.0 if command.type == 'G': rtime = 1.0 nretr = command.nretr command = str(command) else: if command.startswith('I'): rtime = 10.0 elif command.startswith('G'): rtime = 1.0 nretr = None if nretr == None: nretr = getnretrans(next_retr, rtime) command = '%s %s' % (cookie, command) timer = Timeout(self.retransmit, next_retr, 1, cookie) stime = MonoTime() self.worker.send_to(command, self.address) nretr -= 1 self.pending_requests[cookie] = (next_retr, nretr, timer, command, result_callback, stime, callback_parameters) def retransmit(self, cookie): next_retr, triesleft, timer, command, result_callback, stime, callback_parameters = self.pending_requests[ cookie] #print 'command to %s timeout %s cookie %s triesleft %d' % (str(self.address), command, cookie, triesleft) if triesleft <= 0 or self.worker == None: del self.pending_requests[cookie] self.go_offline() if result_callback != None: result_callback(None, *callback_parameters) return #next_retr *= 2 timer = Timeout(self.retransmit, next_retr, 1, cookie) stime = MonoTime() self.worker.send_to(command, self.address) triesleft -= 1 self.pending_requests[cookie] = (next_retr, triesleft, timer, command, result_callback, stime, callback_parameters) def process_reply(self, data, address, worker, rtime): try: cookie, result = data.split(None, 1) except: print('Rtp_proxy_client_udp.process_reply(): invalid response %s' % data) return parameters = self.pending_requests.pop(cookie, None) if parameters == None: return next_retr, triesleft, timer, command, result_callback, stime, callback_parameters = parameters timer.cancel() if result_callback != None: result_callback(result.strip(), *callback_parameters) ##self.delay_flt.apply(rtime - stime) #print 'Rtp_proxy_client_udp.process_reply(): delay %f' % (rtime - stime) def reconnect(self, address, bind_address=None): self.address = address if bind_address != self.uopts.laddress: self.uopts.laddress = bind_address self.worker.shutdown() self.worker = Udp_server(self.global_config, self.uopts) self.delay_flt = recfilter(0.95, 0.25) def shutdown(self): self.worker.shutdown() self.worker = None def get_rtpc_delay(self): return self.delay_flt.lastval
def __init__(self, global_config, address): self.address = address self.is_local = False self.udp_server = Udp_server(None, self.process_reply) self.pending_requests = {} self.proxy_address = address[0]
def __init__(self, global_config, address): self.udp_server = Udp_server(None, self.process_reply) self.pending_requests = {} self.address = address self.proxy_address = address[0] self.heartbeat()
class Rtp_proxy_client_udp(object): udp_server = None pending_requests = None address = None online = False copy_supported = False stat_supported = False tnot_supported = False shutdown = False proxy_address = None caps_done = False def __init__(self, global_config, address): self.udp_server = Udp_server(None, self.process_reply) self.pending_requests = {} self.address = address self.proxy_address = address[0] self.heartbeat() def send_command(self, command, result_callback = None, *callback_parameters): cookie = md5(str(random()) + str(time())).hexdigest() command = '%s %s' % (cookie, command) timer = Timeout(self.retransmit, 1, -1, cookie) self.pending_requests[cookie] = [3, timer, command, result_callback, callback_parameters] self.udp_server.send_to(command, self.address) def retransmit(self, cookie): triesleft, timer, command, result_callback, callback_parameters = self.pending_requests[cookie] if triesleft == 0: timer.cancel() del self.pending_requests[cookie] self.online = False if result_callback != None: result_callback(None, *callback_parameters) return self.udp_server.send_to(command, self.address) self.pending_requests[cookie][0] -= 1 def process_reply(self, data, address, udp_server): cookie, result = data.split(None, 1) parameters = self.pending_requests.pop(cookie, None) if parameters == None: return parameters[1].cancel() if parameters[3] != None: parameters[3](result.strip(), *parameters[4]) def caps_query1(self, result): if self.shutdown: return if result != '1': if result != None: self.copy_supported = False self.stat_supported = False self.tnot_supported = False self.caps_done = True Timeout(self.heartbeat, 60) return self.copy_supported = True self.send_command('VF 20080403', self.caps_query2) def caps_query2(self, result): if self.shutdown: return if result != None: if result == '1': self.stat_supported = True self.send_command('VF 20081224', self.caps_query3) return else: self.stat_supported = False self.tnot_supported = False self.caps_done = True Timeout(self.heartbeat, 60) def caps_query3(self, result): if self.shutdown: return if result != None: if result == '1': self.tnot_supported = True else: self.tnot_supported = False self.caps_done = True Timeout(self.heartbeat, 60) def heartbeat(self): self.send_command('V', self.heartbeat_reply) def heartbeat_reply(self, version): if self.shutdown: return if version == '20040107': self.online = True if not self.caps_done: self.send_command('VF 20071218', self.caps_query1) return else: self.online = False Timeout(self.heartbeat, 60)
class Rtp_proxy_client_udp(object): pending_requests = None is_local = False worker = None uopts = None global_config = None delay_flt = None ploss_out_rate = 0.0 pdelay_out_max = 0.0 def __init__(self, global_config, address, bind_address = None, family = None, nworkers = None): self.address = address self.is_local = False self.uopts = Udp_server_opts(bind_address, self.process_reply, family) self.uopts.flags = 0 self.uopts.ploss_out_rate = self.ploss_out_rate self.uopts.pdelay_out_max = self.pdelay_out_max if nworkers != None: self.uopts.nworkers = nworkers self.worker = Udp_server(global_config, self.uopts) self.pending_requests = {} self.global_config = global_config self.delay_flt = recfilter(0.95, 0.25) def send_command(self, command, result_callback = None, *callback_parameters): cookie = md5(str(random()) + str(time())).hexdigest() next_retr = self.delay_flt.lastval * 4.0 exp_time = 3.0 if isinstance(command, Rtp_proxy_cmd): if command.type == 'I': exp_time = 10.0 if command.type == 'G': exp_time = 1.0 nretr = command.nretr command = str(command) else: if command.startswith('I'): exp_time = 10.0 elif command.startswith('G'): exp_time = 1.0 nretr = None if nretr == None: nretr = getnretrans(next_retr, exp_time) command = '%s %s' % (cookie, command) timer = Timeout(self.retransmit, next_retr, 1, cookie) preq = Rtp_proxy_pending_req(next_retr, nretr - 1, timer, command, \ result_callback, callback_parameters) self.worker.send_to(command, self.address) self.pending_requests[cookie] = preq def retransmit(self, cookie): preq = self.pending_requests[cookie] #print 'command to %s timeout %s cookie %s triesleft %d' % (str(self.address), preq.command, cookie, preq.triesleft) if preq.triesleft <= 0 or self.worker == None: del self.pending_requests[cookie] self.go_offline() if preq.result_callback != None: preq.result_callback(None, *preq.callback_parameters) return preq.retransmits += 1 preq.next_retr *= 2 preq.timer = Timeout(self.retransmit, preq.next_retr, 1, cookie) self.worker.send_to(preq.command, self.address) preq.triesleft -= 1 def go_offline(self): # To be replaced in the upper level class pass def process_reply(self, data, address, worker, rtime): try: cookie, result = data.split(None, 1) except: print('Rtp_proxy_client_udp.process_reply(): invalid response from %s: "%s"' % \ (str(address), data)) return preq = self.pending_requests.pop(cookie, None) if preq == None: return preq.timer.cancel() if rtime <= preq.stime: # MonoTime as the name suggests is supposed to be monotonic, # so if we get response earlier than request went out something # is very wrong. Fail immediately. rtime_fix = MonoTime() raise AssertionError('cookie=%s: MonoTime stale/went' \ ' backwards (%f <= %f, now=%f)' % (cookie, rtime.monot, \ preq.stime.monot, rtime_fix.monot)) if preq.result_callback != None: preq.result_callback(result.strip(), *preq.callback_parameters) # When we had to do retransmit it is not possible to figure out whether # or not this reply is related to the original request or one of the # retransmits. Therefore, using it to estimate delay could easily produce # bogus value that is too low or even negative if we cook up retransmit # while the original response is already in the queue waiting to be # processed. This should not be a big issue since UDP command channel does # not work very well if the packet loss goes to more than 30-40%. if preq.retransmits == 0: self.delay_flt.apply(rtime - preq.stime) #print 'Rtp_proxy_client_udp.process_reply(): delay %f' % (rtime - preq.stime) def reconnect(self, address, bind_address = None): self.address = address if bind_address != self.uopts.laddress: self.uopts.laddress = bind_address self.worker.shutdown() self.worker = Udp_server(self.global_config, self.uopts) self.delay_flt = recfilter(0.95, 0.25) def shutdown(self): self.worker.shutdown() self.worker = None def get_rtpc_delay(self): return self.delay_flt.lastval
class Rtp_proxy_client_udp(Rtp_proxy_client_net): pending_requests = None is_local = False worker = None uopts = None global_config = None delay_flt = None ploss_out_rate = 0.0 pdelay_out_max = 0.0 sock_type = SOCK_DGRAM def __init__(self, global_config, address, bind_address=None, family=AF_INET, nworkers=None): # print('Rtp_proxy_client_udp(family=%s)' % family) self.address = self.getdestbyaddr(address, family) self.is_local = False self.uopts = Udp_server_opts(bind_address, self.process_reply, family) self.uopts.flags = 0 self.uopts.ploss_out_rate = self.ploss_out_rate self.uopts.pdelay_out_max = self.pdelay_out_max if nworkers != None: self.uopts.nworkers = nworkers self.worker = Udp_server(global_config, self.uopts) self.pending_requests = {} self.global_config = global_config self.delay_flt = recfilter(0.95, 0.25) def send_command(self, command, result_callback=None, *callback_parameters): entropy = str(random()) + str(time()) cookie = md5(entropy.encode()).hexdigest() next_retr = self.delay_flt.lastval * 4.0 exp_time = 3.0 if isinstance(command, Rtp_proxy_cmd): if command.type == 'I': exp_time = 10.0 if command.type == 'G': exp_time = 1.0 nretr = command.nretr command = str(command) else: if command.startswith('I'): exp_time = 10.0 elif command.startswith('G'): exp_time = 1.0 nretr = None if nretr == None: nretr = getnretrans(next_retr, exp_time) command = '%s %s' % (cookie, command) timer = Timeout(self.retransmit, next_retr, 1, cookie) preq = Rtp_proxy_pending_req(next_retr, nretr - 1, timer, command, \ result_callback, callback_parameters) self.worker.send_to(command, self.address) self.pending_requests[cookie] = preq def retransmit(self, cookie): preq = self.pending_requests[cookie] # print('command to %s timeout %s cookie %s triesleft %d' % (str(self.address), preq.command, cookie, preq.triesleft)) if preq.triesleft <= 0 or self.worker == None: del self.pending_requests[cookie] self.go_offline() if preq.result_callback != None: preq.result_callback(None, *preq.callback_parameters) return preq.retransmits += 1 preq.next_retr *= 2 preq.timer = Timeout(self.retransmit, preq.next_retr, 1, cookie) self.worker.send_to(preq.command, self.address) preq.triesleft -= 1 def go_offline(self): # To be replaced in the upper level class pass def process_reply(self, data, address, worker, rtime): try: cookie, result = data.split(None, 1) except: print('Rtp_proxy_client_udp.process_reply(): invalid response from %s: "%s"' % \ (str(address), data)) return preq = self.pending_requests.pop(cookie, None) if preq == None: return preq.timer.cancel() if rtime <= preq.stime: # MonoTime as the name suggests is supposed to be monotonic, # so if we get response earlier than request went out something # is very wrong. Fail immediately. rtime_fix = MonoTime() raise AssertionError('cookie=%s: MonoTime stale/went' \ ' backwards (%f <= %f, now=%f)' % (cookie, rtime.monot, \ preq.stime.monot, rtime_fix.monot)) if preq.result_callback != None: preq.result_callback(result.strip(), *preq.callback_parameters) # When we had to do retransmit it is not possible to figure out whether # or not this reply is related to the original request or one of the # retransmits. Therefore, using it to estimate delay could easily produce # bogus value that is too low or even negative if we cook up retransmit # while the original response is already in the queue waiting to be # processed. This should not be a big issue since UDP command channel does # not work very well if the packet loss goes to more than 30-40%. if preq.retransmits == 0: self.delay_flt.apply(rtime - preq.stime) # print('Rtp_proxy_client_udp.process_reply(): delay %f' % (rtime - preq.stime)) def reconnect(self, address, bind_address=None): # print('reconnect', address) address = self.getdestbyaddr(address, self.uopts.family) self.rtpp_class._reconnect(self, address, bind_address) def _reconnect(self, address, bind_address=None): self.address = address if bind_address != self.uopts.laddress: self.uopts.laddress = bind_address self.worker.shutdown() self.worker = Udp_server(self.global_config, self.uopts) self.delay_flt = recfilter(0.95, 0.25) def shutdown(self): self.worker.shutdown() self.worker = None def get_rtpc_delay(self): return self.delay_flt.lastval
class Rtp_proxy_client_udp(object): pending_requests = None is_local = False worker = None uopts = None global_config = None delay_flt = None def __init__(self, global_config, address, bind_address = None, family = None, nworkers = None): self.address = address self.is_local = False self.uopts = Udp_server_opts(bind_address, self.process_reply, family) self.uopts.flags = 0 ##self.uopts.ploss_in_rate = 0.025 ##self.uopts.pdelay_out_max = 1.0 if nworkers != None: self.uopts.nworkers = nworkers self.worker = Udp_server(global_config, self.uopts) self.pending_requests = {} self.global_config = global_config self.delay_flt = recfilter(0.95, 0.025) def send_command(self, command, result_callback = None, *callback_parameters): cookie = md5(str(random()) + str(time())).hexdigest() next_retr = self.delay_flt.lastval * 4.0 rtime = 3.0 if isinstance(command, Rtp_proxy_cmd): if command.type == 'I': rtime = 10.0 if command.type == 'G': rtime = 1.0 nretr = command.nretr command = str(command) else: if command.startswith('I'): rtime = 10.0 elif command.startswith('G'): rtime = 1.0 nretr = None if nretr == None: nretr = getnretrans(next_retr, rtime) command = '%s %s' % (cookie, command) timer = Timeout(self.retransmit, next_retr, 1, cookie) stime = MonoTime() self.worker.send_to(command, self.address) nretr -= 1 self.pending_requests[cookie] = (next_retr, nretr, timer, command, result_callback, stime, callback_parameters) def retransmit(self, cookie): next_retr, triesleft, timer, command, result_callback, stime, callback_parameters = self.pending_requests[cookie] #print 'command to %s timeout %s cookie %s triesleft %d' % (str(self.address), command, cookie, triesleft) if triesleft <= 0 or self.worker == None: del self.pending_requests[cookie] self.go_offline() if result_callback != None: result_callback(None, *callback_parameters) return #next_retr *= 2 timer = Timeout(self.retransmit, next_retr, 1, cookie) stime = MonoTime() self.worker.send_to(command, self.address) triesleft -= 1 self.pending_requests[cookie] = (next_retr, triesleft, timer, command, result_callback, stime, callback_parameters) def process_reply(self, data, address, worker, rtime): try: cookie, result = data.split(None, 1) except: print('Rtp_proxy_client_udp.process_reply(): invalid response %s' % data) return parameters = self.pending_requests.pop(cookie, None) if parameters == None: return next_retr, triesleft, timer, command, result_callback, stime, callback_parameters = parameters timer.cancel() if result_callback != None: result_callback(result.strip(), *callback_parameters) ##self.delay_flt.apply(rtime - stime) #print 'Rtp_proxy_client_udp.process_reply(): delay %f' % (rtime - stime) def reconnect(self, address, bind_address = None): self.address = address if bind_address != self.uopts.laddress: self.uopts.laddress = bind_address self.worker.shutdown() self.worker = Udp_server(self.global_config, self.uopts) self.delay_flt = recfilter(0.95, 0.25) def shutdown(self): self.worker.shutdown() self.worker = None def get_rtpc_delay(self): return self.delay_flt.lastval