def run(self): """The actual thread code""" self._log.debug('Starting %s ' % self.name) self._running = True self._started = True job_info = None while not self._stop_event.isSet(): job_info = utils.q_get(self._job_queue, get_timeout=0.5) if job_info: self._execute_job(job_info) # Execute remaining jobs while True: job_info = utils.q_get(self._job_queue, get_timeout=0.5) if job_info: self._execute_job(job_info) else: break utils.wait(5) self._running = False #self._log.debug('Stopping %s ' % self.name) if self._exit_callback: self._exit_callback(self) self._log.debug('Exiting %s ' % self.name)
def read(self, read_timeout=0): """ Read from the console Return the console input or None """ if self._console_read_q is not None: return utils.q_get(self._console_read_q, get_timeout=read_timeout) else: utils.wait(read_timeout) return None
def _get_rpc_request(self, timeout=None): # Get size and marshalled request from server req = utils.q_get(self._read_q, get_timeout=timeout) if req is None: return None if len(req) < 2: self._log.error( 'RPCConnectionThread._get_rpc_request: Did not get both size bytes' ) return None size = ord(req[0]) * 256 + ord(req[1]) req = req[2:] while len(req) < size: chunk = utils.q_get(self._read_q, get_timeout=self._timeout) if chunk is None: self._log.error( 'RPCConnectionThread._get_rpc_request: timed out waiting for end of request' ) return None req += chunk args = marshal.loads(req) self._log.info('RPCConnectionThread._get_rpc_request: args = %s' % repr(args)) cmd_parts = [] for i, arg in enumerate(args): if i == 0: cmd_parts.append(''.join(['self._base_rpc_server.', arg, '('])) else: if i != 1: cmd_parts.append(', ') cmd_parts.append(arg) cmd_parts.append(')') cmd = ''.join(cmd_parts) self._log.info( 'RPCConnectionThread._get_rpc_request: returning command: %s' % cmd) return cmd
def run(self): """The actual thread code""" self._log.debug('Starting %s ' % self.name) self._running = True self._started = True while not self._stop_event.isSet(): data = utils.q_get(self._data_q, get_timeout=0.5) if data: #self._log.debug('ModemWriteThread sent a pkt') self._modem.write(data) self._running = False #self._log.debug('Stopping %s ' % self.name) self._log.debug('Exiting %s ' % self.name)
def _get_rpc_response(self): # Get size and marshalled response from server resp = utils.q_get(self._read_q, get_timeout=self._timeout) if resp is None: self._log.error( 'RPCServerProxy._get_rpc_response: timed out waiting for start of response' ) return None if len(resp) < 2: self._log.error( 'RPCServerProxy._get_rpc_response: Did not get both size bytes' ) return None size = ord(resp[0]) * 256 + ord(resp[1]) resp = resp[2:] while len(resp) < size: chunk = utils.q_get(self._read_q, get_timeout=self._timeout) if chunk is None: self._log.error( 'RPCServerProxy._get_rpc_response: timed out waiting for end of response' ) return None resp += chunk return marshal.loads(resp)
def run(self): """The actual thread code""" self._log.debug('Starting %s ' % self.name) self._running = True self._started = True while not self._stop_event.isSet(): pkt = utils.q_get(self._pkt_q, get_timeout=0.5) if pkt is not None: self._transmit_pkt(pkt) self._running = False #self._log.debug('Stopping %s ' % self.name) if self._exit_callback: self._exit_callback(self) self._log.debug('Exiting %s ' % self.name)
def run(self): """The actual thread code""" self._log.debug('Starting %s ' % self.name) self._running = True self._started = True while not self._stop_event.isSet(): if not self._proc_info.sock_h.is_running(): break s = utils.q_get(self._proc_info.sock_h.get_read_q(), get_timeout=0.5) if s: print s, self._running = False #self._log.debug('Stopping %s ' % self.name) self._log.debug('Exiting %s ' % self.name)
def run(self): """The actual thread code""" #self._log.debug('Starting %s' % self.name) try: self._sock.settimeout(0.5) except socket.error: # client disconnected self._stop_event.set() self._started = True self._running = True while not self._stop_event.isSet(): self._check_for_new_data_q() if self._data_q is None: # no data queue exists yet utils.wait(0.5) continue data = utils.q_get(self._data_q, get_timeout=1) if data is None: continue #self._log.debug('SockWriteThread: dequeued a %s' % repr(data)) startTime = datetime.now() # keep sending until all data is sent or timeout while data and (not self._stop_event.isSet()): while True: try: sent = self._sock.send(data[:ProxyPkt.MAX_PKT_LEN]) except OSError, e: if e.errno == EINTR: continue except socket.error: # client disconnected self._stop_event.set() break # out of while True break # out of while True if self._stop_event.isSet(): break #self._log.debug('SockWriteThread: Sent %s bytes to %s' % (str(sent), self._client)) data = data[sent:] elapsedTime = datetime.now() - startTime if elapsedTime > self._timeout: self._log.error('Timed out writing to %s' % self._peer_addr_port) self._stop_event.set() break
def run(self): """The actual thread code""" self._log.debug('Starting %s ' % self.name) self._running = True self._started = True while not self._stop_event.isSet(): if not self._sock_h.is_running(): self._stop_event.set() continue data = utils.q_get(self._stream_read_q, get_timeout=0.5) if data is not None: #self._log.debug('Packetize: received %s bytes' % str(len(data))) self._send_passthrough_pkts(data) self._running = False #self._log.debug('Stopping %s ' % self.name) if self._exit_callback: self._exit_callback(self) self._log.debug('Exiting %s ' % self.name)
def _readline(self, sock): """ Read a line ending with \n from sock. Return received line. Return None if shutdown is pending. """ timeout_secs = 2 max_rx_buf_len = 200 rx_buf = '' while not self._shut_down_is_pending(): rx_bytes = utils.q_get(self._sock_h.get_read_q(), timeout_secs) if rx_bytes is None: continue # timed out rx_buf += rx_bytes if rx_buf.endswith('\n'): return rx_buf if len(rx_buf) > max_rx_buf_len: self._log.error('Flushing _readline.rx_buf. Received "%s"' % rx_buf) rx_buf = '' return None
def run(self): """The actual thread code""" self._log.debug('Starting %s ' % self.name) self._running = True self._started = True while not self._stop_event.isSet(): if not self._sock_h.is_running(): self._log.debug( 'Depacketize: exiting because sock_h is not running') self._stop_event.set() continue #self._log.debug('Depacketize: polling queue %s' % repr(self._pkt_read_q)) pkt_buf = utils.q_get(self._pkt_read_q, get_timeout=0.5) if pkt_buf is None: continue #self._log.debug('Depacketize: got a pkt') pkt = ProxyPkt(pkt_buf) pkt_type = pkt.get_type() if pkt_type == ProxyPkt.PASSTHROUGH: #self._log.debug('Depacketize: a PASSTHROUGH pkt') self._send_stream_data(pkt) continue if pkt_type == ProxyPkt.CONNECT: # Got a CONNECT pkt from the other proxy. # Ignore since we are already connected. continue if pkt_type == ProxyPkt.DISCONNECT: # Got a DISCONNECT pkt from the other proxy self._log.debug('Depacketize: Got DISCONNECT') self._got_disconnect_pkt = True self._stop_event.set() self._log.debug( 'Depacketize: exiting because got a DISCONNECT') continue self._running = False #self._log.debug('Stopping %s ' % self.name) if self._exit_callback: self._exit_callback(self) self._log.debug('Exiting %s ' % self.name)
def run(self): """The actual thread code""" self._log.debug('Starting %s' % self.name) self._running = True self._started = True read_pkt_q = self._modem_svr_sock_h.get_read_q() write_pkt_q = self._modem_svr_sock_h.get_write_q() self._update_connected_flag() #self._log.debug('ModemSvrConnection: modem_svr_sock_h read q is %s' % repr(read_pkt_q)) #self._log.debug('ModemSvrConnection: modem_svr_sock_h write q is %s' % repr(write_pkt_q)) while not self._stop_event.isSet(): # If modem server connection is lost, exit thread if not self._modem_svr_sock_h.is_running(): self._stop_event.set() continue pkt_buf = utils.q_get(read_pkt_q, get_timeout=0.5) if pkt_buf: pkt = ProxyPkt(pkt_buf) #self._log.debug('ModemSvrConnection: received pkt') #self._log.debug(pkt.str()) pkt_type = pkt.get_type() if pkt_type == ProxyPkt.PING: #self._log.debug('Got a PING packet.') self._send_ping(write_pkt_q) continue if pkt_type == ProxyPkt.ICCID_REQ: self._xfer_rec.set_time(time.time()) self._send_iccid(write_pkt_q) continue if (pkt_type == ProxyPkt.PASSTHROUGH) or \ (pkt_type == ProxyPkt.DISCONNECT): self._xfer_rec.set_time(time.time()) self._children_lock.acquire() for ch in self._children: if (ch.get_server_port() == pkt.get_dest_port()) and \ (ch.get_client_port() == pkt.get_src_port()): ch.send(pkt) break self._children_lock.release() continue if pkt_type == ProxyPkt.CONNECT: self._xfer_rec.set_time(time.time()) self._log.debug('ModemSvrConnection: got CONNECT') sc = ServerConnection(write_pkt_q, pkt.get_dest_port(), pkt.get_src_port(), self._log, exit_callback=self._my_exit_callback) if sc.is_connected(): self._children_lock.acquire() self._children.append(sc) self._children_lock.release() self._running = False self._log.debug('Stopping %s' % self.name) self._update_disconnected_flag() for ch in self._children: ch.stop() self._log.debug('Exiting %s' % self.name)