def console_size(self):
if self.closing:
return (0, 0)
c_with, c_height = ffi.new('int*'), ffi.new('int*')
code = uv_tty_get_winsize(self.handle, c_with, c_height)
if code != error.STATUS_SUCCESS:
raise error.UVError(code)
return (c_with[0], c_height[0])
def getpeername(self):
assert self.handle
ip = ffi.new('char[16]')
port = ffi.new('int*')
err = uv_tcp_v4_getpeername(self.handle, ip, port)
if err < 0:
raise TCPError((err, get_strerror(err)))
return ffi.string(ip), port[0]
def fileno(self):
assert self.handle
ptr = ffi.new('int*')
err = uv_fileno(self.handle, ptr)
if err < 0:
raise HandleError((err, get_strerror(err)))
return ptr[0]
def bind(self, addr, flags=0):
assert self.handle
if self.closing:
raise error.HandleClosedError()
ip, port = addr
ip = ffi.new('char[]', ip)
code = uv_udp_v4_bind(self.handle, ip, port, flags)
if code != error.STATUS_SUCCESS:
raise error.UVError(code)
def unpack_sockaddr(c_sockaddr):
if c_sockaddr.sa_family == socket.AF_INET:
c_sockaddr_in4 = ffi.cast('struct fatuv_sockaddr_in*', c_sockaddr)
c_host = ffi.new('char[16]')
port = socket.ntohs(c_sockaddr_in4.sin_port)
lib.fatuv_ip4_name(c_sockaddr_in4, c_host, 16)
return Address4(ffi.string(c_host), port)
elif c_sockaddr.sa_family == socket.AF_INET6:
#not support
return None
def receive_buffer_size(self):
assert self.handle
ptr = ffi.new('int*')
ptr[0] = 0
err = uv_recv_buffer_size(self.handle, ptr)
if err < 0:
raise TCPError((err, get_strerror(err)))
return ptr[0]
def send_buffer_size(self, value):
assert self.handle
ptr = ffi.new('int*')
ptr[0] = value
err = uv_send_buffer_size(self.handle, ptr)
if err < 0:
raise TCPError((err, get_strerror(err)))
return ptr[0]
def try_send(self, data, addr):
handle = self.handle
assert self.handle
if self.closing:
raise error.HandleClosedError()
ip, port = addr
ip = ffi.new('char[]', ip)
code = uv_udp_try_send(handle, data, len(data), ip, port)
if code < 0:
raise error.UVError(code)
def send(self, data, addr, callback=None):
handle = self.handle
assert self.handle
if self.closing:
raise error.HandleClosedError()
ip, port = addr
ip = ffi.new('char[]', ip)
self.send_callback = callback
code = uv_udp_send(handle, data, len(data), ip, port,
lib.fatuv_udp_send_callback)
if code != error.STATUS_SUCCESS:
raise error.UVError(code)
def __init__(self, node, service, callback, loop=None):
self.loop = loop or Loop.default_loop()
request = uv_getaddrinfo_ctx_new()
self.request = request
self._userdata = ffi.new_handle(self)
uv_set_pyobj(request, self._userdata)
self.get_addrinfo_callback = callback
c_hints = ffi.new('struct fatuv_addrinfo_s*')
c_hints.ai_family = socket.AF_INET
c_hints.ai_socktype = socket.SOCK_STREAM
c_hints.ai_protocol = socket.IPPROTO_TCP
c_hints.ai_flags = 0
uv_getaddrinfo(self.loop.handle, request,
lib.fatuv_getaddrinfo_callback, node, service, c_hints)
self.set_pending()
def bind(self, addr):
assert self.handle
ip, port = addr
ip = ffi.new('char[]', ip)
return uv_tcp_v4_bind(self.handle, ip, port)
def __init__(self,
loop,
arguments,
uid=None,
gid=None,
cwd=None,
env=None,
stdin=None,
stdout=None,
stderr=None,
stdio=None,
flags=lib.FATUV_PROCESS_WINDOWS_HIDE,
callback=None):
super(Process, self).__init__(loop)
uv_options = ffi.new('fatuv_process_options_t*')
c_file = ffi.new('char[]', arguments[0].encode())
uv_options.file = c_file
c_args_list = [
ffi.new('char[]', argument.encode()) for argument in arguments
]
c_args_list.append(ffi.NULL)
c_args = ffi.new('char*[]', c_args_list)
uv_options.args = c_args
stdio_count = 3
if stdio is not None:
stdio_count += len(stdio)
uv_options.stdio_count = stdio_count
c_stdio_containers = ffi.new('fatuv_stdio_container_t[]', stdio_count)
self.stdin = populate_stdio_container(loop, c_stdio_containers[0],
stdin)
self.stdout = populate_stdio_container(loop, c_stdio_containers[1],
stdout)
self.stderr = populate_stdio_container(loop, c_stdio_containers[2],
stderr)
self.stdio = []
if stdio is not None:
for number in range(len(stdio)):
c_stdio = c_stdio_containers[3 + number]
fileobj = populate_stdio_container(loop, c_stdio,
stdio[number])
self.stdio.append(fileobj)
uv_options.stdio = c_stdio_containers
if cwd is not None:
c_cwd = ffi.new('char[]', cwd.encode())
uv_options.cwd = c_cwd
if env is not None:
c_env_list = [
ffi.new('char[]', ('%s=%s' % item).encode())
for item in env.items()
]
c_env_list.append(ffi.NULL)
c_env = ffi.new('char*[]', c_env_list)
uv_options.env = c_env
if uid is not None:
flags |= lib.UV_PROCESS_SETUID
if gid is not None:
flags |= lib.UV_PROCESS_SETGID
uv_options.uid = uid or 0
uv_options.gid = gid or 0
uv_options.flags = flags
uv_options.exit_cb = lib.fatuv_exit_callback
self.exit_callback = callback
handle = uv_process_new()
code = uv_spawn(loop.handle, handle, uv_options)
if code != error.STATUS_SUCCESS:
raise error.UVError(code)
self._userdata = ffi.new_handle(self)
uv_set_pyobj(handle, self._userdata)
self.handle = handle
