def next_event(self, t):
length = 0
while True:
ev = self.iom.next_event(None)
# non read channels are simple.
if not isinstance(ev, ioman_base.event_read):
return ev
# an event from a read channel.
# we may receive a part of a message, in which case
# we should not return
ch = ev.ch
if ev.data is not None:
ch.buf.write(ev.data)
# an I/O error or EOF. we return anyway
if ev.eof:
data_to_return = ch.buf.getvalue()
return ioman_base.event_read(ch, data_to_return, 1, ev.err)
elif ev.ch.flag == self.SOCKET_OUT:
# the first 10 bytes is the length of the mssage
if ch.length == 0:
ch.length = string.atoi(ev.ch.buf.getvalue()[0:10])
if len(ch.buf.getvalue()) >= ch.length + 10:
all_data = ch.buf.getvalue()
data_to_return = all_data[0:ch.length+10]
ch.buf.truncate(0)
ch.buf.write(all_data[ch.length+10:])
ch.length = 0
ev.ch.so.send("OK")
return ioman_base.event_read(ch, data_to_return, 0, ev.err)
def fill_pending__(self, timeout):
"""
wait for the next event to happen.
respect timeout specified on each channel
"""
if dbg>=2: LOG("%s\n" % self)
# to =
if timeout == float("inf"):
timeout_ms = win32event.INFINITE
else:
timeout_ms = int(timeout * 1.0E3)
if dbg>=2: LOG("%s WaitForMultipleObjects(%s)\n" % (self, self.handles))
x = self.nointr_wait_for_multiple_object(self.handles, 0, timeout_ms)
o0 = win32event.WAIT_OBJECT_0
assert (o0 <= x < o0 + len(self.handles) \
or x == win32event.WAIT_TIMEOUT), \
(o0, x, len(self.handles))
if x == win32event.WAIT_TIMEOUT: return
h = self.handles[x - o0]
ch = self.channels[h]
if dbg>=2: LOG("-> handle=%s ch=%s\n" % (h, ch))
if isinstance(ch, chan_win_process):
status,err = ch.do_io()
assert (err is None), err
self.pending.append(ioman_base.event_death(ch.pid, status))
elif isinstance(ch, chan_win_server_socket):
new_ch,err = ch.do_io()
assert (err is None), err
self.pending.append(ioman_base.event_accept(ch, new_ch, err))
elif isinstance(ch, chan_win_handle_read):
data,err = ch.do_read()
eof = 0
if data == "" or err:
eof = 1
self.pending.append(ioman_base.event_read(ch, data, eof, err))
elif isinstance(ch, chan_win_handle_write):
pending_bytes,pending_close,err = ch.do_write()
self.pending.append(ioman_base.event_write(ch, pending_bytes,
pending_close, err))
elif isinstance(ch, chan_win_socket):
n_events = 0 # make sure we get at least one event
if ch.read_wouldnt_block():
data,err = ch.do_read()
eof = 0
if data == "" or err:
eof = 1
n_events = n_events + 1
self.pending.append(ioman_base.event_read(ch, data, eof, err))
if ch.requests and ch.so and ch.write_wouldnt_block():
pending_bytes,pending_close,err = ch.do_write()
n_events = n_events + 1
self.pending.append(ioman_base.event_write(ch, pending_bytes,
pending_close, err))
elif isinstance(ch, chan_win_ctrlc):
ch.reset()
self.pending.append(ioman_base.event_win_ctrlc(ch))
else:
raise ioman_win_bug()
def fill_pending__(self, to):
"""
wait for the next event to happen.
respect timeout specified on each channel
"""
if dbg>=3: LOG("\n")
if to is None or to == float("inf"):
events = no_intr(self.po.poll, ())
else:
events = no_intr(self.po.poll, (int(to * 1000.0),))
for fd,event in events:
if dbg>=3:
LOG("fd %d got event %s\n" % (fd, self.pp_event__(event)))
ch = self.channels[fd]
if event & self.events_error:
assert (event & (self.events_out | self.events_in)), (fd, event)
if event & self.events_out:
pending_bytes,pending_close,err = ch.do_write()
self.pending.append(ioman_base.event_write(ch, pending_bytes, pending_close, err))
if event & (self.events_in | self.events_hup):
if ch is self.child_watch:
assert (event & self.events_hup) == 0
assert (event & self.events_error) == 0
data,err = ch.do_read()
assert len(data) > 0
assert err is None
for pid,st in self.reap_children__():
self.pending.append(ioman_base.event_death(pid, st))
elif isinstance(ch, chan_unix_server_socket):
assert (event & self.events_hup) == 0
assert (event & self.events_error) == 0
new_ch,err = ch.do_read()
self.pending.append(ioman_base.event_accept(ch, new_ch, err))
elif event & self.events_hup:
# read until we get EOF or error
c = cStringIO.StringIO()
while 1:
data,err = ch.do_read()
# I thought hup means EOF, but for sockets, I got
# hup after connection reset by peers error
# assert (err is None), err
if err:
assert (data is None)
break
elif data == "":
break
c.write(data)
data = c.getvalue()
eof = 1
self.pending.append(ioman_base.event_read(ch, data, eof, err))
else:
data,err = ch.do_read()
if data == "" or err:
eof = 1
else:
eof = 0
self.pending.append(ioman_base.event_read(ch, data, eof, err))
