class MockSocketBase(object):
id_next = 1
id_lock = threading.RLock()
def __init__(self):
with self.id_lock:
self.id = MockSocketBase.id_next
MockSocketBase.id_next += 1
self.blocking = True
self.send_pipe = Pipe(timeout=10, name="MockSocket.send[%i]" % self.id)
self.recv_pipe = Pipe(timeout=10, name="MockSocket.recv[%i]" % self.id)
self.send_rbuffer = io.BufferedReader(self.send_pipe)
self.recv_wbuffer = io.BufferedWriter(self.recv_pipe)
self.io_error = None
pass_select = select.select
@classmethod
def wrap_select(cls, rlist, wlist, xlist, timeout=5):
mrlist = []
mwlist = []
mxlist = []
srlist = []
swlist = []
sxlist = []
for r in rlist:
if isinstance(r, cls):
mrlist.append(r)
else:
srlist.append(r)
for w in wlist:
if isinstance(w, cls):
mwlist.append(w)
else:
swlist.append(w)
for x in xlist:
if isinstance(x, cls):
mxlist.append(x)
else:
sxlist.append(x)
if srlist or swlist or sxlist:
return cls.pass_select(srlist, swlist, sxlist, timeout)
else:
return cls.select(mrlist, mwlist, mxlist, timeout)
@classmethod
def select(cls, rlist, wlist, xlist, timeout=5):
the_time = time.time()
if timeout is not None:
tstop = the_time + timeout
else:
tstop = 0
while timeout is None or the_time <= tstop:
# we must always go around at least once
rs = []
ws = []
for r in rlist:
try:
if r.recv_pipe.canread():
rs.append(r)
except IOError:
# raise a socket error
raise select.error(errno.EPIPE, os.strerror(errno.EPIPE))
for w in wlist:
try:
if w.send_pipe.canwrite():
ws.append(w)
except IOError:
# raise a socket error
raise select.error(errno.EPIPE, os.strerror(errno.EPIPE))
if rs or ws:
return rs, ws, []
else:
time.sleep(1)
the_time = time.time()
return [], [], []
def setblocking(self, blocking):
self.blocking = blocking
# turn off blocking for recv and send
self.recv_pipe.set_readblocking(blocking)
self.send_pipe.set_writeblocking(blocking)
def recv(self, nbytes):
if self.io_error:
raise self.io_error
result = self.recv_pipe.read(nbytes)
if self.io_error:
raise self.io_error
if result is None:
# non-blocking read, nothing to read
raise IOError(errno.EAGAIN, os.strerror(errno.EAGAIN),
"MockSocket.recv")
return result
def send(self, data):
if self.io_error:
raise self.io_error
result = self.send_pipe.write(data)
if self.io_error:
raise self.io_error
if result is None:
# non-blocking read, nothing to read
raise IOError(errno.EAGAIN, os.strerror(errno.EAGAIN),
"MockSocket.send")
return result
def shutdown(self, how):
if self.io_error:
raise self.io_error
if how in (socket.SHUT_RD, socket.SHUT_RDWR):
# don't want any more data
self.recv_pipe.write_eof()
# don't wait for recv buffer, we stopped reading
# self.recv_wbuffer.flush()
if how in (socket.SHUT_WR, socket.SHUT_RDWR):
self.send_pipe.write_eof()
# but wait for the client to finish reading
self.send_pipe.set_writeblocking(True)
self.send_rbuffer.flush()
if self.io_error:
raise self.io_error
def mock_shutdown(self, how):
if how in (socket.SHUT_WR, socket.SHUT_RDWR):
self.recv_pipe.write_eof()
# wait for the other end to finish reading
self.recv_pipe.set_writeblocking(True)
self.recv_wbuffer.flush()
if how in (socket.SHUT_RD, socket.SHUT_RDWR):
# don't want any more data
self.send_pipe.write_eof()
# but don't wait for send buffer, we stopped reading
# self.send_rbuffer.flush()
self.send_pipe.close()
def close(self):
self.send_pipe.close()
self.recv_pipe.close()
class MockSocketBase(object):
id_next = 1
id_lock = threading.RLock()
def __init__(self):
with self.id_lock:
self.id = MockSocketBase.id_next
MockSocketBase.id_next += 1
self.blocking = True
self.send_pipe = Pipe(timeout=10, name="MockSocket.send[%i]" % self.id)
self.recv_pipe = Pipe(timeout=10, name="MockSocket.recv[%i]" % self.id)
self.send_rbuffer = io.BufferedReader(self.send_pipe)
self.recv_wbuffer = io.BufferedWriter(self.recv_pipe)
self.io_error = None
pass_select = select.select
@classmethod
def wrap_select(cls, rlist, wlist, xlist, timeout=5):
mrlist = []
mwlist = []
mxlist = []
srlist = []
swlist = []
sxlist = []
for r in rlist:
if isinstance(r, cls):
mrlist.append(r)
else:
srlist.append(r)
for w in wlist:
if isinstance(w, cls):
mwlist.append(w)
else:
swlist.append(w)
for x in xlist:
if isinstance(x, cls):
mxlist.append(x)
else:
sxlist.append(x)
if srlist or swlist or sxlist:
return cls.pass_select(srlist, swlist, sxlist, timeout)
else:
return cls.select(mrlist, mwlist, mxlist, timeout)
@classmethod
def select(cls, rlist, wlist, xlist, timeout=5):
the_time = time.time()
if timeout is not None:
tstop = the_time + timeout
else:
tstop = 0
while timeout is None or the_time <= tstop:
# we must always go around at least once
rs = []
ws = []
for r in rlist:
try:
if r.recv_pipe.canread():
rs.append(r)
except IOError:
# raise a socket error
raise select.error(errno.EPIPE, os.strerror(errno.EPIPE))
for w in wlist:
try:
if w.send_pipe.canwrite():
ws.append(w)
except IOError:
# raise a socket error
raise select.error(errno.EPIPE, os.strerror(errno.EPIPE))
if rs or ws:
return rs, ws, []
else:
time.sleep(1)
the_time = time.time()
return [], [], []
def setblocking(self, blocking):
self.blocking = blocking
# turn off blocking for recv and send
self.recv_pipe.set_readblocking(blocking)
self.send_pipe.set_writeblocking(blocking)
def recv(self, nbytes):
if self.io_error:
raise self.io_error
result = self.recv_pipe.read(nbytes)
if self.io_error:
raise self.io_error
if result is None:
# non-blocking read, nothing to read
raise IOError(errno.EAGAIN, os.strerror(errno.EAGAIN),
"MockSocket.recv")
return result
def send(self, data):
if self.io_error:
raise self.io_error
result = self.send_pipe.write(data)
if self.io_error:
raise self.io_error
if result is None:
# non-blocking read, nothing to read
raise IOError(errno.EAGAIN, os.strerror(errno.EAGAIN),
"MockSocket.send")
return result
def shutdown(self, how):
if self.io_error:
raise self.io_error
if how in (socket.SHUT_RD, socket.SHUT_RDWR):
# don't want any more data
self.recv_pipe.write_eof()
# don't wait for recv buffer, we stopped reading
# self.recv_wbuffer.flush()
if how in (socket.SHUT_WR, socket.SHUT_RDWR):
self.send_pipe.write_eof()
# but wait for the client to finish reading
self.send_pipe.set_writeblocking(True)
self.send_rbuffer.flush()
if self.io_error:
raise self.io_error
def mock_shutdown(self, how):
if how in (socket.SHUT_WR, socket.SHUT_RDWR):
self.recv_pipe.write_eof()
# wait for the other end to finish reading
self.recv_pipe.set_writeblocking(True)
self.recv_wbuffer.flush()
if how in (socket.SHUT_RD, socket.SHUT_RDWR):
# don't want any more data
self.send_pipe.write_eof()
# but don't wait for send buffer, we stopped reading
# self.send_rbuffer.flush()
self.send_pipe.close()
def close(self):
self.send_pipe.close()
self.recv_pipe.close()
