lxc-ruby 0.2.3 → 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b048cb271bb43ee64cf3759aa1916899b9c85e5
+  data.tar.gz: c91c3b7c6e0998b64eccf7e81f033781d997ff51
+SHA512:
+  metadata.gz: fc5eddbca427353c4f33dbcab6f559949dddd2472239488badebc54eae7d8ed831462832ba7e7b67ec8230fc8e7841094d549d418a55814448d05fd08ed16217
+  data.tar.gz: de0f0ad1dea5a915b1ceddc781aaf488e1b19194ef4143e6604bb7d5c901cf67231c8355415a791e91245f4d12ad945a833ba34a019fe9cf07f9e286a696fca1

data/.gitignore

@@ -8,6 +8,7 @@
 .bundle
 .config
 .yardoc
+.vagrant
 Gemfile.lock
 InstalledFiles
 \#*
@@ -23,3 +24,4 @@ test/version_tmp
 tmp
 tmtags
 lib/test.rb
+shared/

data/.travis.yml

@@ -3,5 +3,6 @@ rvm:
   - 1.8.7
   - 1.9.2
   - 1.9.3
+  - 2.0.0
   - rbx-18mode
   - rbx-19mode

data/Gemfile

@@ -1,2 +1,2 @@
-source :rubygems
+source 'https://rubygems.org'
 gemspec

data/README.md

@@ -1,23 +1,17 @@
-# LXC Ruby Wrapper
+# LXC Ruby Wrapper [![Build Status](https://secure.travis-ci.org/sosedoff/lxc-ruby.png?branch=master)](http://travis-ci.org/sosedoff/lxc-ruby)
 
-Ruby wrapper to [Linux Containers](http://lxc.sourceforge.net/) CLI tools
-
-## 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)
+Ruby library to integrate with [Linux Containers](http://lxc.sourceforge.net/) CLI tools
 
 ## Requirements
 
 Supported LXC versions:
 
 - 0.7.5
-- 0.8.0-rc1
-- 0.8.0-rc2 - in works  
+- 0.8.0  
 
-For testing purposes you can use [Vagrant](http://vagrantup.com/) or [VirtualBox](https://www.virtualbox.org/). Most of functionality
-was tested on Ubuntu 11.x / 12.04. Additional boxes could be found [here](http://www.vagrantbox.es/)
+For testing purposes you can use [Vagrant](http://vagrantup.com/) with [VirtualBox](https://www.virtualbox.org/). 
+Most of the functionality was tested on 64-bit Ubuntu 11.10 and 12.04. Recommended version is 12.04. 
+Additional boxes could be found [here](http://www.vagrantbox.es/).
 
 ## Installation
 
@@ -64,10 +58,13 @@ Container instance is a simple abstaction for lxc's container tools:
 c = LXC.container('foo')
 
 # Get current status of container
-c.status # => {:state => 'RUNNING', :pid => 1234}
+c.state  # => 'running'
+c.pid    # => 1234
+c.status # => <LXC::Status @state='running' @pid=123456>
 
 # Check if container exists?
-# this is needed since lxc does not raise any errors if container is
+#
+# 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
@@ -78,8 +75,8 @@ c.stopped? # => false
 c.frozen?  # => false
 
 # Start and stop containers
-c.start  # => {:state => 'RUNNING', :pid => 1234}
-c.stop   # => {:state => 'STOPPED', :pid => -1}
+c.start # will be started in daemonized mode
+c.stop
 
 # Free and unfreeze (also returns current status)
 c.freeze

data/Vagrantfile

@@ -0,0 +1,111 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure("2") do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "precise64"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  config.vm.box_url = "http://files.vagrantup.com/precise64.box"
+
+  # Create a forwarded port mapping which allows access to a specific port
+  # within the machine from a port on the host machine. In the example below,
+  # accessing "localhost:8080" will access port 80 on the guest machine.
+  # config.vm.network :forwarded_port, guest: 80, host: 8080
+
+  # Create a private network, which allows host-only access to the machine
+  # using a specific IP.
+  config.vm.network :private_network, ip: "192.168.33.10"
+
+  # Create a public network, which generally matched to bridged network.
+  # Bridged networks make the machine appear as another physical device on
+  # your network.
+  # config.vm.network :public_network
+
+  # Share an additional folder to the guest VM. The first argument is
+  # the path on the host to the actual folder. The second argument is
+  # the path on the guest to mount the folder. And the optional third
+  # argument is a set of non-required options.
+  config.vm.synced_folder "./shared", "/shared"
+
+  # Provider-specific configuration so you can fine-tune various
+  # backing providers for Vagrant. These expose provider-specific options.
+  # Example for VirtualBox:
+  #
+  # config.vm.provider :virtualbox do |vb|
+  #   # Don't boot with headless mode
+  #   vb.gui = true
+  #
+  #   # Use VBoxManage to customize the VM. For example to change memory:
+  #   vb.customize ["modifyvm", :id, "--memory", "1024"]
+  # end
+  #
+  # View the documentation for the provider you're using for more
+  # information on available options.
+
+  # Enable provisioning with Puppet stand alone.  Puppet manifests
+  # are contained in a directory path relative to this Vagrantfile.
+  # You will need to create the manifests directory and a manifest in
+  # the file base.pp in the manifests_path directory.
+  #
+  # An example Puppet manifest to provision the message of the day:
+  #
+  # # group { "puppet":
+  # #   ensure => "present",
+  # # }
+  # #
+  # # File { owner => 0, group => 0, mode => 0644 }
+  # #
+  # # file { '/etc/motd':
+  # #   content => "Welcome to your Vagrant-built virtual machine!
+  # #               Managed by Puppet.\n"
+  # # }
+  #
+  # config.vm.provision :puppet do |puppet|
+  #   puppet.manifests_path = "manifests"
+  #   puppet.manifest_file  = "base.pp"
+  # end
+
+  # Enable provisioning with chef solo, specifying a cookbooks path, roles
+  # path, and data_bags path (all relative to this Vagrantfile), and adding
+  # some recipes and/or roles.
+  #
+  # config.vm.provision :chef_solo do |chef|
+  #   chef.cookbooks_path = "../my-recipes/cookbooks"
+  #   chef.roles_path = "../my-recipes/roles"
+  #   chef.data_bags_path = "../my-recipes/data_bags"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { :mysql_password => "foo" }
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision :chef_client do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # If you're using the Opscode platform, your validator client is
+  # ORGNAME-validator, replacing ORGNAME with your organization name.
+  #
+  # If you have your own Chef Server, the default validation client name is
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
+end

data/lib/lxc/configuration.rb

@@ -17,9 +17,11 @@ module LXC
     # @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
 
@@ -45,15 +47,20 @@ module LXC
     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")) }
+
+      File.open(path, 'w') do |f|
+        f.write(lines.flatten.join("\n"))
+      end
     end
 
     private
@@ -61,16 +68,24 @@ module LXC
     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.each_pair do |k, v| 
+        hash[k] = v.first if v.size == 1
+      end
+
       hash
     end
   end

data/lib/lxc/container.rb

@@ -1,8 +1,6 @@
 module LXC
   class Container
     attr_accessor :name
-    attr_reader   :state
-    attr_reader   :pid
 
     # Initialize a new LXC::Container instance
     # @param [String] name container name
@@ -14,17 +12,28 @@ module LXC
     # Get container attributes hash
     # @return [Hash]
     def to_hash
-      status
-      {'name' => name, 'state' => state, 'pid' => pid}
+      status.to_hash.merge('name' => name)
     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}
+      output = run('info')
+      result = output.scan(/^state:\s+([\w]+)|pid:\s+(-?[\d]+)$/).flatten
+
+      LXC::Status.new(result.first, result.last)
+    end
+
+    # Get state of the container
+    # @return [String]
+    def state
+      status.state
+    end
+
+    # Get PID of the container
+    # @return [Integer]
+    def pid
+      status.pid
     end
 
     # Check if container exists
@@ -36,19 +45,19 @@ module LXC
     # Check if container is running
     # @return [Boolean]
     def running?
-      status[:state] == 'RUNNING'
+      status.state == 'running'
     end
 
     # Check if container is frozen
     # @return [Boolean]
     def frozen?
-      status[:state] == 'FROZEN'
+      status.state == 'frozen'
     end
 
-    # Check if container is stopped?
+    # Check if container is stopped
     # @return [Boolean]
     def stopped?
-      exists? && status[:state] == 'STOPPED'
+      exists? && status.state == 'stopped'
     end
 
     # Start container
@@ -68,8 +77,8 @@ module LXC
     # Restart container
     # @return [Hash] container status hash
     def restart
-      stop
-      start
+      stop ; start
+      status
     end
 
     # Freeze container
@@ -87,9 +96,9 @@ module LXC
     end
 
     # Wait for container to change status
-    # @param [String] state state name
+    # @param [String] state name
     def wait(state)
-      if !LXC::Shell.valid_state?(state)
+      if !LXC::Shell.valid_state?(status.state)
         raise ArgumentError, "Invalid container state: #{state}"
       end
 
@@ -111,14 +120,14 @@ module LXC
     # Get container cpu shares
     # @return [Integer]
     def cpu_shares
-      result = run('cgroup', "cpu.shares").strip
+      result = run('cgroup', "cpu.shares").to_s.strip
       result.empty? ? nil : result.to_i
     end
 
     # Get container cpu usage in seconds
     # @return [Float]
     def cpu_usage
-      result = run('cgroup', "cpuacct.usage").strip
+      result = run('cgroup', "cpuacct.usage").to_s.strip
       result.empty? ? nil : Float('%.4f' % (result.to_i / 1E9))
     end
 
@@ -149,7 +158,8 @@ module LXC
         end
 
         if !!path[:template]
-          template_path = "/usr/lib/lxc/templates/lxc-#{path[:template]}"
+          template_dir =  path[:template_dir] || '/usr/lib/lxc/templates'
+          template_path = File.join(template_dir,"lxc-#{path[:template]}")
           unless File.exists?(template_path)
             raise ArgumentError, "Template #{path[:template]} does not exist."
           end
@@ -163,7 +173,7 @@ module LXC
         exists?
       else
         raise ArgumentError, "File #{path} does not exist." unless File.exists?(path)
-        LXC.run('create', '-n', name, '-f', path)
+        LXC.run('create', '-f', path)
         exists?
       end
     end
@@ -173,12 +183,13 @@ module LXC
     # @return [LXC::Container] new container instance
     def clone_to(target)
       raise ContainerError, "Container does not exist." unless exists?
-      if self.class.new(target).exists?
+
+      if LXC.container(target).exists?
         raise ContainerError, "New container already exists."
       end
 
       LXC.run('clone', '-o', name, '-n', target)
-      self.class.new target
+      LXC.container(target)
     end
 
     # Create a new container from an existing container
@@ -186,11 +197,12 @@ module LXC
     # @return [Boolean]
     def clone_from(source)
       raise ContainerError, "Container already exists." if exists?
-      unless self.class.new(source).exists?
+
+      unless LXC.container(source).exists?
         raise ContainerError, "Source container does not exist."
       end
 
-      LXC.run('clone', '-o', source, '-n', name)
+      run('clone', '-o', source)
       exists?
     end
 
@@ -202,18 +214,19 @@ module LXC
     # it will be stopped first. Otherwise it will raise exception.
     #
     def destroy(force=false)
-      raise ContainerError, "Container does not exist." unless exists?
+      unless exists?
+        raise ContainerError, "Container does not exist."
+      end
 
       if running?
-        if force
-          # This will force stop and destroy container automatically
-          run('destroy', '-f')
+        if force == true
+          stop
         else
           raise ContainerError, "Container is running. Stop it first or use force=true"
-        end
-      else
-        run('destroy')
-      end  
+        end  
+      end
+
+      run('destroy')
 
       !exists?
     end
@@ -228,20 +241,13 @@ module LXC
       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
+        'pid'     => chunks.shift,
+        'user'    => chunks.shift,
+        'cpu'     => chunks.shift,
+        'memory'  => chunks.shift,
+        'command' => chunks.shift,
+        'args'    => chunks.join(' ')
       }
     end
   end

data/lib/lxc/shell.rb

@@ -78,15 +78,18 @@ module LXC
     # 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}`
+      cmd << "sudo " if use_sudo == true
+      cmd << "#{command_name} #{args.join(' ')}".strip
+      cmd << " | #{yield}" if block_given?
+
+      child = POSIX::Spawn::Child.new(cmd.strip)
+      child.out
     end
   end
 end

data/lib/lxc/status.rb

@@ -0,0 +1,22 @@
+module LXC
+  class Status
+    attr_reader :state, :pid
+
+    def initialize(state, pid)
+      @state = state.to_s.downcase
+      @pid = Integer(pid)
+    end
+
+    def == (instance)
+      instance.pid == pid && instance.state == state
+    end
+
+    def to_hash
+      {'state' => state, 'pid' => pid}
+    end
+
+    def to_s
+      "state=#{state} pid=#{pid}"
+    end
+  end
+end

data/lib/lxc/version.rb

@@ -1,3 +1,3 @@
 module LXC
-  VERSION = '0.2.3'
+  VERSION = "0.3.1"
 end

data/lib/lxc.rb

@@ -1,58 +1,67 @@
+require 'posix/spawn'
 require 'lxc/version'
-require 'lxc/errors'
-require 'lxc/shell'
-require 'lxc/configuration_options'
-require 'lxc/configuration'
-require 'lxc/container'
 
 module LXC
+  class Error              < StandardError ; end
+  class ContainerError     < Error ; end
+  class ConfigurationError < Error ; end
+
+  autoload :Shell,                'lxc/shell'
+  autoload :Configuration,        'lxc/configuration'
+  autoload :ConfigurationOptions, 'lxc/configuration_options'
+  autoload :Container,            'lxc/container'
+  autoload :Status,               'lxc/status'
+
   class << self
     include LXC::Shell
+  end
+
+  # Check if binary file is installed
+  # @param [String] binary filename
+  # @return [Boolean] true if installed
+  def self.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 self.installed?
+    LXC::Shell::BIN_FILES.all?{ |f| binary_installed?(f) }
+  end
+
+  # Get LXC configuration info
+  # @return [Hash] hash containing config groups
+  def self.config
+    str = LXC.run('checkconfig') { LXC::Shell::REMOVE_COLORS }
+
+    data = str.scan(/^([\w\s]+): (enabled|disabled)$/).map { |r|
+      [r.first.downcase.gsub(' ', '_'), r.last == 'enabled']
+    }
+
+    Hash[data]
+  end
+
+  # Get a single container instance
+  # @param [String] name of the container
+  # @return [LXC::Container] container instance
+  def self.container(name)
+    LXC::Container.new(name)
+  end
+
+  # Get a list of all available containers
+  # @param [String] select containers that match string
+  # @return [Array] array of LXC::Containers
+  def self.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| LXC::Container.new(name) }
+  end
 
-    # Check if binary file is installed
-    # @param [String] 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') { LXC::Shell::REMOVE_COLORS }
-      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] container name
-    # @return [LXC::Container] container instance
-    def container(name)
-      LXC::Container.new(name)
-    end
-
-    # Get a list of all available containers
-    # @param [String] 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
+  # Get currently installeded LXC version
+  # @return [String] current LXC version
+  def self.version
+    LXC.run('version').strip.split(' ').last
   end
-end
+end

data/{lxc.gemspec → lxc-ruby.gemspec}

@@ -8,10 +8,12 @@ Gem::Specification.new do |s|
   s.homepage    = "http://github.com/sosedoff/lxc-ruby"
   s.authors     = ["Dan Sosedoff"]
   s.email       = ["dan.sosedoff@gmail.com"]
+
+  s.add_dependency 'posix-spawn', '~> 0.3.6'
   
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec',     '~> 2.6'
-  s.add_development_dependency 'simplecov', '~> 0.4'
+  s.add_development_dependency 'rspec',     '~> 2.13'
+  s.add_development_dependency 'simplecov', '~> 0.7'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/configuration_spec.rb

@@ -3,13 +3,13 @@ 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
+    expect(conf.content).to be_a Hash
+    expect(conf.attributes).to be_an Array
+    expect(conf.attributes).to_not be_empty
+    expect(conf.utsname).to_not be_nil
+    expect(conf['utsname']).to_not be_nil
+    expect(conf[:utsname]).to_not be_nil
+    expect(conf.network_ipv4).to_not be_nil
   end
 
   it 'saves config data into file' do
@@ -17,6 +17,6 @@ describe LXC::Configuration do
     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)
+    expect(c1.content).to eq(c2.content)
   end
-end
+end

data/spec/container_spec.rb

@@ -3,28 +3,29 @@ 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
+  it { should respond_to :name }
+  it { should respond_to :status }
+  it { should respond_to :state }
+  it { should respond_to :pid }
+
+  describe '#name' do
+    it 'should be set to "app"' do
+      expect(subject.name).to eq 'app'
+    end
   end
 
   describe '#exists?' do
     context 'for existing container' do
       it 'returns true' do
         stub_lxc('ls') { "app\napp2" }
-        subject.exists?.should be_true
+        expect(subject).to exist
       end
     end
 
     context 'for non-existing container' do
       it 'returns false' do
         stub_lxc('ls') { "app2\napp3" }
-        subject.exists?.should be_false
+        expect(subject).to_not exist
       end
     end
   end
@@ -32,41 +33,60 @@ describe LXC::Container do
   describe '#status' do
     it 'returns STOPPED' do
       stub_lxc('info', '-n', 'app') { fixture('lxc-info-stopped.txt') }
-      subject.status.should eq({:state => 'STOPPED', :pid => '-1'})
+      expect(subject.status).to eq LXC::Status.new('STOPPED', '-1')
     end
 
     it 'returns RUNNING' do
       stub_lxc('info', '-n', 'app') { fixture('lxc-info-running.txt') }
-      subject.status.should eq({:state => 'RUNNING', :pid => '2125'})
+      expect(subject.status).to eq LXC::Status.new('RUNNING', '2125')
     end
   end
 
   describe '#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."
+
+      expect { 
+        subject.destroy 
+      }.to 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"
+      subject.stub(:exists?).and_return(true)
+      subject.stub(:running?).and_return(true)
+
+      expect { 
+        subject.destroy 
+      }.to raise_error LXC::ContainerError, "Container is running. Stop it first or use force=true"  
+    end
+
+    context 'with force=true' do
+      before do
+        stub_lxc('ls') { 'app' }
+        stub_lxc('info', '-n', 'app') { fixture 'lxc-info-running.txt' }
+        stub_lxc('stop', '-n', 'app') { '' }
+        stub_lxc('info', '-n', 'app') { fixture 'lxc-info-stopped.txt' }
+        stub_lxc('destroy', '-n', 'app') { '' }
+        stub_lxc('ls') { '' }
+      end
+
+      it 'stops and destroys container' do
+        expect(subject.destroy(true)).to be_true
+      end
     end
   end
 
   describe '#memory_usage' do
     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)
+      expect(subject.memory_usage).to eq(3280896)
     end
   end
 
   describe '#memory_limit' do
     it 'returns the memory limit' do
       stub_lxc('cgroup', '-n', 'app', 'memory.limit_in_bytes') { "268435456\n" }
-      subject.memory_limit.should eq(268435456)
+      expect(subject.memory_limit).to eq(268435456)
     end
   end
 
@@ -74,8 +94,9 @@ describe LXC::Container 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"
+      expect { 
+        subject.processes 
+      }.to raise_error LXC::ContainerError, "Container is not running"
     end
  
     it 'returns list of all processes' do
@@ -83,16 +104,16 @@ describe LXC::Container do
       stub_lxc('ps', '-n', 'app', '--', '-eo pid,user,%cpu,%mem,args') { fixture('lxc-ps-aux.txt') }
 
       list = subject.processes
-      list.should be_an Array
+      expect(list).to 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')
+      expect(p).to be_a Hash
+      expect(p).to have_key('pid')
+      expect(p).to have_key('user')
+      expect(p).to have_key('cpu')
+      expect(p).to have_key('memory')
+      expect(p).to have_key('command')
+      expect(p).to have_key('args')
     end
   end
 
@@ -100,7 +121,7 @@ describe LXC::Container do
     context 'when container does not exist' do
       it 'returns false' do
         stub_lxc('ls') { "foo-app" }
-        subject.stopped?.should be_false
+        expect(subject).to_not be_stopped
       end
     end
 
@@ -109,14 +130,14 @@ describe LXC::Container do
         stub_lxc('ls') { 'app' }
         stub_lxc('info', '-n', 'app') { fixture('lxc-info-stopped.txt') }
 
-        subject.stopped?.should be_true
+        expect(subject).to be_stopped
       end
 
       it 'returns false if running' do
         stub_lxc('ls') { 'app' }
         stub_lxc('info', '-n', 'app') { fixture('lxc-info-running.txt') }
 
-        subject.stopped?.should be_false
+        expect(subject).to_not be_stopped
       end
     end
   end
@@ -128,7 +149,7 @@ describe LXC::Container do
       end
 
       it 'returns cpu shares value' do
-        subject.cpu_shares.should eq 1024
+        expect(subject.cpu_shares).to eq 1024
       end
     end
 
@@ -138,7 +159,17 @@ describe LXC::Container do
       end
 
       it 'returns nil' do
-        subject.cpu_shares.should be_nil
+        expect(subject.cpu_shares).to be_nil
+      end
+    end
+
+    context 'when run command is nil' do
+      before do
+        subject.stub(:run).and_return(nil)
+      end
+
+      it 'should return nil' do
+        expect(subject.cpu_shares).to be_nil
       end
     end
   end
@@ -150,7 +181,7 @@ describe LXC::Container do
       end
 
       it 'returns usage in seconds' do
-        subject.cpu_usage.should eq 4239.0819
+        expect(subject.cpu_usage).to eq 4239.0819
       end
     end
 
@@ -160,7 +191,17 @@ describe LXC::Container do
       end
 
       it 'returns nil' do
-        subject.cpu_usage.should be_nil
+        expect(subject.cpu_usage).to be_nil
+      end
+    end
+
+    context 'when run command is nil' do
+      before do
+        subject.stub(:run).and_return(nil)
+      end
+
+      it 'should return nil' do
+        expect(subject.cpu_usage).to be_nil
       end
     end
   end
@@ -178,7 +219,7 @@ describe LXC::Container do
 
     it 'executes a command with container name' do
       stub_lxc("info", "-n", "app") { "info" }
-      subject.info.should eq "info"
+      expect(subject.info).to eq "info"
     end
   end
-end
+end

data/spec/lxc_spec.rb

@@ -18,101 +18,112 @@ describe LXC do
     end
 
     it 'returns true if all files are found' do
-      LXC.installed?.should be_true
+      expect(LXC.installed?).to be_true
     end
 
     it 'returns false on missing files' do
       FileUtils.rm("/tmp/lxc/lxc-version")
-      LXC.installed?.should be_false
+      expect(LXC.installed?).to be_false
     end
   end
 
-  it 'returns installed version' do
-    stub_lxc('version') { fixture('lxc-version.txt') }
-    LXC.version.should eq('0.7.5')
+  describe '.version' do
+    it 'returns installed LXC version' do
+      stub_lxc('version') { fixture('lxc-version.txt') }
+      expect(LXC.version).to eq('0.7.5')
+    end
   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
+  describe '.config' do
+    it 'returns config hash with attributes' do
+      stub_lxc('checkconfig') { fixture('lxc-checkconfig.txt') }
+
+      info = LXC.config
+      expect(info).to be_a(Hash)
+
+      expect(info['namespaces']).to be_true
+      expect(info['utsname_namespace']).to be_true
+      expect(info['ipc_namespace']).to be_true
+      expect(info['pid_namespace']).to be_true
+      expect(info['user_namespace']).to be_true
+      expect(info['network_namespace']).to be_true
+      expect(info['cgroup']).to be_true
+      expect(info['cgroup_clone_children_flag']).to be_true
+      expect(info['cgroup_device']).to be_true
+      expect(info['cgroup_sched']).to be_true
+      expect(info['cgroup_cpu_account']).to be_true
+      expect(info['cgroup_memory_controller']).to be_true
+      expect(info['cgroup_cpuset']).to be_true
+      expect(info['veth_pair_device']).to be_true
+      expect(info['macvlan']).to be_true
+      expect(info['vlan']).to be_true
+      expect(info['file_capabilities']).to be_true
+    end
   end
 
-  it 'returns a single container' do
-    c = LXC.container('foo')
-    c.should be_a LXC::Container
-    c.name.should eq('foo')
-  end
+  describe '.container' do
+    it 'returns a container for name' do
+      c = LXC.container('foo')
 
-  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')
+      expect(c).to be_a LXC::Container
+      expect(c.name).to eq('foo')
+    end
   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
+  describe '.containers' do
+    it 'returns all available containers' do
+      stub_lxc('ls') { "vm0\nvm1\nvm0" }
+    
+      list = LXC.containers
+      expect(list).to be_an Array
+      expect(list.size).to eq(2)
+      expect(list.first).to be_a LXC::Container
+      expect(list.first.name).to eq('vm0')
+    end
 
-  context 'sudo' do
-    class Foo
-      include LXC::Shell
+    context 'with argument' do
+      it 'returns containers filtered by name' do
+        stub_lxc('ls') { "vm0\nvm1\nfoo\n"}
+
+        list = LXC.containers("vm")
+        expect(list.size).to eq(2)
+      end
     end
+  end
 
-    before do
-      LXC.use_sudo = true
+  describe '.sudo' do
+    before { LXC.use_sudo = true }
+    let(:result) do 
+      klass = Struct.new(:out)
+      klass.new(fixture('lxc-version.txt'))
     end
 
     it 'executes command using sudo' do
-      LXC.use_sudo.should be_true
+      expect(LXC.use_sudo).to be_true
+
+      POSIX::Spawn::Child.stub(:new).
+        with('sudo lxc-version').
+        and_return(result)
 
-      bar = Foo.new
-      bar.should_receive(:'`').with('sudo lxc-version').and_return(fixture('lxc-version.txt'))
-      bar.run('version').should_not be_empty
+      expect(LXC.run('version')).to eq 'lxc version: 0.7.5'
     end
   end
 
-  context '.use_sudo' do
-    class Bar
-      include LXC::Shell
-    end
+  describe '.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)
+      expect(foo.use_sudo).to be_true
+      expect(LXC.use_sudo).to be_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)
+      expect(LXC.use_sudo).to be_false
+      expect(foo.use_sudo).to be_false
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,10 @@
 $:.unshift File.expand_path("../..", __FILE__)
 
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/.bundle/"
+end
+
 require 'lib/lxc'
 
 def fixture_path(filename=nil)
@@ -13,5 +18,9 @@ end
 
 def stub_lxc(command, *args)
   output = yield
-  LXC.should_receive(:run).with(command, *args).and_return(output)
+
+  LXC.should_receive(:run).
+    exactly(1).times.
+    with(command, *args).
+    and_return(output)
 end

data/spec/status_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe LXC::Status do
+  describe '.new' do
+    let(:status) { LXC::Status.new('RUNNING', '12345') }
+
+    it 'makes state downcase' do
+      expect(status.state).to eq 'running'
+    end
+
+    it 'converts given pid into integer' do
+      expect(status.pid).to be_an Integer
+    end
+  end
+
+  describe '#to_hash' do
+    let(:status) { LXC::Status.new('RUNNING', '12345') }
+
+    it 'returns a hash representation' do
+      result = status.to_hash
+      expect(result).to be_a Hash
+      expect(result).to include 'state', 'pid'
+    end
+  end
+
+  describe '#to_s' do
+    let(:status) { LXC::Status.new('RUNNING', '12345') }
+
+    it 'returns a string representation' do
+      expect(status.to_s).to eq 'state=running pid=12345'
+    end
+  end
+end

metadata

@@ -1,64 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: lxc-ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.3
-  prerelease: 
+  version: 0.3.1
 platform: ruby
 authors:
 - Dan Sosedoff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-23 00:00:00.000000000 Z
+date: 2013-09-22 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: posix-spawn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.6
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.13'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.7'
 description: Ruby wrapper to manage LXC (Linux Containers).
 email:
 - dan.sosedoff@gmail.com
@@ -72,14 +79,15 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- Vagrantfile
 - 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/status.rb
 - lib/lxc/version.rb
-- lxc.gemspec
+- lxc-ruby.gemspec
 - spec/configuration_spec.rb
 - spec/container_spec.rb
 - spec/fixtures/configuration.txt
@@ -90,35 +98,29 @@ files:
 - spec/fixtures/lxc-version.txt
 - spec/lxc_spec.rb
 - spec/spec_helper.rb
+- spec/status_spec.rb
 homepage: http://github.com/sosedoff/lxc-ruby
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 2803095474129589431
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 2803095474129589431
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.0.5
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ruby wrapper to LXC
 test_files:
 - spec/configuration_spec.rb
@@ -131,3 +133,5 @@ test_files:
 - spec/fixtures/lxc-version.txt
 - spec/lxc_spec.rb
 - spec/spec_helper.rb
+- spec/status_spec.rb
+has_rdoc: 

data/lib/lxc/errors.rb

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