def run(self): #print(self.run, 'enter') while True: #print(self.run, 'spin') self.userv.wi_available.acquire() while len(self.userv.wi) == 0: self.userv.wi_available.wait() wi = self.userv.wi.pop(0) if wi == None: # Shutdown request, relay it further self.userv.wi.append(None) self.userv.wi_available.notify() self.userv.wi_available.release() if wi == None: break command, result_callback, callback_parameters = wi try: data, rtpc_delay = self.send_raw(command) if len(data) == 0: data, rtpc_delay = None, None except Exception as e: dump_exception('Rtp_proxy_client_stream: unhandled exception I/O RTPproxy') data, rtpc_delay = None, None if result_callback != None: ED2.callFromThread(self.dispatch, result_callback, data, callback_parameters) if rtpc_delay != None: ED2.callFromThread(self.userv.register_delay, rtpc_delay) self.userv = None
def run(self): #print(self.run, 'enter') while True: #print(self.run, 'cycle') self.w_available.acquire() while self.wbuffer != None and len(self.wbuffer) == 0 and not self.close_pendind: self.w_available.wait() if self.wbuffer == None: self.w_available.release() break wbuffer = self.wbuffer if not self.close_pendind: self.wbuffer = bytes() else: self.wbuffer = None self.w_available.release() while True: res = self.clientsock.send(wbuffer) if res == len(wbuffer): break if res > 0: wbuffer = wbuffer[res:] if self.close_pendind: ED2.callFromThread(self.clim.shutdown) self.clim = None
def run(self): #print(self.run, 'enter') while True: #print(self.run, 'cycle') self.w_available.acquire() while self.wbuffer != None and len( self.wbuffer) == 0 and not self.close_pendind: self.w_available.wait() if self.wbuffer == None: self.w_available.release() break wbuffer = self.wbuffer if not self.close_pendind: self.wbuffer = bytes() else: self.wbuffer = None self.w_available.release() while True: res = self.clientsock.send(wbuffer) if res == len(wbuffer): break if res > 0: wbuffer = wbuffer[res:] if self.close_pendind: ED2.callFromThread(self.clim.shutdown) self.clim = None
def signal_handler(self, signum, *frame): ED2.callFromThread(self.dispatch) if self.previous_handler not in (SIG_IGN, SIG_DFL): try: self.previous_handler(signum, *frame) except: dump_exception('Signal: unhandled exception in signal chain')
def run(self): maxemptydata = 100 while True: try: data, address = self.userv.skt.recvfrom(8192) if not data and address == None: # Ugly hack to detect socket being closed under us on Linux. # The problem is that even call on non-closed socket can # sometimes return empty data buffer, making AsyncReceiver # to exit prematurely. maxemptydata -= 1 if maxemptydata == 0: break continue else: maxemptydata = 100 rtime = MonoTime() except Exception as why: if isinstance(why, socket.error) and why.errno in (ECONNRESET, ENOTCONN, ESHUTDOWN): break if isinstance(why, socket.error) and why.errno in (EINTR,): continue else: print(datetime.now(), 'Udp_server: unhandled exception when receiving incoming data') print('-' * 70) traceback.print_exc(file = sys.stdout) print('-' * 70) sys.stdout.flush() sleep(1) continue if self.userv.uopts.family == socket.AF_INET6: address = ('[%s]' % address[0], address[1]) ED2.callFromThread(self.userv.handle_read, data, address, rtime) self.userv = None
def run(self): #print(self.run, 'enter') while True: #print(self.run, 'spin') self.userv.wi_available.acquire() while len(self.userv.wi) == 0: self.userv.wi_available.wait() wi = self.userv.wi.pop(0) if wi == None: # Shutdown request, relay it further self.userv.wi.append(None) self.userv.wi_available.notify() self.userv.wi_available.release() if wi == None: break command, result_callback, callback_parameters = wi try: data, rtpc_delay = self.send_raw(command) if len(data) == 0: data, rtpc_delay = None, None except Exception as e: dump_exception( 'Rtp_proxy_client_stream: unhandled exception I/O RTPproxy' ) data, rtpc_delay = None, None if result_callback != None: ED2.callFromThread(self.dispatch, result_callback, data, callback_parameters) if rtpc_delay != None: ED2.callFromThread(self.userv.register_delay, rtpc_delay) self.userv = None
def _stop_play(self, rtpps, result_callback = None, index = 0): if not self.session_exists: ED2.callFromThread(rtpps.command_result, None, result_callback) return from_tag, to_tag = self.gettags(rtpps) command = 'S %s %s %s' % ('%s-%d' % (rtpps.call_id, index), from_tag, to_tag) rtpps.rtp_proxy_client.send_command(command, rtpps.command_result, result_callback)
def run(self): #print(self.run, 'enter') while True: #print(self.run, 'cycle') pollret = dict(self.pollobj.poll()).get(self.fileno, 0) if pollret & POLLNVAL != 0: break if pollret & POLLIN == 0: continue try: clientsock, addr = self.clicm.serversock.accept() except Exception as why: if isinstance(why, socket.error): if why.errno == ECONNABORTED: continue elif why.errno == EBADF: break else: raise dump_exception( 'CLIConnectionManager: unhandled exception when accepting incoming connection' ) break #print(self.run, 'handle_accept') ED2.callFromThread(self.clicm.handle_accept, clientsock, addr) self.clicm = None
def run(self): maxemptydata = 100 while True: try: data, address = self.userv.skt.recvfrom(8192) if not data and address == None: # Ugly hack to detect socket being closed under us on Linux. # The problem is that even call on non-closed socket can # sometimes return empty data buffer, making AsyncReceiver # to exit prematurely. maxemptydata -= 1 if maxemptydata == 0: break continue else: maxemptydata = 100 rtime = MonoTime() except Exception as why: if isinstance(why, socket.error) and why[0] in (ECONNRESET, ENOTCONN, ESHUTDOWN): break if isinstance(why, socket.error) and why[0] in (EINTR,): continue else: print(datetime.now(), 'Udp_server: unhandled exception when receiving incoming data') print('-' * 70) traceback.print_exc(file = sys.stdout) print('-' * 70) sys.stdout.flush() sleep(1) continue if self.userv.uopts.family == socket.AF_INET6: address = ('[%s]' % address[0], address[1]) ED2.callFromThread(self.userv.handle_read, data, address, rtime) self.userv = None
def _play(self, rtpps, prompt_name, times = 1, result_callback = None, index = 0): if not self.session_exists: ED2.callFromThread(rtpps.command_result, None, result_callback) return otherside = self.getother(rtpps) if not otherside.session_exists: otherside.update(rtpps, '0.0.0.0', 0, self.__play, '', index, 'IP4', prompt_name, times, result_callback, index) return self.__play(None, rtpps, prompt_name, times, result_callback, index)
def requestCallback(self, resp, *args, **kwargs): query = parse_qs(resp.url) param = { query['state'][0]: resp.text, "url": resp.url, "diff": round(time.time() * 1000) - self.time_invite } print('threading.currentThread =>', threading.currentThread().ident) ED2.callFromThread(self.createUa0, param)
def run(self): need_close_fds = True if platform == 'win32': need_close_fds = False pipe = Popen(self.command, shell = False, stdin = PIPE, \ stdout = PIPE, stderr = PIPE, close_fds = need_close_fds) while True: self.master.work_available.acquire() while len(self.master.work) == 0: self.master.work_available.wait() wi = self.master.work.pop(0) if wi == None: # Shutdown request, relay it further self.master.work.append(None) self.master.work_available.notify() self.master.work_available.release() if wi == None: break if wi.is_cancelled(): wi.data = None wi.result_callback = None wi.callback_parameters = None continue batch = [x + b'\n' for x in wi.data] batch.append(b'\n') pipe.stdin.writelines(batch) pipe.stdin.flush() result = [] while True: try: line = pipe.stdout.readline().strip() except IOError as e: # Catch EINTR if e.args[0] != EINTR: raise e continue if len(line) == 0: break result.append(line) ED2.callFromThread(self.master.process_result, wi.result_callback, tuple(result), *wi.callback_parameters) wi.data = None wi.result_callback = None wi.callback_parameters = None
def run(self): need_close_fds = True if platform == 'win32': need_close_fds = False pipe = Popen(self.command, shell = False, stdin = PIPE, \ stdout = PIPE, stderr = PIPE, close_fds = need_close_fds) while True: self.master.work_available.acquire() while len(self.master.work) == 0: self.master.work_available.wait() wi = self.master.work.pop(0) if wi == None: # Shutdown request, relay it further self.master.work.append(None) self.master.work_available.notify() self.master.work_available.release() if wi == None: break if wi.is_cancelled(): wi.data = None wi.result_callback = None wi.callback_parameters = None continue batch = [x + b'\n' for x in wi.data] batch.append(b'\n') pipe.stdin.writelines(batch) pipe.stdin.flush() result = [] while True: try: line = pipe.stdout.readline().strip() except IOError as e: # Catch EINTR if e.args[0] != EINTR: raise e continue if len(line) == 0: break result.append(line) ED2.callFromThread(self.master.process_result, wi.result_callback, tuple(result), *wi.callback_parameters) wi.data = None wi.result_callback = None wi.callback_parameters = None
def run(self): #print(self.run, 'enter') while True: #print(self.run, 'cycle') pollret = dict(self.pollobj.poll()).get(self.fileno, 0) if pollret & POLLNVAL != 0: break if pollret & POLLIN == 0: continue try: clientsock, addr = self.clicm.serversock.accept() except Exception as why: if isinstance(why, socket.error): if why.errno == ECONNABORTED: continue elif why.errno == EBADF: break else: raise dump_exception('CLIConnectionManager: unhandled exception when accepting incoming connection') break #print(self.run, 'handle_accept') ED2.callFromThread(self.clicm.handle_accept, clientsock, addr) self.clicm = None
def run(self): rbuffer = '' while True: data = self.clientsock.recv(1024) if len(data) == 0: ED2.callFromThread(self.clim.shutdown) break try: rbuffer += data.decode('ascii') except UnicodeDecodeError: ED2.callFromThread(self.clim.shutdown) break while rbuffer.find('\n') != -1: cmd, rbuffer = rbuffer.split('\n', 1) cmd = cmd.strip() if len(cmd) == 0: continue ED2.callFromThread(self.clim.handle_cmd, cmd) self.clim = None
def run(self): rbuffer = '' while True: data = self.clientsock.recv(1024) if len(data) == 0: ED2.callFromThread(self.clim.shutdown) break try: rbuffer += data.decode('ascii') except UnicodeDecodeError: ED2.callFromThread(self.clim.shutdown) break while rbuffer.find('\n') != -1: cmd, rbuffer = rbuffer.split('\n', 1) cmd = cmd.strip() if len(cmd) == 0: continue ED2.callFromThread(self.clim.handle_cmd, cmd) self.clim = None
def __del__(self): if self.my_ident != get_ident(): #print 'Rtp_proxy_session.__del__() from wrong thread, re-routing' ED2.callFromThread(self.delete) else: self.delete()
def __del__(self): if self.my_ident != get_ident(): #print 'Rtp_proxy_session.__del__() from wrong thread, re-routing' ED2.callFromThread(self.delete) else: self.delete()
def run(self): rfile = None session_timeout = self.default_timeout ctime = None count = 0 port = Serial(self.sdev, baudrate = self.brate, timeout=0.1) while True: try: data = port.read(256) except Exception as e: self.lfile.write('Session exception: %s\n' % str(e)) self.lfile.flush() if rfile != None: #rfile.flush() rfile.close() rfile = None sleep(1) port = Serial(self.sdev, baudrate = self.brate, timeout=0.1) continue atime = time() if rfile != None and atime - ctime > session_timeout: self.lfile.write('Session timeout: %f\n' % (atime - ctime)) self.lfile.flush() #rfile.flush() rfile.close() rfile = None if self.send_cb != None: ED2.callFromThread(self.send_cb) self.enqueue_cb_lock.acquire() self.enqueue_cb = None self.enqueue_cb_lock.release() self.prequeue = [] if len(data) == 0: continue previous_ctime = ctime ctime = atime if rfile == None: fname = '/tmp/%s.csv' % int(ctime) rfile = open(fname, 'w') session_timeout = self.default_timeout previous_ctime = None count = 0 self.lfile.write('Starting recording %s\n' % fname) self.lfile.flush() if self.sstart_cb != None: ED2.callFromThread(self._sstart_cb) if previous_ctime != None and session_timeout > (ctime - previous_ctime) * 2 and count > 2: session_timeout = (ctime - previous_ctime) * 2 self.lfile.write(' Updating session timeout to %f sec\n' % session_timeout) self.lfile.flush() parts = [x.strip() for x in data.decode('ascii').split(' ', 3)] try: volts = float(parts[1][:-1]) amps = float(parts[2][:-1]) except: count += 1 continue pload = '%d,%f,%f' % (count, volts, amps) rfile.write('%s\n' % pload) pload = pload.encode() self.enqueue_cb_lock.acquire() if self.enqueue_cb != None: self.enqueue_cb(pload) else: self.prequeue.append(pload) self.enqueue_cb_lock.release() #rfile.flush() count += 1