def Stream_read(self):
self.check_closed()
ec = core.get_ec()
if len(self.read_queue) == 0:
uv_callback.push(ec.uv__read, self)
status = uv.read_start(self.stream, _alloc_callback_,
_read_callback_once_)
if status < 0:
uv_callback.drop(ec.uv__read, self.stream)
raise uv_callback.to_error(status)
if len(self.read_queue) == 0:
if self.read_greenlet is not None:
raise unwind(LError(u"async collision"))
self.read_greenlet = ec.current
core.switch([ec.eventloop])
array, nread, status = self.read_queue.pop(0)
if nread < 0:
raise uv_callback.to_error(nread)
if status < 0:
raise uv_callback.to_error(status)
if array is None:
return Uint8Slice(lltype.nullptr(rffi.UCHARP.TO), 0, None)
if array.length == nread:
return array
return array.subslice(nread)
def UDP_recv(self):
self.check_closed()
ec = core.get_ec()
if len(self.read_queue) == 0:
uv_callback.push(ec.uv__udp_recv, self)
status = uv.udp_recv_start(self.udp, _udp_alloc_callback_,
_udp_read_callback_once_)
if status < 0:
uv_callback.drop(ec.uv__udp_recv, self.udp)
raise uv_callback.to_error(status)
if len(self.read_queue) == 0:
if self.read_greenlet is not None:
raise unwind(LError(u"async collision"))
self.read_greenlet = ec.current
core.switch([ec.eventloop])
array, nread, status, addr, flags = self.read_queue.pop(0)
if nread < 0:
raise uv_callback.to_error(nread)
if status < 0:
raise uv_callback.to_error(status)
if array is None:
array = Uint8Slice(lltype.nullptr(rffi.UCHARP.TO), 0, None)
elif array.length != nread:
array = array.subslice(nread)
res = Exnihilo()
res.setattr(u"data", array)
res.setattr(u"addr", addr)
res.setattr(u"flags", Integer(rffi.r_long(flags)))
return res
def Stream_listen(self, backlog):
self.check_closed()
ec = core.get_ec()
uv_callback.push(ec.uv__connection, self)
status = uv.listen(self.stream, backlog.value, _listen_callback_)
if status < 0:
uv_callback.drop(ec.uv__connection, self.stream)
raise uv_callback.to_error(status)
else:
self.listening = True
return null
def Watch_init(path):
ec = core.get_ec()
path = pathobj.os_stringify(path).encode('utf-8')
handle = lltype.malloc(uv.fs_event_ptr.TO, flavor='raw', zero=True)
res = uv.fs_event_init(ec.uv_loop, handle)
if res < 0:
lltype.free(handle, flavor='raw')
raise uv_callback.to_error(res)
self = Watch(handle)
uv_callback.push(ec.uv__fs_event, self)
res = uv.fs_event_start(self.fs_event, _fs_event_cb_, path, 0)
if res < 0:
uv_callback.drop(ec.uv__fs_event, self.fs_event)
Handle_close(self)
raise uv_callback.to_error(res)
return self
def _listen_callback_(handle, status):
status = int(status)
ec = core.get_ec()
if status < 0:
self = uv_callback.drop(ec.uv__connection, handle)
self.listen_status = status
else:
self = uv_callback.peek(ec.uv__connection, handle)
self.listen_count += 1
if self.accept_greenlet is not None:
greenlet, self.accept_greenlet = self.accept_greenlet, None
core.root_switch(ec, [greenlet])
def _read_callback_once_(stream, nread, buf):
ec = core.get_ec()
self = uv_callback.drop(ec.uv__read, stream)
for array in self.alloc_buffers:
if rffi.cast(rffi.CCHARP, array.uint8data) == buf.c_base:
break
else:
array = None
status = uv.read_stop(stream)
self.read_queue.append((array, nread, status))
if self.read_greenlet is not None:
greenlet, self.read_greenlet = self.read_greenlet, None
core.root_switch(ec, [greenlet])
def _fs_event_cb_(handle, filename, events, status):
ec = core.get_ec()
try:
self = uv_callback.peek(ec.uv__fs_event, handle)
status = rffi.r_long(status)
if self.status == 0 and status < 0:
uv_callback.drop(ec.uv__fs_event, handle)
self.status = status
return
obj = Exnihilo()
obj.setattr(u"path", from_cstring(rffi.charp2str(filename)))
if rffi.r_long(events) == 1:
obj.setattr(u"type", String(u"rename"))
else:
obj.setattr(u"type", String(u"change"))
if self.greenlet is None:
self.data.append(obj)
else:
greenlet, self.greenlet = self.greenlet, None
core.switch([greenlet, obj])
except Unwinder as unwinder:
core.root_unwind(ec, unwinder)
def _udp_read_callback_once_(stream, nread, buf, addr, flags):
ec = core.get_ec()
self = uv_callback.drop(ec.uv__udp_recv, stream)
for array in self.alloc_buffers:
if rffi.cast(rffi.CCHARP, array.uint8data) == buf.c_base:
break
else:
array = None
status = uv.udp_recv_stop(stream)
if addr:
addr = copy_to_uint8array(rffi.cast(rffi.VOIDP, addr),
rffi.sizeof(uv.sockaddr_storage),
rffi.sizeof(uv.sockaddr_storage))
else:
addr = null
self.read_queue.append((array, nread, status, addr, flags))
if self.read_greenlet is not None:
greenlet, self.read_greenlet = self.read_greenlet, None
core.root_switch(ec, [greenlet])