Merge branch 'NiR--1.1.x' into 1.1.x

.github/workflows/commits.yml

@@ -1,40 +0,0 @@
-name: Commits
-on:
-  - pull_request
-
-permissions:
-  contents: read
-
-jobs:
-  dco-check:
-    permissions:
-      pull-requests: read  # for tim-actions/get-pr-commits to get list of commits from the PR
-    name: Signed-off-by (DCO)
-    runs-on: ubuntu-20.04
-    steps:
-    - name: Get PR Commits
-      id: 'get-pr-commits'
-      uses: tim-actions/get-pr-commits@master
-      with:
-        token: ${{ secrets.GITHUB_TOKEN }}
-
-    - name: Check that all commits are signed-off
-      uses: tim-actions/dco@master
-      with:
-        commits: ${{ steps.get-pr-commits.outputs.commits }}
-
-  target-branch:
-    permissions:
-      contents: none
-    name: Branch target
-    runs-on: ubuntu-20.04
-    steps:
-    - name: Check branch target
-      env:
-        TARGET: ${{ github.event.pull_request.base.ref }}
-      run: |
-        set -x
-        [ "${TARGET}" = "main" ] && exit 0
-
-        echo "Invalid branch target: ${TARGET}"
-        exit 1

.travis.yml

@@ -5,17 +5,11 @@ rvm:
   - 2.1.0
 branches:
   only:
-    - master
+    - 1.1.x
 before_install:
   - sudo apt-get update -y
   - sudo apt-get install -y python-software-properties
-  - sudo add-apt-repository -y ppa:ubuntu-lxc/daily
   - sudo apt-get update -y
-  - sudo apt-get install -y liblxc1
+  - sudo apt-get install -y liblxc0
 script:
   - bundle exec rake clean package
-
-notifications:
-  webhooks: https://linuxcontainers.org/webhook-lxcbot/
-  email:
-    - andrenth@gmail.com

README.md

@@ -1,7 +1,5 @@
 # Ruby-LXC
 
-[![Build Status](https://travis-ci.org/lxc/ruby-lxc.svg?branch=master)](https://travis-ci.org/lxc/ruby-lxc)
-
 ## Introduction
 
 Ruby-LXC is a Ruby binding for liblxc. It allows the creation and management
@@ -13,12 +11,10 @@ Assuming a current installation of LXC is available, to install Ruby-LXC
 simply run the commands below
 
 ```sh
-sudo apt-get install ruby-dev lxc-dev
-
 bundle install
 bundle exec rake compile
 bundle exec rake gem
-gem install pkg/ruby-lxc-1.2.0.gem
+gem install pkg/ruby-lxc-1.1.1.gem
 ```
 or just add this to your ```Gemfile```
 ```ruby
@@ -29,7 +25,6 @@ gem "ruby-lxc", github: "lxc/ruby-lxc", require: "lxc"
 
 - Container lifecycle management (create, start, stop and destroy containers)
 ```ruby
-require 'lxc'
 c = LXC::Container.new('foo')
 c.create('ubuntu') # create a container named foo with ubuntu template
 c.start

debian/changelog

@@ -1,27 +1,3 @@
-ruby-lxc (1.2.3-0digirati1) trusty; urgency=low
-
-  * Version 1.2.3.
-
- -- Andre Nathan <andre@digirati.com.br>  Mon, 10 Jul 2018 10:29:03 -0300
-
-ruby-lxc (1.2.2-0digirati1) trusty; urgency=low
-
-  * Version 1.2.2.
-
- -- Andre Nathan <andre@digirati.com.br>  Mon, 24 Oct 2016 10:55:05 -0200
-
-ruby-lxc (1.2.1-0digirati1) trusty; urgency=low
-
-  * Version 1.2.1.
-
- -- Andre Nathan <andre@digirati.com.br>  Fri, 04 Jan 2016 11:43:33 -0200
-
-ruby-lxc (1.2.0-0digirati1) trusty; urgency=low
-
-  * Version 1.2.0.
-
- -- Andre Nathan <andre@digirati.com.br>  Fri, 13 Jun 2014 14:37:26 -0300
-
 ruby-lxc (1.1.1-0digirati1) trusty; urgency=low
 
   * Version 1.1.1.

debian/control

@@ -2,13 +2,13 @@ Source: ruby-lxc
 Section: ruby
 Priority: optional
 Maintainer: Andre Nathan <andrenth@gmail.com>
-Build-Depends: debhelper (>= 7.0.50~), gem2deb (>= 0.2.3~), lxc-dev
+Build-Depends: debhelper (>= 7.0.50~), gem2deb (>= 0.2.3~)
 Standards-Version: 3.9.5
 XS-Ruby-Versions: all
 
 Package: ruby-lxc
 Architecture: any
 XB-Ruby-Versions: ${ruby:Versions}
-Depends: ${misc:Depends}, ${shlibs:Depends}, ruby | ruby-interpreter, liblxc1
+Depends: ${misc:Depends}, ${shlibs:Depends}, ruby | ruby-interpreter, lxc-dev
 Description: Ruby bindings for liblxc
  This package provides liblxc bindings for the Ruby programming language.

ext/lxc/lxc.c

@@ -6,7 +6,6 @@
 #include <signal.h>
 #include <stdint.h>
 #include <string.h>
-#include <errno.h>
 
 #define SYMBOL(s) ID2SYM(rb_intern(s))
 
@@ -41,28 +40,9 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 #define RELEASING_GVL2(func, arg, killfunc, killarg) func(arg)
 #endif
 
-//extern int lxc_wait_for_pid_status(pid_t pid);
+extern int lxc_wait_for_pid_status(pid_t pid);
-#include <sys/types.h>
+extern long lxc_config_parse_arch(const char *arch);
-#include <sys/wait.h>
+extern const char *lxc_strerror(int error);
-int lxc_wait_for_pid_status(pid_t pid)
-{
-	int status, ret;
-
-again:
-	ret = waitpid(pid, &status, 0);
-	if (ret == -1) {
-		if (errno == EINTR)
-			goto again;
-
-		return -1;
-	}
-
-	if (ret != pid)
-		goto again;
-
-	return status;
-}
-//extern long lxc_config_parse_arch(const char *arch);
 
 static VALUE Container;
 static VALUE Error;
@@ -71,6 +51,20 @@ struct container_data {
     struct lxc_container *container;
 };
 
+struct bdev_specs {
+    char *fstype;
+    uint64_t fssize;  // fs size in bytes
+    struct {
+        char *zfsroot;
+    } zfs;
+    struct {
+        char *vg;
+        char *lv;
+        char *thinpool; // lvm thin pool to use, if any
+    } lvm;
+    char *dir;
+};
+
 static char **
 ruby_to_c_string_array(VALUE rb_arr)
 {
@@ -118,24 +112,24 @@ free_c_string_array(char **arr)
  * "personality", either +:linux32+ or +:linux+, for the 32-bit and 64-bit
  * architectures, respectively.
  */
-//static VALUE
+static VALUE
-//lxc_arch_to_personality(VALUE self, VALUE rb_arch)
+lxc_arch_to_personality(VALUE self, VALUE rb_arch)
-//{
+{
-//    int ret;
+    int ret;
-//    char *arch;
+    char *arch;
-//
+
-//    arch = StringValuePtr(rb_arch);
+    arch = StringValuePtr(rb_arch);
-//    ret = lxc_config_parse_arch(arch);
+    ret = lxc_config_parse_arch(arch);
-//
+
-//    switch (ret) {
+    switch (ret) {
-//    case PER_LINUX32:
+    case PER_LINUX32:
-//        return SYMBOL("linux32");
+        return SYMBOL("linux32");
-//    case PER_LINUX:
+    case PER_LINUX:
-//        return SYMBOL("linux");
+        return SYMBOL("linux");
-//    default:
+    default:
-//        rb_raise(Error, "unknown personality");
+        rb_raise(Error, "unknown personality");
-//    }
+    }
-//}
+}
 
 /*
  * call-seq:
@@ -566,10 +560,10 @@ is_string_array(VALUE v)
 }
 
 static int
-has_file_descriptor(VALUE v)
+is_io(VALUE v)
 {
-    return rb_respond_to(v, rb_intern("fileno")) &&
+    return rb_respond_to(v, rb_intern("sysread")) &&
-           rb_funcall(v, rb_intern("fileno"), 0) != Qnil;
+           rb_respond_to(v, rb_intern("syswrite"));
 }
 
 static void
@@ -589,12 +583,11 @@ lxc_attach_free_options(lxc_attach_options_t *opts)
 static lxc_attach_options_t *
 lxc_attach_parse_options(VALUE rb_opts)
 {
-    char *error = NULL;
     lxc_attach_options_t default_opts = LXC_ATTACH_OPTIONS_DEFAULT;
     lxc_attach_options_t *opts;
     VALUE rb_attach_flags, rb_namespaces, rb_personality, rb_initial_cwd;
     VALUE rb_uid, rb_gid, rb_env_policy, rb_extra_env_vars, rb_extra_keep_env;
-    VALUE rb_stdin_opt, rb_stdout_opt, rb_stderr_opt;
+    VALUE rb_stdin, rb_stdout, rb_stderr;
 
     opts = malloc(sizeof(*opts));
     if (opts == NULL)
@@ -604,124 +597,95 @@ lxc_attach_parse_options(VALUE rb_opts)
     if (NIL_P(rb_opts))
         return opts;
 
-    error = NULL;
-
     rb_attach_flags = rb_hash_aref(rb_opts, SYMBOL("flags"));
     if (!NIL_P(rb_attach_flags)) {
-        if (is_integer(rb_attach_flags)) {
+        if (is_integer(rb_attach_flags))
             opts->attach_flags = NUM2INT(rb_attach_flags);
-        } else {
+        else
-            error = "flags must be an integer";
             goto err;
     }
-    }
     rb_namespaces = rb_hash_aref(rb_opts, SYMBOL("namespaces"));
     if (!NIL_P(rb_namespaces)) {
-        if (is_integer(rb_namespaces)) {
+        if (is_integer(rb_namespaces))
             opts->namespaces = NUM2INT(rb_namespaces);
-        } else {
+        else
-            error = "namespaces must be an integer";
             goto err;
     }
-    }
     rb_personality = rb_hash_aref(rb_opts, SYMBOL("personality"));
     if (!NIL_P(rb_personality)) {
-        if (is_integer(rb_personality)) {
+        if (is_integer(rb_personality))
             opts->personality = NUM2INT(rb_personality);
-        } else {
+        else
-            error = "personality must be an integer";
             goto err;
     }
-    }
     rb_initial_cwd = rb_hash_aref(rb_opts, SYMBOL("initial_cwd"));
     if (!NIL_P(rb_initial_cwd)) {
-        if (is_string(rb_initial_cwd)) {
+        if (is_string(rb_initial_cwd))
             opts->initial_cwd = StringValuePtr(rb_initial_cwd);
-        } else {
+        else
-            error = "initial_cwd must be a string";
             goto err;
     }
-    }
     rb_uid = rb_hash_aref(rb_opts, SYMBOL("uid"));
     if (!NIL_P(rb_uid)) {
-        if (is_integer(rb_uid)) {
+        if (is_integer(rb_uid))
             opts->uid = NUM2INT(rb_uid);
-        } else {
+        else
-            error = "uid must be an integer";
             goto err;
     }
-    }
     rb_gid = rb_hash_aref(rb_opts, SYMBOL("gid"));
     if (!NIL_P(rb_gid)) {
-        if (is_integer(rb_gid)) {
+        if (is_integer(rb_gid))
             opts->gid = NUM2INT(rb_gid);
-        } else {
+        else
-            error = "gid must be an integer";
             goto err;
     }
-    }
     rb_env_policy = rb_hash_aref(rb_opts, SYMBOL("env_policy"));
     if (!NIL_P(rb_env_policy)) {
-        if (is_integer(rb_env_policy)) {
+        if (is_integer(rb_env_policy))
             opts->env_policy = NUM2INT(rb_env_policy);
-        } else {
+        else
-            error = "env_policy must be an integer";
             goto err;
     }
-    }
     rb_extra_env_vars = rb_hash_aref(rb_opts, SYMBOL("extra_env_vars"));
     if (!NIL_P(rb_extra_env_vars)) {
-        if (is_string_array(rb_extra_env_vars)) {
+        if (is_string_array(rb_extra_env_vars))
             opts->extra_env_vars = ruby_to_c_string_array(rb_extra_env_vars);
-        } else {
+        else
-            error = "extra_env_vars must be a array of strings";
             goto err;
     }
-    }
     rb_extra_keep_env = rb_hash_aref(rb_opts, SYMBOL("extra_keep_env"));
     if (!NIL_P(rb_extra_keep_env)) {
-        if (is_string_array(rb_extra_keep_env)) {
+        if (is_string_array(rb_extra_keep_env))
             opts->extra_keep_env = ruby_to_c_string_array(rb_extra_keep_env);
-        } else {
+        else
-            error = "extra_keep_env must be a array of strings";
             goto err;
     }
-    }
+    rb_stdin = rb_hash_aref(rb_opts, SYMBOL("stdin"));
-    rb_stdin_opt = rb_hash_aref(rb_opts, SYMBOL("stdin"));
+    if (!NIL_P(rb_stdin)) {
-    if (!NIL_P(rb_stdin_opt)) {
+        if (is_io(rb_stdin))
-        if (has_file_descriptor(rb_stdin_opt)) {
+            opts->stdin_fd = io_fileno(rb_stdin);
-            opts->stdin_fd = io_fileno(rb_stdin_opt);
+        else
-        } else {
-            error = "stdin object must have a file descriptor";
             goto err;
     }
-    }
+    rb_stdout = rb_hash_aref(rb_opts, SYMBOL("stdout"));
-    rb_stdout_opt = rb_hash_aref(rb_opts, SYMBOL("stdout"));
+    if (!NIL_P(rb_stdout)) {
-    if (!NIL_P(rb_stdout_opt)) {
+        if (is_io(rb_stdout))
-        if (has_file_descriptor(rb_stdout_opt)) {
+            opts->stdout_fd = io_fileno(rb_stdout);
-            opts->stdout_fd = io_fileno(rb_stdout_opt);
+        else
-        } else {
-            error = "stdout object must have a file descriptor";
             goto err;
     }
-    }
+    rb_stderr = rb_hash_aref(rb_opts, SYMBOL("stderr"));
-    rb_stderr_opt = rb_hash_aref(rb_opts, SYMBOL("stderr"));
+    if (!NIL_P(rb_stderr)) {
-    if (!NIL_P(rb_stderr_opt)) {
+        if (is_io(rb_stderr))
-        if (has_file_descriptor(rb_stderr_opt)) {
+            opts->stderr_fd = io_fileno(rb_stderr);
-            opts->stderr_fd = io_fileno(rb_stderr_opt);
+        else
-        } else {
-            error = "stderr object must have a file descriptor";
             goto err;
     }
-    }
 
     return opts;
 
 err:
     lxc_attach_free_options(opts);
-    if (error != NULL)
-        rb_raise(rb_eArgError, "%s", error);
-    else
     return NULL;
 }
 
@@ -2089,7 +2053,7 @@ container_unfreeze(VALUE self)
 
     ret = RELEASING_GVL(unfreeze_without_gvl, data);
     if (!ret)
-        rb_raise(Error, "unable to unfreeze container");
+        rb_raise(Error, "unable to unfreeze container: %s", lxc_strerror(ret));
 
     return self;
 }
@@ -2147,8 +2111,8 @@ Init_lxc(void)
 {
     VALUE LXC = rb_define_module("LXC");
 
-    //rb_define_singleton_method(LXC, "arch_to_personality",
+    rb_define_singleton_method(LXC, "arch_to_personality",
-    //                           lxc_arch_to_personality, 1);
+                               lxc_arch_to_personality, 1);
     rb_define_singleton_method(LXC, "run_command", lxc_run_command, 1);
     rb_define_singleton_method(LXC, "run_shell", lxc_run_shell, 0);
     rb_define_singleton_method(LXC, "global_config_item",

lib/lxc/version.rb

@@ -1,3 +1,3 @@
 module LXC
-  VERSION = '1.2.3'
+  VERSION = '1.1.1'
 end