vagrant-lxc 0.2.0 → 0.3.0

data/lib/vagrant-lxc/action/base_action.rb

@@ -1,11 +0,0 @@
-module Vagrant
-  module LXC
-    module Action
-      class BaseAction
-        def initialize(app, env)
-          @app = app
-        end
-      end
-    end
-  end
-end

data/lib/vagrant-lxc/action/network.rb

@@ -1,21 +0,0 @@
-module Vagrant
-  module LXC
-    module Action
-      class Network < BaseAction
-        def call(env)
-          # TODO: Validate network configuration prior to anything below
-          @env = env
-
-          env[:machine].config.vm.networks.each do |type, options|
-            # We only handle private networks
-            next if type != :private_network
-            env[:machine].provider_config.start_opts << "lxc.network.ipv4=#{options[:ip]}/24"
-          end
-
-          # Continue the middleware chain.
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/lib/vagrant-lxc/container.rb

@@ -1,141 +0,0 @@
-require 'securerandom'
-
-require "vagrant-lxc/errors"
-require "vagrant-lxc/container/cli"
-
-require "vagrant/util/retryable"
-require "vagrant/util/subprocess"
-
-module Vagrant
-  module LXC
-    class Container
-      # Root folder where containers are stored
-      CONTAINERS_PATH = '/var/lib/lxc'
-
-      # Include this so we can use `Subprocess` more easily.
-      include Vagrant::Util::Retryable
-
-      # This is raised if the container can't be found when initializing it with
-      # a name.
-      class NotFound < StandardError; end
-
-      attr_reader :name
-
-      def initialize(name, cli = CLI.new(name))
-        @name   = name
-        @cli    = cli
-        @logger = Log4r::Logger.new("vagrant::provider::lxc::container")
-      end
-
-      def validate!
-        raise NotFound if @name && ! @cli.list.include?(@name)
-      end
-
-      def base_path
-        Pathname.new("#{CONTAINERS_PATH}/#{@name}")
-      end
-
-      def rootfs_path
-        Pathname.new(base_path.join('config').read.match(/^lxc\.rootfs\s+=\s+(.+)$/)[1])
-      end
-
-      def create(base_name, target_rootfs_path, metadata = {})
-        @logger.debug('Creating container using lxc-create...')
-
-        @name      = "#{base_name}-#{SecureRandom.hex(6)}"
-        public_key = Vagrant.source_root.join('keys', 'vagrant.pub').expand_path.to_s
-        meta_opts  = metadata.fetch('template-opts', {}).merge(
-          '--auth-key' => public_key,
-          '--cache'    => metadata.fetch('rootfs-cache-path')
-        )
-
-        @cli.name = @name
-        @cli.create(metadata.fetch('template-name'), target_rootfs_path, meta_opts)
-
-        @name
-      end
-
-      def share_folders(folders, config)
-        folders.each do |folder|
-          guestpath = rootfs_path.join(folder[:guestpath].gsub(/^\//, ''))
-          unless guestpath.directory?
-            begin
-              system "sudo mkdir -p #{guestpath.to_s}"
-            rescue Errno::EACCES
-              raise Vagrant::Errors::SharedFolderCreateFailed,
-                :path => guestpath.to_s
-            end
-          end
-
-          config.start_opts << "lxc.mount.entry=#{folder[:hostpath]} #{guestpath} none bind 0 0"
-        end
-      end
-
-      def start(config)
-        @logger.info('Starting container...')
-
-        opts = config.start_opts.dup
-        if ENV['LXC_START_LOG_FILE']
-          extra = ['-o', ENV['LXC_START_LOG_FILE'], '-l', 'DEBUG']
-        end
-
-        @cli.transition_to(:running) { |c| c.start(opts, (extra || nil)) }
-      end
-
-      def halt
-        @logger.info('Shutting down container...')
-
-        # TODO: issue an lxc-stop if a timeout gets reached
-        @cli.transition_to(:stopped) { |c| c.shutdown }
-      end
-
-      def destroy
-        @cli.destroy
-      end
-
-      # TODO: This needs to be reviewed and specs needs to be written
-      def compress_rootfs
-        # TODO: Our template should not depend on container's arch
-        arch           = base_path.join('config').read.match(/^lxc\.arch\s+=\s+(.+)$/)[1]
-        rootfs_dirname = File.dirname rootfs_path
-        basename       = rootfs_path.to_s.gsub(/^#{Regexp.escape rootfs_dirname}\//, '')
-        # TODO: Pass in tmpdir so we can clean up from outside
-        target_path    = "#{Dir.mktmpdir}/rootfs.tar.gz"
-
-        Dir.chdir base_path do
-          @logger.info "Compressing '#{rootfs_path}' rootfs to #{target_path}"
-          system "sudo rm -f rootfs.tar.gz && sudo bsdtar -s /#{basename}/rootfs-#{arch}/ --numeric-owner -czf #{target_path} #{basename}/* 2>/dev/null"
-
-          @logger.info "Changing rootfs tarbal owner"
-          system "sudo chown #{ENV['USER']}:#{ENV['USER']} #{target_path}"
-        end
-
-        target_path
-      end
-
-      def state
-        if @name
-          @cli.state
-        end
-      end
-
-      def assigned_ip
-        ip = ''
-        retryable(:on => LXC::Errors::ExecuteError, :tries => 10, :sleep => 3) do
-          unless ip = get_container_ip_from_ifconfig
-            # retry
-            raise LXC::Errors::ExecuteError, :command => "lxc-attach"
-          end
-        end
-        ip
-      end
-
-      def get_container_ip_from_ifconfig
-        output = @cli.attach '/sbin/ifconfig', '-v', 'eth0', namespaces: 'network'
-        if output =~ /\s+inet addr:([0-9.]+)\s+/
-          return $1.to_s
-        end
-      end
-    end
-  end
-end

data/lib/vagrant-lxc/machine_state.rb

@@ -1,25 +0,0 @@
-module Vagrant
-  module LXC
-    class MachineState < Vagrant::MachineState
-      CREATED_STATES = %w( running stopped ).map!(&:to_sym)
-
-      def initialize(state_id)
-        short = state_id.to_s.gsub("_", " ")
-        long  = I18n.t("vagrant.commands.status.#{state_id}")
-        super(state_id, short, long)
-      end
-
-      def created?
-        CREATED_STATES.include?(self.id)
-      end
-
-      def off?
-        self.id == :stopped
-      end
-
-      def running?
-        self.id == :running
-      end
-    end
-  end
-end

data/spec/fixtures/sample-ifconfig-output

@@ -1,18 +0,0 @@
-eth0      Link encap:Ethernet  HWaddr 00:16:3e:7c:dd:44  
-          inet addr:10.0.3.109  Bcast:10.0.3.255  Mask:255.255.255.0
-          inet6 addr: fe80::216:3eff:fe7c:dd44/64 Scope:Link
-          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
-          RX packets:204 errors:0 dropped:0 overruns:0 frame:0
-          TX packets:203 errors:0 dropped:0 overruns:0 carrier:0
-          collisions:0 txqueuelen:1000 
-          RX bytes:29663 (29.6 KB)  TX bytes:30168 (30.1 KB)
-
-lo        Link encap:Local Loopback  
-          inet addr:127.0.0.1  Mask:255.0.0.0
-          inet6 addr: ::1/128 Scope:Host
-          UP LOOPBACK RUNNING  MTU:16436  Metric:1
-          RX packets:73 errors:0 dropped:0 overruns:0 frame:0
-          TX packets:73 errors:0 dropped:0 overruns:0 carrier:0
-          collisions:0 txqueuelen:0 
-          RX bytes:34173 (34.1 KB)  TX bytes:34173 (34.1 KB)
-

data/spec/unit/container_spec.rb

@@ -1,147 +0,0 @@
-require 'unit_helper'
-
-require 'vagrant'
-require 'vagrant-lxc/container'
-
-describe Vagrant::LXC::Container do
-  let(:name) { nil }
-  subject { described_class.new(name) }
-
-  describe 'container name validation' do
-    let(:unknown_container) { described_class.new('unknown', cli) }
-    let(:valid_container)   { described_class.new('valid', cli) }
-    let(:new_container)     { described_class.new(nil) }
-    let(:cli)               { fire_double('Vagrant::LXC::Container::CLI', list: ['valid']) }
-
-    it 'raises a NotFound error if an unknown container name gets provided' do
-      expect {
-        unknown_container.validate!
-      }.to raise_error(Vagrant::LXC::Container::NotFound)
-    end
-
-    it 'does not raise a NotFound error if a valid container name gets provided' do
-      expect {
-        valid_container.validate!
-      }.to_not raise_error(Vagrant::LXC::Container::NotFound)
-    end
-
-    it 'does not raise a NotFound error if nil is provider as name' do
-      expect {
-        new_container.validate!
-      }.to_not raise_error(Vagrant::LXC::Container::NotFound)
-    end
-  end
-
-  describe 'creation' do
-    let(:base_name)       { 'container-name' }
-    let(:suffix)          { 'random-suffix' }
-    let(:template_name)   { 'template-name' }
-    let(:rootfs_cache)    { '/path/to/cache' }
-    let(:target_rootfs)   { '/path/to/rootfs' }
-    let(:public_key_path) { Vagrant.source_root.join('keys', 'vagrant.pub').expand_path.to_s }
-    let(:cli)             { fire_double('Vagrant::LXC::Container::CLI', :create => true, :name= => true) }
-
-    subject { described_class.new(name, cli) }
-
-    before do
-      SecureRandom.stub(hex: suffix)
-      subject.create base_name, target_rootfs, 'template-name' => template_name, 'rootfs-cache-path' => rootfs_cache, 'template-opts' => { '--foo' => 'bar'}
-    end
-
-    it 'creates container with the right arguments' do
-      cli.should have_received(:name=).with("#{base_name}-#{suffix}")
-      cli.should have_received(:create).with(
-        template_name,
-        target_rootfs,
-        '--auth-key' => public_key_path,
-        '--cache'    => rootfs_cache,
-        '--foo'      => 'bar'
-      )
-    end
-  end
-
-  describe 'destruction' do
-    let(:name) { 'container-name' }
-    let(:cli)  { fire_double('Vagrant::LXC::Container::CLI', destroy: true) }
-
-    subject { described_class.new(name, cli) }
-
-    before { subject.destroy }
-
-    it 'delegates to cli object' do
-      cli.should have_received(:destroy)
-    end
-  end
-
-  describe 'start' do
-    let(:config) { mock(:config, start_opts: ['a=1', 'b=2']) }
-    let(:name)   { 'container-name' }
-    let(:cli)    { fire_double('Vagrant::LXC::Container::CLI', start: true) }
-
-    subject { described_class.new(name, cli) }
-
-    before do
-      cli.stub(:transition_to).and_yield(cli)
-    end
-
-    it 'starts container with configured lxc settings' do
-      cli.should_receive(:start).with(['a=1', 'b=2'], nil)
-      subject.start(config)
-    end
-
-    it 'expects a transition to running state to take place' do
-      cli.should_receive(:transition_to).with(:running)
-      subject.start(config)
-    end
-  end
-
-  describe 'halt' do
-    let(:name) { 'container-name' }
-    let(:cli)  { fire_double('Vagrant::LXC::Container::CLI', shutdown: true) }
-
-    subject { described_class.new(name, cli) }
-
-    before do
-      cli.stub(:transition_to).and_yield(cli)
-    end
-
-    it 'delegates to cli shutdown' do
-      cli.should_receive(:shutdown)
-      subject.halt
-    end
-
-    it 'expects a transition to running state to take place' do
-      cli.should_receive(:transition_to).with(:stopped)
-      subject.halt
-    end
-  end
-
-  describe 'state' do
-    let(:name)      { 'random-container-name' }
-    let(:cli_state) { :something }
-    let(:cli)       { fire_double('Vagrant::LXC::Container::CLI', state: cli_state) }
-
-    subject { described_class.new(name, cli) }
-
-    it 'delegates to cli' do
-      subject.state.should == cli_state
-    end
-  end
-
-  describe 'assigned ip' do
-    # This ip is set on the sample-ifconfig-output fixture
-    let(:ip)              { "10.0.3.109" }
-    let(:ifconfig_output) { File.read('spec/fixtures/sample-ifconfig-output') }
-    let(:name)            { 'random-container-name' }
-    let(:cli)             { fire_double('Vagrant::LXC::Container::CLI', :attach => ifconfig_output) }
-
-    subject { described_class.new(name, cli) }
-
-    context 'when ip for eth0 gets returned from lxc-attach call' do
-      it 'gets parsed from ifconfig output' do
-        subject.assigned_ip.should == ip
-        cli.should have_received(:attach).with('/sbin/ifconfig', '-v', 'eth0', namespaces: 'network')
-      end
-    end
-  end
-end

data/spec/unit/machine_state_spec.rb

@@ -1,39 +0,0 @@
-require 'unit_helper'
-
-require 'vagrant-lxc/machine_state'
-
-describe Vagrant::LXC::MachineState do
-  describe 'short description' do
-    subject { described_class.new(:not_created) }
-
-    it 'is a humanized version of state id' do
-      subject.short_description.should == 'not created'
-    end
-  end
-
-  describe 'long description' do
-    subject { described_class.new(:short_name) }
-    before  { I18n.stub(t: 'some really long description') }
-
-    it 'is a localized version of the state id' do
-      subject.long_description.should == 'some really long description'
-      I18n.should have_received(:t).with('vagrant.commands.status.short_name')
-    end
-  end
-
-  context 'when state id is :running' do
-    subject { described_class.new(:running) }
-
-    it { should be_created }
-    it { should be_running }
-    it { should_not be_off }
-  end
-
-  context 'when state id is :stopped' do
-    subject { described_class.new(:stopped) }
-
-    it { should be_created }
-    it { should be_off }
-    it { should_not be_running }
-  end
-end