class Libvirt::Stream

abort → nil click to toggle source

Call 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)
{
    ruby_libvirt_generate_call_nil(virStreamAbort, ruby_libvirt_connect_get(s),
                                   ruby_libvirt_stream_get(s));
}

event_add_callback(events, callback, opaque=nil) → nil click to toggle source

Call 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 = RUBY_Qnil, callback = RUBY_Qnil, opaque = RUBY_Qnil, passthrough;
    int ret;

    rb_scan_args(argc, argv, "21", &events, &callback, &opaque);

    if (!ruby_libvirt_is_symbol_or_proc(callback)) {
        rb_raise(rb_eTypeError,
                 "wrong argument type (expected Symbol or Proc)");
    }

    passthrough = rb_ary_new2(3);
    rb_ary_store(passthrough, 0, callback);
    rb_ary_store(passthrough, 1, opaque);
    rb_ary_store(passthrough, 2, s);

    ret = virStreamEventAddCallback(ruby_libvirt_stream_get(s), NUM2INT(events),
                                    stream_event_callback, (void *)passthrough,
                                    NULL);
    ruby_libvirt_raise_error_if(ret < 0, e_RetrieveError,
                                "virStreamEventAddCallback",
                                ruby_libvirt_connect_get(s));

    return Qnil;
}

event_remove_callback → nil click to toggle source

Call virStreamEventRemoveCallback to remove the event callback currently registered to this stream.

static VALUE libvirt_stream_event_remove_callback(VALUE s)
{
    ruby_libvirt_generate_call_nil(virStreamEventRemoveCallback,
                                   ruby_libvirt_connect_get(s),
                                   ruby_libvirt_stream_get(s));
}

event_update_callback(events) → nil click to toggle source

Call 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)
{
    ruby_libvirt_generate_call_nil(virStreamEventUpdateCallback,
                                   ruby_libvirt_connect_get(s),
                                   ruby_libvirt_stream_get(s), NUM2INT(events));
}

finish → nil click to toggle source

Call 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)
{
    ruby_libvirt_generate_call_nil(virStreamFinish, ruby_libvirt_connect_get(s),
                                   ruby_libvirt_stream_get(s));
}

free → nil click to toggle source

Call virStreamFree to free this stream. The object will no longer be valid after this call.

static VALUE libvirt_stream_free(VALUE s)
{
    ruby_libvirt_generate_call_free(Stream, s);
}

recv(bytes) → [return_value, data] click to toggle source

Call 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;
    VALUE result;

    data = alloca(sizeof(char) * NUM2INT(bytes));

    ret = virStreamRecv(ruby_libvirt_stream_get(s), data, NUM2INT(bytes));
    ruby_libvirt_raise_error_if(ret < 0, e_RetrieveError, "virStreamRecv",
                                ruby_libvirt_connect_get(s));

    result = rb_ary_new2(2);

    rb_ary_store(result, 0, INT2NUM(ret));
    rb_ary_store(result, 1, rb_str_new(data, ret));

    return result;
}

recvall(opaque){|data, opaque| receive block} → nil click to toggle source

Call 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 = RUBY_Qnil;
    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(ruby_libvirt_stream_get(s), internal_recvall,
                           (void *)opaque);
    ruby_libvirt_raise_error_if(ret < 0, e_RetrieveError, "virStreamRecvAll",
                                ruby_libvirt_connect_get(s));

    return Qnil;
}

send(buffer) → Fixnum click to toggle source

Call 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(ruby_libvirt_stream_get(s), RSTRING_PTR(buffer),
                        RSTRING_LEN(buffer));
    ruby_libvirt_raise_error_if(ret == -1, e_RetrieveError, "virStreamSend",
                                ruby_libvirt_connect_get(s));

    return INT2NUM(ret);
}

sendall(opaque=nil){|opaque, nbytes| send block} → nil click to toggle source

Call 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 = RUBY_Qnil;
    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(ruby_libvirt_stream_get(s), internal_sendall,
                           (void *)opaque);
    ruby_libvirt_raise_error_if(ret < 0, e_RetrieveError, "virStreamSendAll",
                                ruby_libvirt_connect_get(s));

    return Qnil;
}

Constants

Attributes

Public Instance Methods