class Libvirt::Stream
Constants
- EVENT_ERROR
- EVENT_HANGUP
- EVENT_READABLE
- EVENT_WRITABLE
- NONBLOCK
Attributes
Public Instance Methods
Call
virStreamAbort[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamAbort]
to abort this stream. Abort is typically used when something on the stream
has failed, and the stream needs to be cleaned up.
static VALUE libvirt_stream_abort(VALUE s) { gen_call_void(virStreamAbort, conn(s), stream_get(s)); }
Call
virStreamEventAddCallback[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamEventAddCallback]
to register a callback to be notified when a stream becomes readable or
writeable. The events parameter is an integer representing the events the
user is interested in; it should be one or more of EVENT_READABLE, EVENT_WRITABLE, EVENT_ERROR, and EVENT_HANGUP, ORed together. The
callback can either be a Symbol (that is the name of a method to callback)
or a Proc. The callback should accept 3 parameters: a pointer to the Stream object itself, the integer that represents
the events that actually occurred, and an opaque pointer that was
(optionally) passed into stream.event_add_callback to begin with.
static VALUE libvirt_stream_event_add_callback(int argc, VALUE *argv, VALUE s) { VALUE events; VALUE callback; VALUE opaque; VALUE passthrough; int ret; rb_scan_args(argc, argv, "21", &events, &callback, &opaque); if (!is_symbol_or_proc(callback)) rb_raise(rb_eTypeError, "wrong argument type (expected Symbol or Proc)"); passthrough = rb_ary_new(); rb_ary_store(passthrough, 0, callback); rb_ary_store(passthrough, 1, opaque); rb_ary_store(passthrough, 2, s); ret = virStreamEventAddCallback(stream_get(s), NUM2INT(events), stream_event_callback, (void *)passthrough, NULL); _E(ret < 0, create_error(e_RetrieveError, "virStreamEventAddCallback", conn(s))); return Qnil; }
Call
virStreamEventRemoveCallback[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamEventRemoveCallback]
to remove the event callback currently registered to this stream.
static VALUE libvirt_stream_event_remove_callback(VALUE s) { int ret; ret = virStreamEventRemoveCallback(stream_get(s)); _E(ret < 0, create_error(e_RetrieveError, "virStreamEventRemoveCallback", conn(s))); return Qnil; }
Call
virStreamEventUpdateCallback[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamEventUpdateCallback]
to change the events that the event callback is looking for. The events
parameter is an integer representing the events the user is interested in;
it should be one or more of EVENT_READABLE, EVENT_WRITABLE, EVENT_ERROR, and EVENT_HANGUP, ORed together.
static VALUE libvirt_stream_event_update_callback(VALUE s, VALUE events) { int ret; ret = virStreamEventUpdateCallback(stream_get(s), NUM2INT(events)); _E(ret < 0, create_error(e_RetrieveError, "virStreamEventUpdateCallback", conn(s))); return Qnil; }
Call
virStreamFinish[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamFinish]
to finish this stream. Finish is typically used when the stream is no
longer needed and needs to be cleaned up.
static VALUE libvirt_stream_finish(VALUE s) { gen_call_void(virStreamFinish, conn(s), stream_get(s)); }
Call
virStreamFree[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamFree]
to free this stream. The object will no longer be valid after this call.
static VALUE libvirt_stream_free(VALUE s) { gen_call_free(Stream, s); }
Call
virStreamRecv[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamRecv]
to receive up to bytes amount of data from the stream. The return is an
array with two elements; the return code from the virStreamRecv call and
the data (as a String) read from the stream. If an error occurred, the
return_value is set to -1. If there is no data pending and the stream is
marked as non-blocking, return_value is set to -2.
static VALUE libvirt_stream_recv(VALUE s, VALUE bytes) { char *data; int ret; int exception = 0; VALUE result; struct stream_recv_args args; data = ALLOC_N(char, NUM2INT(bytes)); ret = virStreamRecv(stream_get(s), data, NUM2INT(bytes)); if (ret == -1) { xfree(data); rb_exc_raise(create_error(e_RetrieveError, "virStreamRecv", conn(s))); } args.ret = ret; args.data = data; result = rb_protect(stream_recv_array, (VALUE)&args, &exception); if (exception) { xfree(data); rb_jump_tag(exception); } xfree(data); return result; }
Call
virStreamRecvAll[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamRecvAll]
to receive the entire data stream. The receive block is required and is
called one or more times to receive data. Each invocation of the receive
block yields the data received and the opaque data passed into the initial
call. The block should return -1 if an error occurred and 0 otherwise.
static VALUE libvirt_stream_recvall(int argc, VALUE *argv, VALUE s) { VALUE opaque; int ret; if (!rb_block_given_p()) rb_raise(rb_eRuntimeError, "A block must be provided"); rb_scan_args(argc, argv, "01", &opaque); ret = virStreamRecvAll(stream_get(s), internal_recvall, (void *)opaque); _E(ret < 0, create_error(e_RetrieveError, "virStreamRecvAll", conn(s))); return Qnil; }
Call
virStreamSend[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamSend]
to send the data in buffer out to the stream. The return value is the
number of bytes sent, which may be less than the size of the buffer. If an
error occurred, -1 is returned. If the transmit buffers are full and the
stream is marked non-blocking, returns -2.
static VALUE libvirt_stream_send(VALUE s, VALUE buffer) { int ret; StringValue(buffer); ret = virStreamSend(stream_get(s), RSTRING_PTR(buffer), RSTRING_LEN(buffer)); _E(ret == -1, create_error(e_RetrieveError, "virStreamSend", conn(s))); return INT2NUM(ret); }
Call
virStreamSendAll[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamSendAll]
to send the entire data stream. The send block is required and is executed
one or more times to send data. Each invocation of the send block yields
the opaque data passed into the initial call and the number of bytes this
iteration is prepared to handle. The send block should return an array of
2 elements; the first element should be the return code from the block (-1
for error, 0 otherwise), and the second element should be the data that the
block prepared to send.
static VALUE libvirt_stream_sendall(int argc, VALUE *argv, VALUE s) { VALUE opaque; int ret; if (!rb_block_given_p()) rb_raise(rb_eRuntimeError, "A block must be provided"); rb_scan_args(argc, argv, "01", &opaque); ret = virStreamSendAll(stream_get(s), internal_sendall, (void *)opaque); _E(ret < 0, create_error(e_RetrieveError, "virStreamSendAll", conn(s))); return Qnil; }