def Timer_start(self, delay, repeat): if repeat is None: rep = 0 else: rep = int(repeat.number * 1000) check(uv.timer_start(self.timer, _on_tick_, int(delay.number * 1000), 0)) return null
def ip6_name(addr): res_length = uv.INET6_ADDRSTRLEN res = lltype.malloc(rffi.CCHARP.TO, res_length, flavor="raw") sockaddr = as_sockaddr(addr) try: check(uv.ip6_name(sockaddr, res, res_length)) return from_cstring(rffi.charp2str(res)) finally: lltype.free(res, flavor='raw')
def Stream_try_write(self, data): self.check_closed() bufs, nbufs = uv_callback.obj2bufs(data) try: status = uv.try_write(self.stream, bufs, nbufs) check(status) return Integer(rffi.r_long(status)) finally: lltype.free(bufs, flavor='raw')
def TCP_getpeername(self): self.check_closed() array = alloc_uint8array(rffi.sizeof(uv.sockaddr_storage)) namelen = lltype.malloc(rffi.INTP.TO, 1, flavor="raw", zero=True) try: check(uv.tcp_getpeername(self.tcp, as_sockaddr(array), namelen)) finally: lltype.free(namelen, flavor='raw') return array
def Stream_shutdown(self): self.check_closed() req = lltype.malloc(uv.shutdown_ptr.TO, flavor='raw', zero=True) try: response = uv_callback.shutdown(req) check( response.wait( uv.shutdown(req, self.stream, uv_callback.shutdown.cb))[0]) return null finally: lltype.free(req, flavor='raw')
def inet_pton(af, src): af = af.value if af == uv.AF_INET: res = alloc_uint8array(4) elif af == uv.AF_INET6: res = alloc_uint8array(16) else: raise unwind( LError(u"first argument must be either AF_INET or AF_INET6")) check(uv.inet_ntop(af, src.string.encode('utf-8'), res.uint8data)) return res
def Pipe_connect(self, name): self.check_closed() string = name.string.encode('utf-8') req = lltype.malloc(uv.connect_ptr.TO, flavor='raw', zero=True) try: response = uv_callback.connect(req) uv.pipe_connect(req, self.pipe, string, uv_callback.connect.cb) check(response.wait()[0]) return null finally: lltype.free(req, flavor='raw')
def Stream_accept(self): self.check_closed() if self.listen_count > 0: if self.accept_greenlet is not None: raise unwind(LError(u"async collision")) ec = core.get_ec() self.accept_greenlet = ec.current core.switch([ec.eventloop]) check(self.listen_status) self.listen_count -= 1 client = self.new_stream() check(uv.accept(self.stream, client.stream)) return client
def TTY_set_mode(self, modename_obj): self.check_closed() modename = string_upper(modename_obj.string) if modename == u"NORMAL": mode = uv.TTY_MODE_NORMAL elif modename == u"RAW": mode = uv.TTY_MODE_RAW elif modename == u"IO": mode = uv.TTY_MODE_IO else: raise unwind(LError(u"unknown mode: " + modename_obj.repr())) check(uv.tty_set_mode(self.tty, mode)) return null
def UDP_try_send(self, data, addr): self.check_closed() bufs, nbufs = uv_callback.obj2bufs(data) req = lltype.malloc(uv.udp_send_ptr.TO, flavor='raw', zero=True) sockaddr = as_sockaddr(addr) try: check( uv.udp_try_send(req, self.udp, bufs, nbufs, sockaddr, uv_callback.udp_send.cb)) return null finally: lltype.free(bufs, flavor='raw') lltype.free(req, flavor='raw')
def TCP_connect(self, addr): self.check_closed() req = lltype.malloc(uv.connect_ptr.TO, flavor='raw', zero=True) sockaddr = as_sockaddr(addr) try: response = uv_callback.connect(req) check( response.wait( uv.tcp_connect(req, self.tcp, sockaddr, uv_callback.connect.cb))[0]) return null finally: lltype.free(req, flavor='raw')
def Stream_write(self, data): self.check_closed() bufs, nbufs = uv_callback.obj2bufs(data) req = lltype.malloc(uv.write_ptr.TO, flavor='raw', zero=True) try: response = uv_callback.write(req) check( response.wait( uv.write(req, self.stream, bufs, nbufs, uv_callback.write.cb))[0]) return null finally: lltype.free(bufs, flavor='raw') lltype.free(req, flavor='raw')
def Pipe_accept(self): tp = uv.pipe_pending_type(self.pipe) if tp == uv.NAMED_PIPE or tp == uv.UNKNOWN_HANDLE or tp == uv.FILE: client = alloc_pipe( 1 ) # The libuv reports an external_memory file handle as UNKNOWN_HANDLE elif tp == uv.TCP: # I guess it might be safe to alloc a pipe when that happens. client = stdlib.net.tcp_alloc() elif tp == uv.UDP: client = stdlib.net.udp_alloc() else: raise OldError(u"got fd of type=" + str(tp).decode('utf-8')) check(uv.accept(self.stream, client.stream)) return client
def TTY_get_winsize(self): self.check_closed() width = lltype.malloc(rffi.INTP.TO, 1, flavor='raw', zero=True) height = lltype.malloc(rffi.INTP.TO, 1, flavor='raw', zero=True) try: check(uv.tty_get_winsize(self.tty, width, height)) w = rffi.r_long(width[0]) h = rffi.r_long(height[0]) obj = Exnihilo() obj.setattr(u"width", Integer(w)) obj.setattr(u"height", Integer(h)) return obj finally: lltype.free(width, flavor='raw') lltype.free(height, flavor='raw')
def inet_ntop(af, src): af = af.value if af == uv.AF_INET: L = 4 elif af == uv.AF_INET6: L = 16 else: raise unwind( LError(u"first argument must be either AF_INET or AF_INET6")) if src.length < L: raise unwind(LError(u"argument too short to be an address")) res_length = uv.INET6_ADDRSTRLEN res = lltype.malloc(rffi.CCHARP.TO, res_length, flavor="raw") try: check(uv.inet_ntop(af, src.uint8data, res, res_length)) return from_cstring(rffi.charp2str(res)) finally: lltype.free(res, flavor='raw')
def TCP_bind(self, addr, flags): self.check_closed() flags = 0 if flags is None else flags.value sockaddr = as_sockaddr(addr) check(uv.tcp_bind(self.tcp, sockaddr, flags)) return null
def TCP_nodelay(self, enable): self.check_closed() check(uv.tcp_simultaneous_accepts(self.tcp, 1 if is_true(enable) else 0)) return null
def TCP_nodelay(self, enable, delay): self.check_closed() check( uv.tcp_keepalive(self.tcp, 1 if is_true(enable) else 0, 0 if delay is None else delay.value)) return null
def Timer_stop(self): check(uv.timer_stop(self.timer)) return null
def Spawn_kill(self, signum): check(uv.process_kill(self.process, signum.value)) return null
def Pipe_bind(self, name): self.check_closed() string = name.string.encode('utf-8') check(uv.pipe_bind(self.pipe, string)) return null
def ip6_addr(address, port): res = alloc_uint8array(rffi.sizeof(uv.sockaddr_storage)) check( uv.ip6_addr(address.string.encode('utf-8'), port.value, res.uint8data)) return res
def kill_(pid, signum): check(uv.kill(pid.value, signum.value)) return null
def UDP_set_ttl(self, ttl): self.check_closed() check(uv.udp_set_ttl(self.udp, ttl.value)) return null
def UDP_set_broadcast(self, on): self.check_closed() check(uv.udp_set_broadcast(self.udp, 1 if is_true(on) else 0)) return null
def UDP_set_multicast_loop(self, enable): self.check_closed() check(uv.udp_set_multicast_loop(self.udp, 1 if is_true(enable) else 0)) return null
def Stream_stop(self): check(uv.read_stop(self.stream)) return null
def Timer_again(self): check(uv.timer_again(self.timer)) return null
def TCP_nodelay(self, enable): self.check_closed() check(uv.tcp_nodelay(self.tcp, 1 if is_true(enable) else 0)) return null
def Pipe_pending_count(self): self.check_closed() result = uv.pipe_pending_count(self.pipe) check(result) return Integer(rffi.r_long(result))