Module: LXC

Defined in:
ext/lxc/lxc.c,
lib/lxc/version.rb,
ext/lxc/lxc.c

Overview

This module provides a Ruby API allowing programmatic managing of “Linux Containers”.

The LXC module contains generic methods (which are not related to a specific container instance) and methods related to liblxc. The container-specific methods are contained in the LXC::Container class.

Defined Under Namespace

Classes: Container, Error

Constant Summary collapse

VERSION = 
'1.2.2'

Class Method Summary collapse

Class Method Details

.arch_to_personality(arch) ⇒ Object

Converts an architecture string (x86, i686, x86_64 or amd64) to a “personality”, either :linux32 or :linux, for the 32-bit and 64-bit architectures, respectively.



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'ext/lxc/lxc.c', line 100

static VALUE
lxc_arch_to_personality(VALUE self, VALUE rb_arch)
{
    int ret;
    char *arch;

    arch = StringValuePtr(rb_arch);
    ret = lxc_config_parse_arch(arch);

    switch (ret) {
    case PER_LINUX32:
        return SYMBOL("linux32");
    case PER_LINUX:
        return SYMBOL("linux");
    default:
        rb_raise(Error, "unknown personality");
    }
}

.global_config_item(key) ⇒ Object

Returns value for the given global config key.



172
173
174
175
176
177
178
179
180
181
182
 
# File 'ext/lxc/lxc.c', line 172

static VALUE
lxc_global_config_item(VALUE self, VALUE rb_key)
{
    char *key;
    const char *value;
    key = StringValuePtr(rb_key);
    value = lxc_get_global_config_item(key);
    if (value == NULL)
        rb_raise(Error, "invalid configuration key %s", key);
    return rb_str_new2(value);
}

.list_containers([opts]) ⇒ Object

Returns an array of containers. Which containers are returned depends on the options hash: by default, all containers are returned. One may list only active or defined containers by setting either the :active or :defined keys to true. The :config_path key allows an alternate configuration path to be scanned when building the list.



232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
 
# File 'ext/lxc/lxc.c', line 232

static VALUE
lxc_list_containers(int argc, VALUE *argv, VALUE self)
{
    int i, num_containers;
    VALUE rb_active, rb_defined, rb_config;
    VALUE rb_opts;
    VALUE rb_containers;
    struct list_containers_without_gvl_args args;

    rb_scan_args(argc, argv, "01", &rb_opts);

    args.active = 1;
    args.defined = 1;
    args.config = NULL;

    if (!NIL_P(rb_opts)) {
        Check_Type(rb_opts, T_HASH);

        rb_active = rb_hash_aref(rb_opts, SYMBOL("active"));
        if (!NIL_P(rb_active))
            args.active = rb_active != Qfalse;

        rb_defined = rb_hash_aref(rb_opts, SYMBOL("defined"));
        if (!NIL_P(rb_defined))
            args.defined = rb_defined != Qfalse;

        rb_config = rb_hash_aref(rb_opts, SYMBOL("config_path"));
        if (!NIL_P(rb_config))
            args.config = StringValuePtr(rb_config);
    }
    num_containers = RELEASING_GVL(list_containers_without_gvl, &args);
    if (num_containers < 0)
        rb_raise(Error, "failure to list containers");

    rb_containers = rb_ary_new2(num_containers);
    /*
     * The `names` array is not NULL-terminated, so free it manually,
     * ie, don't use free_c_string_array().
     */
    for (i = 0; i < num_containers; i++) {
        rb_ary_store(rb_containers, i, rb_str_new2(args.names[i]));
        free(args.names[i]);
    }
    free(args.names);

    return rb_containers;
}

.run_command(command) ⇒ Object

Runs the given command (given as a string or as an argv array) in an attached container. Useful in conjunction with LXC::Container#attach.



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'ext/lxc/lxc.c', line 126

static VALUE
lxc_run_command(VALUE self, VALUE rb_command)
{
    int ret;
    lxc_attach_command_t cmd;
    VALUE rb_program;

    if (TYPE(rb_command) == T_STRING)
        rb_command = rb_str_split(rb_command, " ");

    rb_program = rb_ary_entry(rb_command, 0);
    cmd.program = StringValuePtr(rb_program);
    cmd.argv = ruby_to_c_string_array(rb_command);

    ret = lxc_attach_run_command(&cmd);
    if (ret == -1)
        rb_raise(Error, "unable to run command on attached container");
    /* NOTREACHED */
    return Qnil;
}

.run_shell ⇒ Object

Runs a shell in an attached container. Useful in conjunction with LXC::Container#attach.



154
155
156
157
158
159
160
161
162
163
164
 
# File 'ext/lxc/lxc.c', line 154

static VALUE
lxc_run_shell(VALUE self)
{
    int ret;

    ret = lxc_attach_run_shell(NULL);
    if (ret == -1)
        rb_raise(Error, "unable to run shell on attached container");
    /* NOTREACHED */
    return Qnil;
}

.version ⇒ Object

Returns the liblxc version.



190
191
192
193
194
 
# File 'ext/lxc/lxc.c', line 190

static VALUE
lxc_version(VALUE self)
{
    return rb_str_new2(lxc_get_version());
}