def _pipe_read(self, buf):
read = c_ulong(0)
r = ReadFile(self.pipe_handle, self.read_buffer_ptr, BUFSIZE,
byref(read), byref(self.read_overlapped))
log("ReadFile(..)=%i, len=%s", r, read.value)
if not r and self.pipe_handle:
e = GetLastError()
if e != ERROR_IO_PENDING:
log("ReadFile: %s", IO_ERROR_STR.get(e, e))
if e in CONNECTION_CLOSED_ERRORS:
raise ConnectionClosedException(
CONNECTION_CLOSED_ERRORS[e])
r = WaitForSingleObject(self.read_event, INFINITE)
log("WaitForSingleObject(..)=%s, len=%s", WAIT_STR.get(r, r),
read.value)
if r and self.pipe_handle:
raise Exception("failed to read from named pipe handle %s" %
self.pipe_handle)
if self.pipe_handle:
if not GetOverlappedResult(self.pipe_handle,
byref(self.read_overlapped),
byref(read), False):
e = GetLastError()
if e in CONNECTION_CLOSED_ERRORS:
raise ConnectionClosedException(
CONNECTION_CLOSED_ERRORS[e])
raise Exception("overlapped read failed: %s" %
IO_ERROR_STR.get(e, e))
if read.value == 0:
data = None
else:
data = string_at(self.read_buffer_ptr, read.value)
log("pipe_read: %i bytes", len(data or "")) #, binascii.hexlify(s))
return data
def can_retry(e):
if isinstance(e, socket.timeout):
return "socket.timeout"
if isinstance(e, (IOError, OSError)):
global CONTINUE_ERRNO
code = e.args[0]
can_continue = CONTINUE_ERRNO.get(code)
if can_continue:
return can_continue
#SSL pollution - see ticket #1927
if code=="The read operation timed out":
return str(code)
if isinstance(e, CAN_RETRY_EXCEPTIONS):
return str(e)
abort = ABORT.get(code, code)
if abort is not None:
errno = getattr(e, "errno", None)
log("can_retry: %s, args=%s, errno=%s, code=%s, abort=%s", type(e), e.args, errno, code, abort)
raise ConnectionClosedException(e)
if isinstance(e, CLOSED_EXCEPTIONS):
raise ConnectionClosedException(e)
return False
def _pipe_write(self, buf):
bbuf = memoryview_to_bytes(buf)
size = len(bbuf)
log("pipe_write: %i bytes", size) #binascii.hexlify(buf))
written = c_ulong(0)
r = WriteFile(self.pipe_handle, c_char_p(bbuf), size, byref(written), byref(self.write_overlapped))
log("WriteFile(..)=%s, len=%i", r, written.value)
if not r and self.pipe_handle:
e = GetLastError()
if e!=ERROR_IO_PENDING:
log("WriteFile: %s", IO_ERROR_STR.get(e, e))
if e in CONNECTION_CLOSED_ERRORS:
raise ConnectionClosedException(CONNECTION_CLOSED_ERRORS[e])
r = WaitForSingleObject(self.write_event, INFINITE)
log("WaitForSingleObject(..)=%s, len=%i", WAIT_STR.get(r, r), written.value)
if not self.pipe_handle:
#closed already!
return written.value
if r:
raise Exception("failed to write buffer to named pipe handle %s" % self.pipe_handle)
if self.pipe_handle:
if not GetOverlappedResult(self.pipe_handle, byref(self.write_overlapped), byref(written), False):
e = GetLastError()
raise Exception("overlapped write failed: %s" % IO_ERROR_STR.get(e, e))
log("pipe_write: %i bytes written", written.value)
if self.pipe_handle:
FlushFileBuffers(self.pipe_handle)
#SetFilePointer(self.pipe_handle, 0, FILE_BEGIN)
return written.value
def can_retry(self, e):
code = e.args[0]
if code == errno.WSAEWOULDBLOCK: #@UndefinedVariable pylint: disable=no-member
return "WSAEWOULDBLOCK"
#convert those to a connection closed:
closed = CONNECTION_CLOSED_ERRORS.get(code)
if closed:
raise ConnectionClosedException(e)
return False
def can_retry(e):
if isinstance(e, socket.timeout):
return "socket.timeout"
if isinstance(e, BrokenPipeError):
raise ConnectionClosedException(e) from None
if isinstance(e, OSError):
if isinstance(e, CAN_RETRY_EXCEPTIONS):
return str(e)
code = e.args[0]
abort = ABORT.get(code, code)
if abort is not None:
err = getattr(e, "errno", None)
log("can_retry: %s, args=%s, errno=%s, code=%s, abort=%s", type(e),
e.args, err, code, abort)
raise ConnectionClosedException(e) from None
if isinstance(e, CLOSED_EXCEPTIONS):
raise ConnectionClosedException(e) from None
return False
def can_retry(e):
if isinstance(e, socket.timeout):
return "socket.timeout"
if isinstance(e, (IOError, OSError)):
global CONTINUE_ERRNO
code = e.args[0]
can_continue = CONTINUE_ERRNO.get(code)
if can_continue:
return can_continue
abort = ABORT.get(code, code)
if abort is not None:
errno = getattr(e, "errno", None)
log("can_retry: %s, args=%s, errno=%s, code=%s, abort=%s", type(e),
e.args, errno, code, abort)
raise ConnectionClosedException(e)
return False
def can_retry(e):
continue_exception = CONTINUE_EXCEPTIONS.get(type(e))
if continue_exception:
return continue_exception
if isinstance(e, (IOError, OSError)):
global CONTINUE
code = e.args[0]
can_continue = CONTINUE.get(code)
if can_continue:
return can_continue
abort = ABORT.get(code, code)
if abort is not None:
log("untilConcludes: %s, args=%s, code=%s, abort=%s", type(e),
e.args, code, abort)
raise ConnectionClosedException(e)
return False
def abort_test(self, action):
p = self.process
if p is None or p.poll():
raise ConnectionClosedException("cannot %s: subprocess has terminated" % action)