vagrant-lxc-2.1-patch 1.4.0

data/spec/unit/driver/cli_spec.rb

@@ -0,0 +1,263 @@
+require 'unit_helper'
+
+require 'vagrant-lxc/sudo_wrapper'
+require 'vagrant-lxc/driver/cli'
+
+describe Vagrant::LXC::Driver::CLI do
+  let(:sudo_wrapper) { double(Vagrant::LXC::SudoWrapper, run: true, wrapper_path: nil) }
+
+  subject { described_class.new(sudo_wrapper) }
+
+  describe 'list' do
+    let(:lxc_ls_out) { "dup-container\na-container dup-container" }
+    let(:result)     { @result }
+
+    before do
+      allow(subject).to receive(:run).with(:ls).and_return(lxc_ls_out)
+      @result = subject.list
+    end
+
+    it 'grabs previously created containers from lxc-ls output' do
+      expect(result).to be_an Enumerable
+      expect(result).to include 'a-container'
+      expect(result).to include 'dup-container'
+    end
+
+    it 'removes duplicates from lxc-ls output' do
+      expect(result.uniq).to eq(result)
+    end
+  end
+
+  describe 'version' do
+    before do
+      allow(subject).to receive(:run).with(:create, '--version').and_return(lxc_version_out)
+    end
+
+    describe 'lxc version after 1.x.x' do
+      let(:lxc_version_out) { "1.0.0\n" }
+
+      it 'parses the version from the output' do
+        expect(subject.version).to eq('1.0.0')
+      end
+    end
+  end
+
+  describe 'config' do
+    before do
+      allow(subject).to receive(:run).with(:config, 'lxc.lxcpath').and_return(lxc_config_out)
+      allow(subject).to receive(:run).with(:create, '--version').and_return(lxc_version_out)
+    end
+
+    describe 'lxc version after 1.x.x'do
+      let(:lxc_config_out)           { "/var/lib/lxc\n" }
+      let(:lxc_version_out)          { "1.0.0\n" }
+
+      it 'parser the lxc.lxcpath value' do
+        expect(subject.config('lxc.lxcpath')).not_to end_with("\n")
+      end
+    end
+  end
+
+  describe 'create' do
+    let(:template)          { 'quantal-64' }
+    let(:name)              { 'quantal-container' }
+    let(:backingstore)      { 'btrfs' }
+    let(:backingstore_opts) { [['--dir', '/tmp/foo'], ['--foo', 'bar']] }
+    let(:config_file)       { 'config' }
+    let(:template_args)     { { '--extra-param' => 'param', '--other' => 'value' } }
+
+    subject { described_class.new(sudo_wrapper, name) }
+
+    before do
+      allow(subject).to receive(:run) { |*args| @run_args = args }
+    end
+
+    it 'issues a lxc-create with provided template, container name and hash of arguments' do
+      subject.create(template, backingstore, backingstore_opts, config_file, template_args)
+      expect(subject).to have_received(:run).with(
+        :create,
+        '-B',         backingstore,
+        '--template', template,
+        '--name',     name,
+        *(backingstore_opts.flatten),
+        '-f',         config_file,
+        '--',
+        '--extra-param', 'param',
+        '--other',       'value'
+      )
+    end
+
+    it 'wraps a low level error into something more meaningful in case the container already exists' do
+      allow(subject).to receive(:run) { raise Vagrant::LXC::Errors::ExecuteError, stderr: 'alreAdy Exists' }
+      expect {
+        subject.create(template, backingstore, backingstore_opts, config_file, template_args)
+      }.to raise_error(Vagrant::LXC::Errors::ContainerAlreadyExists)
+    end
+  end
+
+  describe 'destroy' do
+    let(:name) { 'a-container-for-destruction' }
+
+    subject { described_class.new(sudo_wrapper, name) }
+
+    before do
+      allow(subject).to receive(:run)
+      subject.destroy
+    end
+
+    it 'issues a lxc-destroy with container name' do
+      expect(subject).to have_received(:run).with(:destroy, '--name', name)
+    end
+  end
+
+  describe 'start' do
+    let(:name) { 'a-container' }
+    subject    { described_class.new(sudo_wrapper, name) }
+
+    before do
+      allow(subject).to receive(:run)
+    end
+
+    it 'starts container on the background' do
+      subject.start
+      expect(subject).to have_received(:run).with(
+        :start,
+        '-d',
+        '--name',  name
+      )
+    end
+  end
+
+  describe 'stop' do
+    let(:name) { 'a-running-container' }
+    subject    { described_class.new(sudo_wrapper, name) }
+
+    before do
+      allow(subject).to receive(:run)
+    end
+
+    context 'lxc-attach is supported' do
+      before do
+        subject.stub(attach: true, supports_attach?: true)
+        subject.stop
+      end
+
+      it 'runs a /sbin/halt within the container' do
+        expect(subject).to have_received(:attach).with('/sbin/halt')
+      end
+
+      it 'issues a lxc-stop with provided container name' do
+        expect(subject).to have_received(:run).with(:stop, '--name', name)
+      end
+    end
+
+    context 'lxc-attach is not supported' do
+      before do
+        subject.stub(attach: false, supports_attach?: false)
+        subject.stop
+      end
+
+      it 'runs a /sbin/halt within the container' do
+        expect(subject).to_not have_received(:attach)
+      end
+
+      it 'issues a lxc-stop with provided container name' do
+        expect(subject).to have_received(:run).with(:stop, '--name', name)
+      end
+    end
+  end
+
+  describe 'state' do
+    let(:name) { 'a-container' }
+    subject    { described_class.new(sudo_wrapper, name) }
+
+    before do
+      allow(subject).to receive(:run).and_return("state: STOPPED\npid: 2")
+    end
+
+    it 'calls lxc-info with the right arguments' do
+      subject.state
+      expect(subject).to have_received(:run).with(:info, '--name', name, retryable: true)
+    end
+
+    it 'maps the output of lxc-info status out to a symbol' do
+      expect(subject.state).to eq(:stopped)
+    end
+
+    it 'is not case sensitive' do
+      allow(subject).to receive(:run).and_return("StatE: STarTED\npid: 2")
+      expect(subject.state).to eq(:started)
+    end
+  end
+
+  describe 'attach' do
+    let(:name)           { 'a-running-container' }
+    let(:command)        { ['ls', 'cat /tmp/file'] }
+    let(:command_output) { 'folders list' }
+    subject              { described_class.new(sudo_wrapper, name) }
+
+    before do
+      subject.stub(run: command_output)
+    end
+
+    it 'calls lxc-attach with specified command' do
+      subject.attach(*command)
+      expect(subject).to have_received(:run).with(:attach, '--name', name, '--', *command)
+    end
+
+    it 'supports a "namespaces" parameter' do
+      allow(subject).to receive(:run).with(:attach, '-h', :show_stderr => true).and_return({:stdout => '', :stderr => '--namespaces'})
+      subject.attach *(command + [{namespaces: ['network', 'mount']}])
+      expect(subject).to have_received(:run).with(:attach, '--name', name, '--namespaces', 'NETWORK|MOUNT', '--', *command)
+    end
+  end
+
+  describe 'transition block' do
+    before do
+      subject.stub(run: true, sleep: true, state: :stopped)
+    end
+
+    it 'yields a cli object' do
+      allow(subject).to receive(:shutdown)
+      subject.transition_to(:stopped) { |c| c.shutdown }
+      expect(subject).to have_received(:shutdown)
+    end
+
+    it 'throws an exception if block is not provided' do
+      expect {
+        subject.transition_to(:running)
+      }.to raise_error(described_class::TransitionBlockNotProvided)
+    end
+
+    skip 'waits for the expected container state'
+  end
+
+  describe 'check for whether lxc-attach is supported' do
+    let(:name) { 'a-running-container' }
+    subject    { described_class.new(sudo_wrapper, name) }
+
+    context 'lxc-attach is present on system' do
+      before { subject.stub(run: true) }
+
+      it 'returns true if `lxc-attach --name CNAME -- /bin/true` works' do
+        expect(subject.supports_attach?).to be_truthy
+        expect(subject).to have_received(:run).with(
+          :attach, '--name', name, '--', '/bin/true'
+        )
+      end
+    end
+
+    context 'lxc-attach is not present on system' do
+      before do
+        allow(subject).to receive(:run).and_raise(Vagrant::LXC::Errors::ExecuteError.new('msg'))
+      end
+
+      it 'returns true if `lxc-attach --name CNAME -- /bin/true` works' do
+        expect(subject.supports_attach?).to be_falsy
+        expect(subject).to have_received(:run).with(
+          :attach, '--name', name, '--', '/bin/true'
+        )
+      end
+    end
+  end
+end

data/spec/unit/driver_spec.rb

@@ -0,0 +1,268 @@
+require 'unit_helper'
+
+require 'vagrant-lxc/driver'
+require 'vagrant-lxc/driver/cli'
+require 'vagrant-lxc/sudo_wrapper'
+
+describe Vagrant::LXC::Driver do
+  describe 'container name validation' do
+    let(:unknown_container) { described_class.new('unknown', nil, cli) }
+    let(:valid_container)   { described_class.new('valid', nil, cli) }
+    let(:new_container)     { described_class.new(nil, nil) }
+    let(:cli)               { double(Vagrant::LXC::Driver::CLI, list: ['valid']) }
+
+    it 'raises a ContainerNotFound error if an unknown container name gets provided' do
+      expect {
+        unknown_container.validate!
+      }.to raise_error
+    end
+
+    it 'does not raise a ContainerNotFound error if a valid container name gets provided' do
+      expect {
+        valid_container.validate!
+      }.not_to raise_error
+    end
+
+    it 'does not raise a ContainerNotFound error if nil is provider as name' do
+      expect {
+        new_container.validate!
+      }.not_to raise_error
+    end
+  end
+
+  describe 'creation' do
+    let(:name)              { 'container-name' }
+    let(:backingstore)      { 'btrfs' }
+    let(:backingstore_opts) { [['--dir', '/tmp/foo'], ['--foo', 'bar']] }
+    let(:template_name)     { 'auto-assigned-template-id' }
+    let(:template_path)     { '/path/to/lxc-template-from-box' }
+    let(:template_opts)     { {'--some' => 'random-option'} }
+    let(:config_file)       { '/path/to/lxc-config-from-box' }
+    let(:rootfs_tarball)    { '/path/to/cache/rootfs.tar.gz' }
+    let(:cli)               { double(Vagrant::LXC::Driver::CLI, :create => true, :name= => true) }
+
+    subject { described_class.new(nil, nil, cli) }
+
+    before do
+      allow(subject).to receive(:import_template).and_yield(template_name)
+      subject.create name, backingstore, backingstore_opts, template_path, config_file, template_opts
+    end
+
+    it 'sets the cli object container name' do
+      expect(cli).to have_received(:name=).with(name)
+    end
+
+    it 'creates container with the right arguments' do
+      expect(cli).to have_received(:create).with(
+        template_path,
+        backingstore,
+        backingstore_opts,
+        config_file,
+        template_opts
+      )
+    end
+  end
+
+  describe 'destruction' do
+    let(:cli) { double(Vagrant::LXC::Driver::CLI, destroy: true) }
+
+    subject { described_class.new('name', nil, cli) }
+
+    before { subject.destroy }
+
+    it 'delegates to cli object' do
+      expect(cli).to have_received(:destroy)
+    end
+  end
+
+  describe 'supports_attach?' do
+    let(:cli) { double(Vagrant::LXC::Driver::CLI, supports_attach?: true) }
+
+    subject { described_class.new('name', nil, cli) }
+
+    it 'delegates to cli object' do
+      expect(subject.supports_attach?).to be_truthy
+      expect(cli).to have_received(:supports_attach?)
+    end
+  end
+
+  describe 'start' do
+    let(:customizations)         { [['a', '1'], ['b', '2']] }
+    let(:internal_customization) { ['internal', 'customization'] }
+    let(:cli)                    { double(Vagrant::LXC::Driver::CLI, start: true) }
+    let(:sudo)                   { double(Vagrant::LXC::SudoWrapper) }
+
+    subject { described_class.new('name', sudo, cli) }
+
+    before do
+      sudo.should_receive(:run).with('cat', '/var/lib/lxc/name/config').exactly(2).times.
+        and_return('# CONFIGURATION')
+      sudo.should_receive(:run).twice.with('cp', '-f', %r{/(run|tmp)/.*}, '/var/lib/lxc/name/config')
+      sudo.should_receive(:run).twice.with('chown', 'root:root', '/var/lib/lxc/name/config')
+      expect(cli).to receive(:config).with("lxc.lxcpath").and_return("/var/lib/lxc")
+
+      subject.customizations << internal_customization
+      subject.start(customizations)
+    end
+
+    it 'prunes previous customizations before writing'
+
+    it 'writes configurations to config file'
+
+    it 'starts container with configured customizations' do
+      expect(cli).to have_received(:start)
+    end
+  end
+
+  describe 'halt' do
+    let(:cli) { double(Vagrant::LXC::Driver::CLI, stop: true) }
+
+    subject { described_class.new('name', nil, cli) }
+
+    before do
+      allow(cli).to receive(:transition_to).and_yield(cli)
+    end
+
+    it 'delegates to cli stop' do
+      expect(cli).to receive(:stop)
+      subject.forced_halt
+    end
+
+    it 'expects a transition to running state to take place' do
+      expect(cli).to receive(:transition_to).with(:stopped)
+      subject.forced_halt
+    end
+
+    it 'attempts to force the container to stop in case a shutdown doesnt work' do
+      allow(cli).to receive(:shutdown).and_raise(Vagrant::LXC::Driver::CLI::TargetStateNotReached.new :target, :source)
+      expect(cli).to receive(:transition_to).with(:stopped)
+      expect(cli).to receive(:stop)
+      subject.forced_halt
+    end
+  end
+
+  describe 'state' do
+    let(:cli_state) { :something }
+    let(:cli)       { double(Vagrant::LXC::Driver::CLI, state: cli_state) }
+
+    subject { described_class.new('name', nil, cli) }
+
+    it 'delegates to cli' do
+      expect(subject.state).to eq(cli_state)
+    end
+  end
+
+  describe 'containers_path' do
+    let(:cli) { double(Vagrant::LXC::Driver::CLI, config: cli_config_value) }
+
+    subject { described_class.new('name', nil, cli) }
+
+    describe 'lxc version after 1.x.x' do
+      let(:cli_config_value)                 { '/etc/lxc' }
+
+      it 'delegates to cli' do
+        expect(subject.containers_path).to eq(cli_config_value)
+      end
+    end
+  end
+
+  describe 'folder sharing' do
+    let(:shared_folder)       { {guestpath: '/vagrant', hostpath: '/path/to/host/dir'} }
+    let(:ro_rw_folder)        { {guestpath: '/vagrant/ro_rw', hostpath: '/path/to/host/dir', mount_options: ['ro', 'rw']} }
+    let(:with_space_folder)   { {guestpath: '/tmp/with space', hostpath: '/path/with space'} }
+    let(:folders)             { [shared_folder, ro_rw_folder, with_space_folder] }
+    let(:expected_guest_path) { "vagrant" }
+    let(:sudo_wrapper)        { double(Vagrant::LXC::SudoWrapper, run: true) }
+    let(:rootfs_path)         { Pathname('/path/to/rootfs') }
+
+    subject { described_class.new('name', sudo_wrapper) }
+
+    describe "with fixed rootfs" do
+      before do
+        subject.stub(rootfs_path: Pathname('/path/to/rootfs'), system: true)
+        subject.share_folders(folders)
+      end
+
+      it 'adds a mount.entry to its local customizations' do
+        expect(subject.customizations).to include [
+          'mount.entry',
+          "#{shared_folder[:hostpath]} #{expected_guest_path} none bind,create=dir 0 0"
+        ]
+      end
+
+      it 'supports additional mount options' do
+        expect(subject.customizations).to include [
+          'mount.entry',
+          "#{ro_rw_folder[:hostpath]} vagrant/ro_rw none ro,rw 0 0"
+        ]
+      end
+
+      it 'supports directories with spaces' do
+        expect(subject.customizations).to include [
+          'mount.entry',
+          "/path/with\\040space tmp/with\\040space none bind,create=dir 0 0"
+        ]
+      end
+    end
+
+    describe "with directory-based LXC config" do
+      let(:config_string) {
+        <<-ENDCONFIG.gsub(/^\s+/, '')
+          # Blah blah comment
+          lxc.mount.entry = proc proc proc nodev,noexec,nosuid 0 0
+          lxc.mount.entry = sysfs sys sysfs defaults  0 0
+          lxc.tty = 4
+          lxc.pts = 1024
+          lxc.rootfs = #{rootfs_path}
+          # VAGRANT-BEGIN
+          lxc.network.type=veth
+          lxc.network.name=eth1
+          # VAGRANT-END
+        ENDCONFIG
+      }
+
+      before do
+        subject { described_class.new('name', sudo_wrapper) }
+        subject.stub(config_string: config_string)
+        subject.share_folders(folders)
+      end
+
+      it 'adds a mount.entry to its local customizations' do
+        expect(subject.customizations).to include [
+          'mount.entry',
+          "#{shared_folder[:hostpath]} #{expected_guest_path} none bind,create=dir 0 0"
+        ]
+      end
+    end
+
+    describe "with overlayfs-based LXC config" do
+      let(:config_string) {
+        <<-ENDCONFIG.gsub(/^\s+/, '')
+          # Blah blah comment
+          lxc.mount.entry = proc proc proc nodev,noexec,nosuid 0 0
+          lxc.mount.entry = sysfs sys sysfs defaults  0 0
+          lxc.tty = 4
+          lxc.pts = 1024
+          lxc.rootfs = overlayfs:/path/to/master/directory:#{rootfs_path}
+          # VAGRANT-BEGIN
+          lxc.network.type=veth
+          lxc.network.name=eth1
+          # VAGRANT-END
+        ENDCONFIG
+      }
+
+      before do
+        subject { described_class.new('name', sudo_wrapper) }
+        subject.stub(config_string: config_string)
+        subject.share_folders(folders)
+      end
+
+      it 'adds a mount.entry to its local customizations' do
+        expect(subject.customizations).to include [
+          'mount.entry',
+          "#{shared_folder[:hostpath]} #{expected_guest_path} none bind,create=dir 0 0"
+        ]
+      end
+    end
+  end
+end