module Kgio::SocketMethods
This method behaves like Kgio::PipeMethods
, but contains optimizations for sockets on certain operating systems (e.g. GNU/Linux).
This method behaves like Kgio::PipeMethods
, but contains optimizations for sockets on certain operating systems (e.g. GNU/Linux).
Attributes
Returns the client IP address of the socket as a string (e.g. “127.0.0.1” or “::1”). This is always the value of the Kgio::LOCALHOST constant for UNIX domain sockets.
Public Instance Methods
Enables or disables autopush on any given Kgio::SocketMethods-capable IO object. This does NOT enable or disable TCP_NOPUSH/TCP_CORK right away, that must be done with IO.setsockopt
Only available on systems with TCP_CORK (Linux) or TCP_NOPUSH (FreeBSD, and maybe other *BSDs).
static VALUE autopush_set(VALUE io, VALUE vbool) { if (RTEST(vbool)) state_set(io, AUTOPUSH_STATE_WRITER); else state_set(io, AUTOPUSH_STATE_IGNORE); return vbool; }
Returns the current autopush state of the Kgio::SocketMethods-enabled socket.
Only available on systems with TCP_CORK (Linux) or TCP_NOPUSH (FreeBSD, and maybe other *BSDs).
static VALUE autopush_get(VALUE io) { return state_get(io) <= 0 ? Qfalse : Qtrue; }
Like kgio_read
, except it uses MSG_PEEK so it does not drain the socket buffer. A subsequent read of any type (including another peek) will return the same data.
static VALUE kgio_peek(int argc, VALUE *argv, VALUE io) { return my_peek(1, argc, argv, io); }
This method may be optimized on some systems (e.g. GNU/Linux) to use MSG_DONTWAIT to avoid explicitly setting the O_NONBLOCK flag via fcntl. Otherwise this is the same as Kgio::PipeMethods#kgio_read
static VALUE kgio_recv(int argc, VALUE *argv, VALUE io) { return my_recv(1, argc, argv, io); }
Same as Kgio::SocketMethods#kgio_read
, except EOFError is raised on EOF without a backtrace
static VALUE kgio_recv_bang(int argc, VALUE *argv, VALUE io) { VALUE rv = my_recv(1, argc, argv, io); if (NIL_P(rv)) my_eof_error(); return rv; }
Returns nil if the write was completed in full.
Returns a String containing the unwritten portion if EAGAIN was encountered, but some portion was successfully written.
Returns :wait_writable if EAGAIN is encountered and nothing was written.
This method is only available on Ruby 1.9.3 or later.
static VALUE kgio_syssend(VALUE io, VALUE str, VALUE flags) { struct wr_args a; long n; a.flags = NUM2INT(flags); prepare_write(&a, io, str); if (a.flags & MY_MSG_DONTWAIT) { do { n = (long)send(a.fd, a.ptr, a.len, a.flags); } while (write_check(&a, n, "send", 0) != 0); } else { do { n = (long)rb_thread_io_blocking_region( nogvl_send, &a, a.fd); } while (write_check(&a, n, "send", 0) != 0); } return a.buf; }
Like kgio_tryread
, except it uses MSG_PEEK so it does not drain the socket buffer. A subsequent read of any type (including another peek) will return the same data.
static VALUE kgio_trypeek(int argc, VALUE *argv, VALUE io) { return my_peek(0, argc, argv, io); }
This method may be optimized on some systems (e.g. GNU/Linux) to use MSG_DONTWAIT to avoid explicitly setting the O_NONBLOCK flag via fcntl. Otherwise this is the same as Kgio::PipeMethods#kgio_tryread
static VALUE kgio_tryrecv(int argc, VALUE *argv, VALUE io) { return my_recv(0, argc, argv, io); }
This method may be optimized on some systems (e.g. GNU/Linux) to use MSG_DONTWAIT to avoid explicitly setting the O_NONBLOCK flag via fcntl. Otherwise this is the same as Kgio::PipeMethods#kgio_trywrite
static VALUE kgio_trysend(VALUE io, VALUE str) { return my_send(io, str, 0); }
Returns nil if the write was completed in full.
Returns an Array of strings containing the unwritten portion if EAGAIN was encountered, but some portion was successfully written.
Returns :wait_writable if EAGAIN is encountered and nothing was written.
Note: it uses +Array()+ semantic for converting argument, so that it will succeed if you pass something else.
static VALUE kgio_trywritev(VALUE io, VALUE ary) { return my_writev(io, ary, 0); }
This method may be optimized on some systems (e.g. GNU/Linux) to use MSG_DONTWAIT to avoid explicitly setting the O_NONBLOCK flag via fcntl. Otherwise this is the same as Kgio::PipeMethods#kgio_write
static VALUE kgio_send(VALUE io, VALUE str) { return my_send(io, str, 1); }
Returns nil when the write completes.
This may block and call any method defined to kgio_wait_writable
for the class.
Note: it uses +Array()+ semantic for converting argument, so that it will succeed if you pass something else.
static VALUE kgio_writev(VALUE io, VALUE ary) { return my_writev(io, ary, 1); }