lxc-ruby 0.2.0

data/.gitignore

@@ -0,0 +1,25 @@
+*.gem
+*.rbc
+*.swp
+*.tmproj
+*~
+.DS_Store
+.\#*
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+\#*
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+tmtags
+lib/test.rb

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=nested

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - rbx-18mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,143 @@
+# LXC Ruby Wrapper
+
+Ruby wrapper to [LXC](http://lxc.sourceforge.net/) cli tools. 
+
+Provides a simple ruby dsl and json API to manage containers. 
+
+## Build status
+
+This library uses Travis-CI service for automated tests.
+
+[![Build Status](https://secure.travis-ci.org/sosedoff/lxc-ruby.png?branch=master)](http://travis-ci.org/sosedoff/lxc-ruby)
+
+## Requirements
+
+Supported LXC versions:
+
+- 0.7.5
+- 0.8.0-rc1
+- 0.8.0-rc2 - in works  
+
+For testing purposes you can use [Vagrant](http://vagrantup.com/) or [VirtualBox](https://www.virtualbox.org/). Most of functionality
+was tested on Ubuntu 11.04 / 11.10. Additional boxes could be found [here](http://www.vagrantbox.es/)
+
+## Installation
+
+As for now this gem is not released yet, so use gem install task:
+
+```
+rake build
+rake install
+```
+
+## Usage
+
+You should have LXC already installed on your system before using the library.
+
+Example:
+
+```ruby
+require 'lxc'
+
+# Check if all lxc binaries are installed
+LXC.installed?
+
+# Get LXC version
+LXC.version
+
+# Get current LXC configuration
+LXC.config
+
+# Get a list of all containers
+LXC.containers
+
+# Get a single container by name
+LXC.container('name')
+```
+
+Container instance is a simple abstaction for lxc's container tools:
+
+```ruby
+c = LXC.container('foo')
+
+# Get current status of container
+c.status # => {:state => 'RUNNING', :pid => 1234}
+
+# Check if container exists?
+# this is needed since lxc does not raise any errors if container is
+# not present in the system, and returns the same result as if container
+# is actually stopped
+c.exists? # => true
+
+# Status helpers
+c.running? # => true
+c.frozen?  # => false
+
+# Start and stop containers
+c.start  # => {:state => 'RUNNING', :pid => 1234}
+c.stop   # => {:state => 'STOPPED', :pid => -1}
+
+# Free and unfreeze (also returns current status)
+c.freeze
+c.unfreeze
+
+# Get container memory usage (in bytes)
+c.memory_usage
+c.memory_limit
+
+# Get running processes
+c.processes 
+# => 
+#[{"pid"=>"27404",
+#   "user"=>"root",
+#   "cpu"=>"0.0",
+#   "memory"=>"0.1",
+#   "command"=>"/sbin/init",
+#   "args"=>""}]
+
+# Destroy container
+c.destroy # => true
+```
+
+To create a new container:
+
+``` ruby
+c = LXC::Container.new('foo')
+c.create(path_to_lxc_config)
+```
+
+This method invokes ```lxc-create -n NAME -f CONFIG``` command. It *DOES NOT* create 
+any rootfs images or configures anything.
+
+### Running with sudo
+
+By default LXC does not allow to run its command under unprivileged user. There are
+two ways to make it work: 
+
+**Using sudo**
+
+```ruby
+LXC.use_sudo = true
+```
+
+**Using lxc-setcap**
+
+If you want to make container usable by non-root users, run lxc-setcap as root, and some capabilities will be set so that normal users will be able to use the container utils. This is not done by default, though, and you have to explicitly allow it.
+
+## Testing
+
+To run the test suite execute:
+
+```
+rake test
+```
+
+## License
+
+Copyright (c) 2012 Dan Sosedoff.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+require 'bundler/gem_tasks'
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.pattern = 'spec/*_spec.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/lib/lxc/configuration.rb

@@ -0,0 +1,77 @@
+module LXC
+  class Configuration
+    include LXC::ConfigurationOptions
+
+    attr_reader :content
+
+    # Initialize a new LXC::Configuration instance
+    # @param [data] string or hash data (optional)
+    def initialize(data=nil)
+      if data.kind_of?(String)
+        @content = parse(data)
+      end
+    end
+
+    # Load an existing LXC container configuration from file
+    # @param [path] path to configuration
+    # @return [LXC::Configuration]
+    def self.load_file(path)
+      fullpath = File.expand_path(path)
+      if !File.exists?(fullpath)
+        raise ArgumentError, "File '#{path}' does not exist."
+      end
+      LXC::Configuration.new(File.read(fullpath))
+    end
+
+    # Get all configuration attributes
+    # @return [Array]
+    def attributes
+      @content.keys
+    end
+
+    # Get attribute value
+    # @param [key] attribute name
+    # @return [String] configuration attribute value
+    def [](key)
+      @content[key.to_s]
+    end
+
+    def method_missing(key)
+      @content[key.to_s]
+    end
+
+    # Save configuration into file
+    # @param [path] path to output file
+    def save_to_file(path)
+      fullpath = File.expand_path(path)
+      lines = []
+      @content.each_pair do |key,value|
+        k = "lxc.#{key.gsub('_', '.')}"
+        if value.kind_of?(Array)
+          lines << value.map { |v| "#{k} = #{v}" }
+        else
+          lines << "#{k} = #{value}"
+        end
+      end
+      File.open(path, 'w') { |f| f.write(lines.flatten.join("\n")) }
+    end
+
+    private
+
+    def parse(data)
+      hash = {}
+      lines = data.split("\n").map(&:strip).select { |l| !l.empty? && l[0,1] != '#' }
+      lines.each do |l|
+        key,value = l.split('=').map(&:strip)
+        if !valid_option?(key)
+          raise ConfigurationError, "Invalid config attribute: #{key}."
+        end
+        key.gsub!(/^lxc\./, '').gsub!('.', '_')
+        hash[key] = [] if !hash.key?(key)
+        hash[key] << value
+      end
+      hash.each_pair { |k,v| hash[k] = v.first if v.size == 1 }
+      hash
+    end
+  end
+end

data/lib/lxc/configuration_options.rb

@@ -0,0 +1,27 @@
+module LXC
+  module ConfigurationOptions
+    VALID_OPTIONS = [
+      'lxc.utsname',
+      'lxc.network.type',
+      'lxc.network.flags',
+      'lxc.network.link',
+      'lxc.network.name',
+      'lxc.network.hwaddr',
+      'lxc.network.ipv4',
+      'lxc.network.ipv6',
+      'lxc.pts',
+      'lxc.tty',
+      'lxc.mount',
+      'lxc.mount.entry',
+      'lxc.rootfs',
+      'lxc.cgroup',
+      'lxc.cap.drop'
+    ]
+
+    protected
+
+    def valid_option?(name)
+      VALID_OPTIONS.include?(name) || name =~ /^lxc.cgroup/
+    end
+  end
+end

data/lib/lxc/container.rb

@@ -0,0 +1,219 @@
+module LXC
+  class Container
+    attr_accessor :name
+    attr_reader   :state
+    attr_reader   :pid
+
+    # Initialize a new LXC::Container instance
+    # @param [String] name container name
+    # @return [LXC::Container] container instance
+    def initialize(name)
+      @name = name
+    end
+
+    # Get container attributes hash
+    # @return [Hash]
+    def to_hash
+      status
+      {'name' => name, 'state' => state, 'pid' => pid}
+    end
+
+    # Get current status of container
+    # @return [Hash] hash with :state and :pid attributes
+    def status
+      str    = LXC.run('info', '-n', name)
+      @state = str.scan(/^state:\s+([\w]+)$/).flatten.first
+      @pid   = str.scan(/^pid:\s+(-?[\d]+)$/).flatten.first
+      {:state => @state, :pid => @pid}
+    end
+
+    # Check if container exists
+    # @return [Boolean]
+    def exists?
+      LXC.run('ls').split("\n").uniq.include?(name)
+    end
+
+    # Check if container is running
+    # @return [Boolean]
+    def running?
+      status[:state] == 'RUNNING'
+    end
+
+    # Check if container is frozen
+    # @return [Boolean]
+    def frozen?
+      status[:state] == 'FROZEN'
+    end
+
+    # Start container
+    # @return [Hash] container status hash
+    def start
+      LXC.run('start', '-d', '-n', name)
+      status
+    end
+
+    # Stop container
+    # @return [Hash] container status hash
+    def stop
+      LXC.run('stop', '-n', name)
+      status
+    end
+
+    # Restart container
+    # @return [Hash] container status hash
+    def restart
+      stop
+      start
+    end
+
+    # Freeze container
+    # @return [Hash] container status hash
+    def freeze
+      LXC.run('freeze', '-n', name)
+      status
+    end
+
+    # Unfreeze container
+    # @return [Hash] container status hash
+    def unfreeze
+      LXC.run('unfreeze', '-n', name)
+      status
+    end
+
+    # Wait for container to change status
+    # @param [String] state state name
+    def wait(state)
+      if !LXC::Shell.valid_state?(state)
+        raise ArgumentError, "Invalid container state: #{state}"
+      end
+      LXC.run('wait', '-n', name, '-s', state)
+    end
+
+    # Get container memory usage in bytes
+    # @return [Integer]
+    def memory_usage
+      LXC.run('cgroup', '-n', name, 'memory.usage_in_bytes').strip.to_i
+    end
+
+    # Get container memory limit in bytes
+    # @return [Integer]
+    def memory_limit
+      LXC.run('cgroup', '-n', name, 'memory.limit_in_bytes').strip.to_i
+    end
+
+    # Get container processes
+    # @return [Array] list of all processes
+    def processes
+      raise ContainerError, "Container is not running" if !running?
+      str = LXC.run('ps', '-n', name, '--', '-eo pid,user,%cpu,%mem,args').strip
+      lines = str.split("\n") ; lines.delete_at(0)
+      lines.map { |l| parse_process_line(l) }
+    end
+
+    # Create a new container
+    # @param [String] path path to container config file or [Hash] options
+    # @return [Boolean]
+    def create(path)
+      raise ContainerError, "Container already exists." if exists?
+      if path.is_a?(Hash)
+        args = "-n #{name}"
+
+        if !!path[:config_file]
+          unless File.exists?(path[:config_file])
+            raise ArgumentError, "File #{path[:config_file]} does not exist."
+          end
+          args += " -f #{path[:config_file]}"
+        end
+
+        if !!path[:template]
+          template_path = "/usr/lib/lxc/templates/lxc-#{path[:template]}"
+          unless File.exists?(template_path)
+            raise ArgumentError, "Template #{path[:template]} does not exist."
+          end
+          args += " -t #{path[:template]}"
+        end
+
+        args += " -B #{path[:backingstore]}" if !!path[:backingstore]
+        args += " -- #{path[:template_options].join(' ')}".strip if !!path[:template_options]
+
+        LXC.run('create', args)
+        exists?
+      else
+        raise ArgumentError, "File #{path} does not exist." unless File.exists?(path)
+        LXC.run('create', '-n', name, '-f', path)
+        exists?
+      end
+    end
+
+    # Clone to a new container from self
+    # @param [String] target name of new container
+    # @return [LXC::Container] new container instance
+    def clone_to(target)
+      raise ContainerError, "Container does not exist." unless exists?
+      if self.class.new(target).exists?
+        raise ContainerError, "New container already exists."
+      end
+
+      LXC.run('clone', '-o', name, '-n', target)
+      self.class.new target
+    end
+
+    # Create a new container from an existing container
+    # @param [String] source name of existing container
+    # @return [Boolean]
+    def clone_from(source)
+      raise ContainerError, "Container already exists." if exists?
+      unless self.class.new(source).exists?
+        raise ContainerError, "Source container does not exist."
+      end
+
+      LXC.run('clone', '-o', source, '-n', name)
+      exists?
+    end
+
+    # Destroy the container 
+    # @param [Boolean] force force destruction
+    # @return [Boolean] true if container was destroyed
+    #
+    # If container is running and `force` parameter is true
+    # it will be stopped first. Otherwise it will raise exception.
+    #
+    def destroy(force=false)
+      raise ContainerError, "Container does not exist." unless exists?
+      if running?
+        if force
+          # This will force stop and destroy container automatically
+          LXC.run('destroy', '-n', '-f', name)
+        else
+          raise ContainerError, "Container is running. Stop it first or use force=true"
+        end
+      else
+        LXC.run('destroy', '-n', name)
+      end  
+      !exists?
+    end
+
+    private
+
+    def parse_process_line(line)
+      chunks = line.split(' ')
+      chunks.delete_at(0)
+
+      pid     = chunks.shift
+      user    = chunks.shift
+      cpu     = chunks.shift
+      mem     = chunks.shift
+      command = chunks.shift
+      args    = chunks.join(' ')
+
+      {
+        'pid'     => pid,
+        'user'    => user,
+        'cpu'     => cpu,
+        'memory'  => mem,
+        'command' => command,
+        'args'    => args
+      }
+    end
+  end
+end

data/lib/lxc/errors.rb

@@ -0,0 +1,5 @@
+module LXC
+  class Error              < StandardError ; end
+  class ContainerError     < Error ; end
+  class ConfigurationError < Error ; end
+end

data/lib/lxc/shell.rb

@@ -0,0 +1,89 @@
+module LXC
+  module Shell
+    extend self
+
+    BIN_PREFIX = '/usr/bin'
+
+    BIN_FILES = [
+      'lxc-attach',
+      'lxc-cgroup',
+      'lxc-checkconfig',
+      'lxc-checkpoint',
+      'lxc-clone',
+      'lxc-console',
+      'lxc-create',
+      'lxc-destroy',
+      'lxc-execute',
+      'lxc-freeze',
+      'lxc-info',
+      'lxc-kill',
+      'lxc-ls',
+      'lxc-monitor',
+      'lxc-netstat',
+      'lxc-ps',
+      'lxc-restart',
+      'lxc-setcap',
+      'lxc-setuid',
+      'lxc-start',
+      'lxc-start-ephemeral',
+      'lxc-stop',
+      'lxc-unfreeze',
+      'lxc-unshare',
+      'lxc-version',
+      'lxc-wait'
+    ]
+
+    CONTAINER_STATES = [
+      'STOPPED',
+      'STARTING',
+      'RUNNING',
+      'STOPPING',
+      'ABORTING',
+      'FREEZING',
+      'FROZEN'
+    ]
+
+    @@use_sudo = false
+
+    # Check if LXC is using sudo to run commands
+    # @return [Boolean] current sudo flag value
+    def use_sudo
+      @@use_sudo
+    end
+
+    # Set LXC to execute commands with sudo
+    # @param val [Boolean] true for sudo usage
+    # @return [Boolean] new sudo flag value
+    def use_sudo=(val)
+      @@use_sudo = val
+      val
+    end
+
+    # Check if container state is valid
+    # @param name [String] container name
+    # @return [Boolean]
+    def valid_state?(name)
+      CONTAINER_STATES.include?(name)
+    end
+
+    # Execute a LXC command
+    # @param [String] name command name
+    # @param [Array] args command arguments
+    # @return [String] execution result
+    #
+    # If you would like to use pipe command you'll need to 
+    # provide a block that returns string
+    def run(command, *args)
+      command_name = "lxc-#{command}"
+      unless BIN_FILES.include?(command_name)
+        raise ArgumentError, "Invalid command: #{command_name}."
+      end
+
+      cmd = ""
+      cmd += "sudo " if use_sudo == true
+      cmd += "#{command_name} #{args.join(' ')}".strip
+      cmd += " | #{yield}" if block_given?
+      `#{cmd.strip}`
+    end
+  end
+end

data/lib/lxc/version.rb

@@ -0,0 +1,3 @@
+module LXC
+  VERSION = '0.2.0'
+end

data/lib/lxc.rb

@@ -0,0 +1,58 @@
+require 'lxc/version'
+require 'lxc/errors'
+require 'lxc/shell'
+require 'lxc/configuration_options'
+require 'lxc/configuration'
+require 'lxc/container'
+
+module LXC
+  class << self
+    include LXC::Shell
+
+    # Check if binary file is installed
+    # @param [String] name binary filename
+    # @return [Boolean] true if installed
+    def binary_installed?(name)
+      path = File.join(LXC::Shell::BIN_PREFIX, name)
+      File.exists?(path)
+    end
+
+    # Check if all binaries are present in the system
+    # @return [Boolean] true if binary files are found
+    def installed?
+      !BIN_FILES.map { |f| binary_installed?(f) }.uniq.include?(false)
+    end
+
+    # Get LXC configuration info
+    # @return [Hash] hash containing config groups
+    def config
+      str = LXC.run('checkconfig') { 'sed -r "s/\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]//g"' }
+      data = str.scan(/^([\w\s]+): (enabled|disabled)$/).map { |r|
+        [r.first.downcase.gsub(' ', '_'), r.last == 'enabled']
+      }
+      Hash[data]
+    end
+
+    # Get container information record
+    # @param [name] name container name
+    # @return [LXC::Container] container instance
+    def container(name)
+      LXC::Container.new(name)
+    end
+
+    # Get a list of all available containers
+    # @param [String] filter select containers that match string
+    # @return [Array] array of LXC::Containers
+    def containers(filter=nil)
+      names = LXC.run('ls').split("\n").uniq
+      names.delete_if { |v| !v.include?(filter) } if filter.kind_of?(String)
+      names.map { |name| Container.new(name) }
+    end
+
+    # Get current LXC version
+    # @return [String] current LXC version
+    def version
+      LXC.run('version').strip.split(' ').last
+    end
+  end
+end

data/lxc.gemspec

@@ -0,0 +1,20 @@
+require File.expand_path('../lib/lxc/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "lxc-ruby"
+  s.version     = LXC::VERSION
+  s.summary     = "Ruby wrapper to LXC"
+  s.description = "Ruby wrapper to manage LXC (Linux Containers)."
+  s.homepage    = "http://github.com/sosedoff/lxc"
+  s.authors     = ["Dan Sosedoff"]
+  s.email       = ["dan.sosedoff@gmail.com"]
+  
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec',     '~> 2.6'
+  s.add_development_dependency 'simplecov', '~> 0.4'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
+  s.require_paths = ["lib"]
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe LXC::Configuration do
+  it 'parses config data' do
+    conf = LXC::Configuration.new(fixture('configuration.txt')) 
+    conf.content.should be_a Hash
+    conf.attributes.should be_an Array
+    conf.attributes.should_not be_empty
+    conf.utsname.should_not be_nil
+    conf['utsname'].should_not be_nil
+    conf[:utsname].should_not be_nil
+    conf.network_ipv4.should_not be_nil
+  end
+
+  it 'saves config data into file' do
+    conf = LXC::Configuration.new(fixture('configuration.txt')) 
+    conf.save_to_file('/tmp/lxc.txt')
+    c1 = LXC::Configuration.new(fixture('configuration.txt')) 
+    c2 = LXC::Configuration.new(File.read('/tmp/lxc.txt'))
+    c1.content.should eq(c2.content)
+  end
+end

data/spec/container_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe LXC::Container do
+  subject { LXC::Container.new('app') }
+
+  it { should respond_to(:name) }
+  it { should respond_to(:state) }
+  it { should respond_to(:pid) }
+
+  it 'has proper default attributes' do
+    subject.name.should eq('app')
+    subject.state.should be_nil
+    subject.pid.should be_nil
+  end
+
+  it 'should exist' do
+    stub_lxc('ls') { "app\napp2" }
+    subject.exists?.should be_true
+
+    stub_lxc('ls') { "app2\napp3" }
+    subject.exists?.should be_false
+  end
+
+  context '.status' do
+    it 'returns STOPPED' do
+      stub_lxc('info', '-n', 'app') { fixture('lxc-info-stopped.txt') }
+      subject.status.should eq({:state => 'STOPPED', :pid => '-1'})
+    end
+
+    it 'returns RUNNING' do
+      stub_lxc('info', '-n', 'app') { fixture('lxc-info-running.txt') }
+      subject.status.should eq({:state => 'RUNNING', :pid => '2125'})
+    end
+  end
+
+  context '.destroy' do
+    it 'raises error if container does not exist' do
+      stub_lxc('ls') { "app2" }
+      proc { subject.destroy }.
+        should raise_error LXC::ContainerError, "Container does not exist."
+    end
+
+    it 'raises error if container is running' do
+      stub_lxc('ls') { "app" }
+      stub_lxc('info', '-n', 'app') { fixture('lxc-info-running.txt') }
+      proc { subject.destroy }.
+        should raise_error LXC::ContainerError, "Container is running. Stop it first or use force=true"
+    end
+  end
+
+  it 'returns the amount of used memory' do
+    stub_lxc('cgroup', '-n', 'app', 'memory.usage_in_bytes') { "3280896\n" }
+    subject.memory_usage.should eq(3280896)
+  end
+
+  it 'returns the memory limit' do
+    stub_lxc('cgroup', '-n', 'app', 'memory.limit_in_bytes') { "268435456\n" }
+    subject.memory_limit.should eq(268435456)
+  end
+
+  context '.processes' do
+    it 'raises error if container is not running' do
+      stub_lxc('info', '-n', 'app') { fixture('lxc-info-stopped.txt') }
+
+      proc { subject.processes }.
+        should raise_error LXC::ContainerError, "Container is not running"
+    end
+ 
+    it 'returns list of all processes' do
+      stub_lxc('info', '-n', 'app') { fixture('lxc-info-running.txt') }
+      stub_lxc('ps', '-n', 'app', '--', '-eo pid,user,%cpu,%mem,args') { fixture('lxc-ps-aux.txt') }
+
+      list = subject.processes
+      list.should be_an Array
+
+      p = list.first
+      p.should be_a Hash
+      p.should have_key('pid')
+      p.should have_key('user')
+      p.should have_key('cpu')
+      p.should have_key('memory')
+      p.should have_key('command')
+      p.should have_key('args')
+    end
+  end
+end

data/spec/fixtures/configuration.txt

@@ -0,0 +1,33 @@
+lxc.utsname = NAME
+
+lxc.tty = 4
+lxc.pts = 1024
+lxc.rootfs = ROOTFS
+lxc.mount  = ROOTFS/fstab
+
+lxc.network.type = veth
+lxc.network.flags = up
+lxc.network.name = eth0
+lxc.network.link = br0
+lxc.network.ipv4 = 0.0.0.0
+
+lxc.cgroup.devices.deny = a
+
+# /dev/null and zero
+lxc.cgroup.devices.allow = c 1:3 rwm
+lxc.cgroup.devices.allow = c 1:5 rwm
+
+# consoles
+lxc.cgroup.devices.allow = c 5:1 rwm
+lxc.cgroup.devices.allow = c 5:0 rwm
+lxc.cgroup.devices.allow = c 4:0 rwm
+lxc.cgroup.devices.allow = c 4:1 rwm
+
+# /dev/{,u}random
+lxc.cgroup.devices.allow = c 1:9 rwm
+lxc.cgroup.devices.allow = c 1:8 rwm
+lxc.cgroup.devices.allow = c 136:* rwm
+lxc.cgroup.devices.allow = c 5:2 rwm
+
+# rtc
+lxc.cgroup.devices.allow = c 254:0 rwm

data/spec/fixtures/lxc-checkconfig.txt

@@ -0,0 +1,29 @@
+Kernel config /proc/config.gz not found, looking in other places...
+Found kernel config file /boot/config-3.0.0-12-server
+--- Namespaces ---
+Namespaces: enabled
+Utsname namespace: enabled
+Ipc namespace: enabled
+Pid namespace: enabled
+User namespace: enabled
+Network namespace: enabled
+Multiple /dev/pts instances: enabled
+
+--- Control groups ---
+Cgroup: enabled
+Cgroup clone_children flag: enabled
+Cgroup device: enabled
+Cgroup sched: enabled
+Cgroup cpu account: enabled
+Cgroup memory controller: enabled
+Cgroup cpuset: enabled
+
+--- Misc ---
+Veth pair device: enabled
+Macvlan: enabled
+Vlan: enabled
+File capabilities: enabled
+
+Note : Before booting a new kernel, you can check its configuration
+usage : CONFIG=/path/to/config /usr/bin/lxc-checkconfig
+

data/spec/fixtures/lxc-info-running.txt

@@ -0,0 +1,2 @@
+state:   RUNNING
+pid:      2125

data/spec/fixtures/lxc-info-stopped.txt

@@ -0,0 +1,2 @@
+state:   STOPPED
+pid:        -1

data/spec/fixtures/lxc-ps-aux.txt

@@ -0,0 +1,9 @@
+CONTAINER    PID USER     %CPU %MEM COMMAND
+app 27404 root      0.0  0.1 /sbin/init
+app 27476 root      0.0  0.0 upstart-udev-bridge --daemon
+app 27479 root      0.0  0.1 udevd --daemon
+app 27590 root      0.0  0.0 udevd --daemon
+app 27591 root      0.0  0.0 udevd --daemon
+app 27692 root      0.0  0.0 upstart-socket-bridge --daemon
+app 27704 root      0.0  0.2 /usr/sbin/sshd -D
+app 27784 root      0.0  0.0 /sbin/getty -8 38400 console

data/spec/fixtures/lxc-version.txt

@@ -0,0 +1 @@
+lxc version: 0.7.5

data/spec/lxc_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'fileutils'
+
+describe LXC do
+  describe '.check_binaries' do
+    LXC::Shell::BIN_PREFIX = '/tmp/lxc'
+
+    before do
+      FileUtils.mkdir_p('/tmp/lxc')
+      LXC::Shell::BIN_FILES.each do |f|
+        FileUtils.touch("/tmp/lxc/#{f}")
+        FileUtils.chmod(0555, "/tmp/lxc/#{f}")
+      end
+    end
+
+    after do
+      FileUtils.rm_rf('/tmp/lxc')
+    end
+
+    it 'returns true if all files are found' do
+      LXC.installed?.should be_true
+    end
+
+    it 'returns false on missing files' do
+      FileUtils.rm("/tmp/lxc/lxc-version")
+      LXC.installed?.should be_false
+    end
+  end
+
+  it 'returns installed version' do
+    stub_lxc('version') { fixture('lxc-version.txt') }
+    LXC.version.should eq('0.7.5')
+  end
+
+  it 'returns config hash with attributes' do
+    stub_lxc('checkconfig') { fixture('lxc-checkconfig.txt') }
+
+    info = LXC.config
+    info.should be_a Hash
+
+    info['namespaces'].should be_true
+    info['utsname_namespace'].should be_true
+    info['ipc_namespace'].should be_true
+    info['pid_namespace'].should be_true
+    info['user_namespace'].should be_true
+    info['network_namespace'].should be_true
+    info['cgroup'].should be_true
+    info['cgroup_clone_children_flag'].should be_true
+    info['cgroup_device'].should be_true
+    info['cgroup_sched'].should be_true
+    info['cgroup_cpu_account'].should be_true
+    info['cgroup_memory_controller'].should be_true
+    info['cgroup_cpuset'].should be_true
+    info['veth_pair_device'].should be_true
+    info['macvlan'].should be_true
+    info['vlan'].should be_true
+    info['file_capabilities'].should be_true
+  end
+
+  it 'returns a single container' do
+    c = LXC.container('foo')
+    c.should be_a LXC::Container
+    c.name.should eq('foo')
+  end
+
+  it 'returns all available containers' do
+    stub_lxc('ls') { "vm0\nvm1\nvm0" }
+    list = LXC.containers
+    list.should be_an Array
+    list.size.should eq(2)
+    list.first.should be_a LXC::Container
+    list.first.name.should eq('vm0')
+  end
+
+  it 'returns filtered list of containers' do
+    stub_lxc('ls') { "vm0\nvm1\nfoo\n"}
+    list = LXC.containers("vm")
+    list.size.should eq(2)
+  end
+
+  context 'sudo' do
+    class Foo
+      include LXC::Shell
+    end
+
+    before do
+      LXC.use_sudo = true
+    end
+
+    it 'executes command using sudo' do
+      LXC.use_sudo.should be_true
+
+      bar = Foo.new
+      bar.should_receive(:'`').with('sudo lxc-version').and_return(fixture('lxc-version.txt'))
+      bar.run('version').should_not be_empty
+    end
+  end
+
+  context '.use_sudo' do
+    class Bar
+      include LXC::Shell
+    end
+
+    it 'should be true' do
+      foo = Bar.new
+      foo.use_sudo.should eq(true)
+      LXC.use_sudo.should eq(true)
+    end
+
+    it 'should be false' do
+      LXC.use_sudo = false
+      foo = Bar.new
+
+      LXC.use_sudo.should eq(false)
+      foo.use_sudo.should eq(false)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+$:.unshift File.expand_path("../..", __FILE__)
+
+require 'lib/lxc'
+
+def fixture_path(filename=nil)
+  path = File.expand_path("../fixtures", __FILE__)
+  filename.nil? ? path : File.join(path, filename)
+end
+
+def fixture(file)
+  File.read(File.join(fixture_path, file))
+end
+
+def stub_lxc(command, *args)
+  output = yield
+  LXC.should_receive(:run).with(command, *args).and_return(output)
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: lxc-ruby
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Dan Sosedoff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-28 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2152032520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152032520
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2152032020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *2152032020
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &2152031520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: *2152031520
+description: Ruby wrapper to manage LXC (Linux Containers).
+email:
+- dan.sosedoff@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- lib/lxc.rb
+- lib/lxc/configuration.rb
+- lib/lxc/configuration_options.rb
+- lib/lxc/container.rb
+- lib/lxc/errors.rb
+- lib/lxc/shell.rb
+- lib/lxc/version.rb
+- lxc.gemspec
+- spec/configuration_spec.rb
+- spec/container_spec.rb
+- spec/fixtures/configuration.txt
+- spec/fixtures/lxc-checkconfig.txt
+- spec/fixtures/lxc-info-running.txt
+- spec/fixtures/lxc-info-stopped.txt
+- spec/fixtures/lxc-ps-aux.txt
+- spec/fixtures/lxc-version.txt
+- spec/lxc_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/sosedoff/lxc
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Ruby wrapper to LXC
+test_files:
+- spec/configuration_spec.rb
+- spec/container_spec.rb
+- spec/fixtures/configuration.txt
+- spec/fixtures/lxc-checkconfig.txt
+- spec/fixtures/lxc-info-running.txt
+- spec/fixtures/lxc-info-stopped.txt
+- spec/fixtures/lxc-ps-aux.txt
+- spec/fixtures/lxc-version.txt
+- spec/lxc_spec.rb
+- spec/spec_helper.rb
+has_rdoc: