def send(self, data, flags=0, timeout=timeout_default): if timeout is timeout_default: timeout = self.timeout if self._sslobj: if flags != 0: raise ValueError( "non-zero flags not allowed in calls to send() on %s" % self.__class__) while True: try: v = self._sslobj.write(data) except SSLError, x: if x.args[0] == SSL_ERROR_WANT_READ: if self.timeout == 0.0: raise timeout(str(x)) sys.exc_clear() wait_read(self.fileno(), timeout=timeout) elif x.args[0] == SSL_ERROR_WANT_WRITE: if self.timeout == 0.0: raise timeout(str(x)) sys.exc_clear() wait_write(self.fileno(), timeout=timeout) else: raise else: return v
def write(self, data): """Write DATA to the underlying SSL channel. Returns number of bytes of DATA actually transmitted.""" while True: try: return self._sslobj.write(data) except SSLError, ex: if ex.args[0] == SSL_ERROR_WANT_READ: if self.timeout == 0.0: raise sys.exc_clear() try: wait_read(self.fileno(), timeout=self.timeout, timeout_exc=_SSLErrorWriteTimeout, event=self._read_event) except socket_error, ex: if ex[0] == EBADF: return 0 raise elif ex.args[0] == SSL_ERROR_WANT_WRITE: if self.timeout == 0.0: raise sys.exc_clear() try: wait_write(self.fileno(), timeout=self.timeout, timeout_exc=_SSLErrorWriteTimeout, event=self._write_event) except socket_error, ex: if ex[0] == EBADF: return 0 raise
def read(self, len=1024): """Read up to LEN bytes and return them. Return zero-length string on EOF.""" while True: try: return self._sslobj.read(len) except SSLError, ex: if ex.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs: return '' elif ex.args[0] == SSL_ERROR_WANT_READ: if self.timeout == 0.0: raise sys.exc_clear() try: wait_read(self.fileno(), timeout=self.timeout, timeout_exc=_SSLErrorReadTimeout, event=self._read_event) except socket_error, ex: if ex[0] == EBADF: return '' raise elif ex.args[0] == SSL_ERROR_WANT_WRITE: if self.timeout == 0.0: raise sys.exc_clear() try: # note: using _SSLErrorReadTimeout rather than _SSLErrorWriteTimeout below is intentional wait_write(self.fileno(), timeout=self.timeout, timeout_exc=_SSLErrorReadTimeout, event=self._write_event) except socket_error, ex: if ex[0] == EBADF: return '' raise
def send(self, data, flags=0, timeout=timeout_default): if timeout is timeout_default: timeout = self.timeout if self._sslobj: if flags != 0: raise ValueError( "non-zero flags not allowed in calls to send() on %s" % self.__class__) while True: try: v = self._sslobj.write(data) except SSLError, x: if x.args[0] == SSL_ERROR_WANT_READ: if self.timeout == 0.0: return 0 sys.exc_clear() try: wait_read(self.fileno(), timeout=timeout, event=self._read_event) except socket_error, ex: if ex[0] == EBADF: return 0 raise elif x.args[0] == SSL_ERROR_WANT_WRITE: if self.timeout == 0.0: return 0 sys.exc_clear() try: wait_write(self.fileno(), timeout=timeout, event=self._write_event) except socket_error, ex: if ex[0] == EBADF: return 0 raise
def _sslobj_shutdown(self): while True: try: return self._sslobj.shutdown() except SSLError, ex: if ex.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs: return '' elif ex.args[0] == SSL_ERROR_WANT_READ: if self.timeout == 0.0: raise sys.exc_clear() try: wait_read(self.fileno(), timeout=self.timeout, timeout_exc=_SSLErrorReadTimeout, event=self._read_event) except socket_error, ex: if ex[0] == EBADF: return '' raise elif ex.args[0] == SSL_ERROR_WANT_WRITE: if self.timeout == 0.0: raise sys.exc_clear() try: wait_write(self.fileno(), timeout=self.timeout, timeout_exc=_SSLErrorWriteTimeout, event=self._write_event) except socket_error, ex: if ex[0] == EBADF: return '' raise
def _gevent_sendfile(fdout, fdin, offset, nbytes): while True: try: return os.sendfile(fdout, fdin, offset, nbytes) except OSError as e: if e.args[0] == errno.EAGAIN: socket.wait_write(fdout) else: raise
def _gevent_sendfile(fdout, fdin, offset, nbytes): while True: try: return o_sendfile(fdout, fdin, offset, nbytes) except OSError as e: if e.args[0] == errno.EAGAIN: wait_write(fdout) else: raise
def popenNonblock(args, data='', stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=None, logFile=None): """Communicate with the process non-blockingly. If logFile is defined print the process's output line by line to that file """ if logFile: f = open(logFile, 'a') stdout = f stderr = f p = subprocess.Popen(args, stdin=stdin, stdout=stdout, stderr=stderr, cwd=cwd) real_stdin = p.stdin if stdin == subprocess.PIPE else stdin fcntl.fcntl(real_stdin, fcntl.F_SETFL, os.O_NONBLOCK) # make the file nonblocking real_stdout = p.stdout if stdout == subprocess.PIPE else stdout fcntl.fcntl(real_stdout, fcntl.F_SETFL, os.O_NONBLOCK) # make the file nonblocking if data: bytes_total = len(data) bytes_written = 0 while bytes_written < bytes_total: try: # p.stdin.write() doesn't return anything, so use os.write. bytes_written += os.write(p.stdin.fileno(), data[bytes_written:]) except IOError: ex = sys.exc_info()[1] if ex.args[0] != errno.EAGAIN: raise sys.exc_clear() socket.wait_write(p.stdin.fileno()) p.stdin.close() chunks = [] if stdout == subprocess.PIPE: while True: try: chunk = p.stdout.read(4096) if not chunk: break chunks.append(chunk) except IOError: ex = sys.exc_info()[1] if ex[0] != errno.EAGAIN: raise sys.exc_clear() socket.wait_read(p.stdout.fileno()) p.stdout.close() output = ''.join(chunks) while True: returncode = p.poll() if returncode is not None: break else: gevent.sleep(1) return (returncode, output)
def __iowait(self, io_func, *args, **kwargs): fd = self._sock.fileno() timeout = self._sock.gettimeout() while True: try: return io_func(*args, **kwargs) except (OpenSSL.SSL.WantReadError, OpenSSL.SSL.WantX509LookupError): wait_read(fd, timeout=timeout) except OpenSSL.SSL.WantWriteError: wait_write(fd, timeout=timeout)
def _send_copy(self, msg, flags=0): flags |= __zmq__.NOBLOCK while True: try: super(Socket, self)._send_copy(msg, flags) return except __zmq__.ZMQError, e: if e.errno != EAGAIN: raise wait_write(self.getsockopt(__zmq__.FD))
def _gevent_sendfile(fdout, fdin, offset, nbytes): while True: try: return os.sendfile(fdout, fdin, offset, nbytes) except OSError as e: if e.args[0] == errno.EAGAIN: # Block the current greenlet until *fileno* is ready to write socket.wait_write(fdout) else: raise
def writer(self, f, queue): fd = f.fileno() while self.running: data = queue.get() total = len(data) while total > 0: socket.wait_write(fd) total -= os.write(fd, data)
def push_statsd_metrics(): collector = StatsdCollector(Collector(conn)) while True: try: sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) for line in collector.collect(): socket.wait_write(sock.fileno()) sock.sendto(six.b(line), (args.statsd_host, args.statsd_port)) except Exception as e: logging.getLogger('vadvisor').error(e) sleep(args.statsd_interval)
def wait_callback(conn, timeout=None): while 1: state = conn.poll() if state == extensions.POLL_OK: return elif state == extensions.POLL_READ: socket.wait_read(conn.fileno(), timeout=timeout) elif state == extensions.POLL_WRITE: socket.wait_write(conn.fileno(), timeout=timeout) else: raise psycopg2.OperationalError("Bad result from poll: %r" % state)
def do_handshake(self): while True: try: _Connection.do_handshake(self) break except WantReadError: exc_clear() wait_read(self._sock.fileno(), timeout=self._timeout) except WantWriteError: exc_clear() wait_write(self._sock.fileno(), timeout=self._timeout)
def wait_callback(conn, timeout=None): while True: state = conn.poll() if state == POLL_OK: break elif state == POLL_READ: wait_read(conn.fileno(), timeout=timeout) elif state == POLL_WRITE: wait_write(conn.fileno(), timeout=timeout) else: raise psycopg2.OperationalError("Bad result from poll: %r" % state)
def connect(self, *args, **kwargs): while True: try: self._connection.connect(*args, **kwargs) break except (WantReadError, WantX509LookupError): sys.exc_clear() wait_read(self._sock.fileno(), timeout=self._timeout) except WantWriteError: sys.exc_clear() wait_write(self._sock.fileno(), timeout=self._timeout)
def connect(self, *args, **kwargs): while True: try: _Connection.connect(self, *args, **kwargs) break except WantReadError: exc_clear() wait_read(self._sock.fileno(), timeout=self._timeout) except WantWriteError: exc_clear() wait_write(self._sock.fileno(), timeout=self._timeout)
def _psycopg_gevent_wait(conn, timeout=None): while True: state = conn.poll() if state == extensions.POLL_OK: break elif state == extensions.POLL_READ: wait_read(conn.fileno(), timeout=timeout) elif state == extensions.POLL_WRITE: wait_write(conn.fileno(), timeout=timeout) else: raise psycopg2.OperationalError("Bad result from poll: %r" % state)
def send_loop(self): while self.state == AsyncTCPClient.CONNECTED_STATE: try: msg = self.msg_queue.get(timeout=1) except gevent.queue.Empty: continue try: socket.wait_write(self.sock.fileno(), timeout=1) self.sock.sendall(str(msg)) except _socket.error: continue
def feed(self, data): """ Write input data into the file descriptor. :param data: New data from the user :type data: string """ wait_write(self.fd) self.stream_out.write(data.encode('utf-8')) self.stream_out.flush()
def write(self, data): while len(data) > 0: try: bytes_written = os.write(self._fd, data) data = data[bytes_written:] except OSError as e: if e.errno == errno.EPIPE: self.close() raise IOError(e) if e.errno != errno.EAGAIN: raise wait_write(self._fd)
def send_with_fd(dest_sock, message, subject_fd): buf = ffi.new('char[]', message) dest_fd = dest_sock.fileno() while 1: ret = C.send_with_fd(dest_fd, buf, len(message), subject_fd) if ret >= 0: break if -ret in (errno.EPERM, errno.EWOULDBLOCK, errno.EAGAIN): socket.wait_write(dest_fd) else: raise os.error(-ret, os.strerror(-ret)) return ret
def write(self, data): if data: bytes_total = len(data) bytes_written = 0 while bytes_written < bytes_total: try: bytes_written += os.write(self.fileno(), data[bytes_written:]) except IOError, ex: if ex[0] != errno.EAGAIN: raise sys.exc_clear() socket.wait_write(self.fileno())
def async_sendfile(fdout, fdin, offset, nbytes): total_sent = 0 while total_sent < nbytes: try: sent = sendfile(fdout, fdin, offset + total_sent, nbytes - total_sent) total_sent += sent except OSError, e: if e.args[0] == errno.EAGAIN: wait_write(fdout) else: raise
def gevent_wait_callback(conn, timeout=None): """A wait callback useful to allow gevent to work with Psycopg.""" while 1: state = conn.poll() if state == extensions.POLL_OK: break elif state == extensions.POLL_READ: wait_read(conn.fileno(), timeout=timeout) elif state == extensions.POLL_WRITE: wait_write(conn.fileno(), timeout=timeout) else: raise psycopg2.OperationalError("Bad result from poll: %r" % state)
def _gevent_wait_callback(conn, timeout=None): # From https://github.com/gevent/gevent/blob/master/examples/psycopg2_pool.py#L19 while 1: state = conn.poll() if state == extensions.POLL_OK: break elif state == extensions.POLL_READ: wait_read(conn.fileno(), timeout=timeout) elif state == extensions.POLL_WRITE: wait_write(conn.fileno(), timeout=timeout) else: raise OperationalError('Bad result from poll: %r' % state)
def wait_callback(conn, timeout=None): while 1: state = conn.poll() if state == extensions.POLL_OK: return elif state == extensions.POLL_READ: socket.wait_read(conn.fileno(), timeout=timeout) elif state == extensions.POLL_WRITE: socket.wait_write(conn.fileno(), timeout=timeout) else: raise psycopg2.OperationalError( "Bad result from poll: %r" % state)
def gevent_sendfile(out_fd, in_fd, offset, count): total_sent = 0 while total_sent < count: try: _offset, sent = original_sendfile(out_fd, in_fd, offset + total_sent, count - total_sent) #print '%s: sent %s [%d%%]' % (out_fd, sent, 100*total_sent/count) total_sent += sent except OSError, ex: if ex[0] == EAGAIN: wait_write(out_fd) else: raise
def gevent_wait_callback(conn, timeout=None): """A wait callback useful to allow gevent to work with Psycopg.""" while 1: state = conn.poll() if state == extensions.POLL_OK: break elif state == extensions.POLL_READ: wait_read(conn.fileno(), timeout=timeout) elif state == extensions.POLL_WRITE: wait_write(conn.fileno(), timeout=timeout) else: raise OperationalError("Bad result from poll: %r" % state)
def send(self, data): """Writes raw outgoing data. Blocks until done.""" if isinstance(data, unicode): data = data.encode('utf-8') elif not isinstance(data, str): data = str(data) socket.wait_write(self._sock.fileno()) try: self._sock.sendall(data) logger.debug('sent: %s' % str(data).decode('utf-8')) except (socket_error, IOError): logger.debug('disconnected from server') raise
def _write_pipe(self, f, input): # writes the given input to f without blocking if input: bytes_total = len(input) bytes_written = 0 while bytes_written < bytes_total: try: # f.write() doesn't return anything, so use os.write. bytes_written += os.write(f.fileno(), input[bytes_written:]) except IOError, ex: if ex[0] != errno.EAGAIN: raise sys.exc_clear() socket.wait_write(f.fileno())
def send_ack(self): """ Send the SIP ACK as a notification that the MCU SDP offer is accepted by the browser. """ reply = "ACK " + self.contact + " SIP/2.0\r\n" + \ "Via: SIP/2.0/TCP " + self.hostname + ":" + str(self.port) + ";rport;branch=z9hG4bK1465117333\r\n" + \ "Max-Forwards: 70\r\n" + \ "To: " + self.to_hdr + "\r\n" + \ "From: " + self.from_hdr + "\r\n" + \ "Call-ID: " + str(self.callid) + "\r\n" + \ "CSeq: 20 ACK\r\n" + \ "Content-Length: 0\r\n\r\n" gsocket.wait_write(self.socket.fileno()) self.socket.send(reply)
def __iowait(self, io_func, *args, **kwargs): fd = self._sock.fileno() timeout = self._sock.gettimeout() while True: try: return io_func(*args, **kwargs) except (OpenSSL.SSL.WantReadError, OpenSSL.SSL.WantX509LookupError): wait_read(fd, timeout=timeout) except OpenSSL.SSL.WantWriteError: wait_write(fd, timeout=timeout) except OpenSSL.SSL.SysCallError as e: if e.args == (-1, 'Unexpected EOF'): return b'' raise
def write(self, data): # use buffer bytes_total = len(data) bytes_written = 0 fileno = self.fileno() while bytes_written < bytes_total: try: # fileobj.write() doesn't return anything, so use os.write. bytes_written += os.write(fileno, data[bytes_written:]) except IOError, ex: if ex[0] != errno.EAGAIN: raise sys.exc_clear() socket.wait_write(fileno)
def recv(self, bufsiz, flags=0): pending = self._connection.pending() if pending: return self._connection.recv(min(pending, bufsiz)) while True: try: return self._connection.recv(bufsiz, flags) except (WantReadError, WantX509LookupError): sys.exc_clear() wait_read(self._sock.fileno(), timeout=self._timeout) except WantWriteError: sys.exc_clear() wait_write(self._sock.fileno(), timeout=self._timeout) except ZeroReturnError: return ''
def recv(self, bufsiz, flags=0): pending = _Connection.pending(self) if pending: return _Connection.recv(min(pending, bufsiz)) while True: try: return _Connection.recv(self, buflen, flags) except WantReadError: exc_clear() wait_read(self._sock.fileno(), timeout=self._timeout) except WantWriteError: exc_clear() wait_write(self._sock.fileno(), timeout=self._timeout) except ZeroReturnError: return ''
def do_handshake(self): while True: try: self._sock.do_handshake() break except SSL.WantReadError: sys.exc_clear() wait_read(self.fileno()) except SSL.WantWriteError: sys.exc_clear() wait_write(self.fileno()) except SSL.SysCallError, ex: raise sslerror(SysCallError_code_mapping.get(ex.args[0], ex.args[0]), ex.args[1]) except SSL.Error, ex: raise sslerror(str(ex))
def _writeAll(writefun, to, data): while data: try: if to is None: count = writefun(data) else: gsocket.wait_write(to) count = writefun(to, data) if count == 0: return False data = data[count:] except OSError as e: if e.errno not in (errno.EAGAIN, errno.EINTR): raise return True
def gevent_sendfile(out_fd, in_fd, offset, count): total_sent = 0 sent = 0 while total_sent < count: try: sent = original_sendfile(out_fd, in_fd, offset + total_sent, count - total_sent) total_sent += sent except OSError as ex: if ex.args[0] == EAGAIN: sent = 0 # TODO: there is performance problem maybe wait_write(out_fd) else: raise return total_sent
def gevent_wait_callback(conn, timeout=None): """A wait callback useful to allow gevent to work with Psycopg.""" # Copyright (C) 2010-2012 Daniele Varrazzo <*****@*****.**> # This function is borrowed from psycogreen module which is licensed # under the BSD license (see in odoo/debian/copyright) while 1: state = conn.poll() if state == psycopg2.extensions.POLL_OK: break elif state == psycopg2.extensions.POLL_READ: wait_read(conn.fileno(), timeout=timeout) elif state == psycopg2.extensions.POLL_WRITE: wait_write(conn.fileno(), timeout=timeout) else: raise psycopg2.OperationalError("Bad result from poll: %r" % state)
def gevent_wait_callback(conn, timeout=None): """A wait callback useful to allow gevent to work with Psycopg.""" while True: state = conn.poll() if state == extensions.POLL_OK: break elif state == extensions.POLL_READ: #print 'Greenlet waiting on READ' socket.wait_read(conn.fileno(), timeout=timeout) elif state == extensions.POLL_WRITE: #print 'Greenlet waiting on WRITE' socket.wait_write(conn.fileno(), timeout=timeout) else: raise psycopg2.OperationalError( "Bad result from poll: %r" % state)
def send(self, data, flags=0): while True: try: _Connection.send(self, data, flags) break except WantReadError: exc_clear() wait_read(self._sock.fileno(), timeout=self._timeout) except WantWriteError: exc_clear() wait_write(self._sock.fileno(), timeout=self._timeout) except SysCallError as e: if e[0] == -1 and not data: # errors when writing empty strings are expected and can be ignored return 0 raise
def do_handshake(self): while True: try: self._sock.do_handshake() break except SSL.WantReadError: sys.exc_clear() wait_read(self.fileno()) except SSL.WantWriteError: sys.exc_clear() wait_write(self.fileno()) except SSL.SysCallError, ex: raise sslerror( SysCallError_code_mapping.get(ex.args[0], ex.args[0]), ex.args[1]) except SSL.Error, ex: raise sslerror(str(ex))