vagrant-lxc-2.1-patch 1.4.0

data/spec/Vagrantfile

@@ -0,0 +1,26 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.require_plugin 'vagrant-lxc'
+Vagrant.require_plugin 'vagrant-cachier'
+
+ENV['BOX_NAME'] ||= 'quantal64'
+puts "Running vagrant commands using #{ENV['BOX_NAME']} box"
+
+Vagrant.configure("2") do |config|
+  config.vm.box = ENV['BOX_NAME']
+  config.vm.hostname = 'lxc-test-box'
+  config.vm.box_url = ENV['BOX_URL']
+  config.vm.network :forwarded_port, guest: 80, host: 8080
+
+  config.cache.auto_detect = true
+
+  config.vm.provision :shell,
+    inline: 'mkdir -p /vagrant/tmp && echo -n "Provisioned" > /vagrant/tmp/provisioning'
+
+  config.vm.provision :shell,
+    inline: 'apt-get install apache2 -y'
+
+  config.vm.provision :shell, privileged: false,
+    inline: "if ! [ -f $HOME/original-box ]; then echo '#{ENV['BOX_NAME']}' > $HOME/original-box; fi"
+end

data/spec/fixtures/sample-ip-addr-output

@@ -0,0 +1,2 @@
+49: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
+    inet 10.0.254.137/24 brd 10.0.254.255 scope global eth0

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+if ENV['COVERAGE']
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.start { add_filter '/spec/' }
+  SimpleCov.merge_timeout 300
+end
+
+require 'bundler/setup'
+
+require 'i18n'
+
+require 'vagrant-lxc'
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.mock_with :rspec do |c|
+    c.yield_receiver_to_any_instance_implementation_blocks = true
+  end
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+  config.raise_errors_for_deprecations!
+end

data/spec/unit/action/clear_forwarded_ports_spec.rb

@@ -0,0 +1,43 @@
+require 'unit_helper'
+
+require 'tmpdir'
+require 'vagrant-lxc/action/clear_forwarded_ports'
+
+describe Vagrant::LXC::Action::ClearForwardedPorts do
+  let(:app)       { double(:app, call: true) }
+  let(:env)       { {machine: machine, ui: double(info: true)} }
+  let(:machine)   { double(:machine, data_dir: data_dir) }
+  let!(:data_dir) { Pathname.new(Dir.mktmpdir) }
+  let(:pids_dir)  { data_dir.join('pids') }
+  let(:pid)       { 'a-pid' }
+  let(:pid_cmd)   { 'redir' }
+
+  subject { described_class.new(app, env) }
+
+  before do
+    pids_dir.mkdir
+    pids_dir.join('redir_1234.pid').open('w') { |f| f.write(pid) }
+    subject.stub(system: true, :` => pid_cmd)
+    subject.call(env)
+  end
+
+  after { FileUtils.rm_rf data_dir.to_s }
+
+  it 'removes all files under pid directory' do
+    expect(Dir[pids_dir.to_s + "/redir_*.pid"]).to be_empty
+  end
+
+  context 'with a valid redir pid' do
+    it 'kills known processes' do
+      expect(subject).to have_received(:system).with("pkill -TERM -P #{pid}")
+    end
+  end
+
+  context 'with an invalid pid' do
+    let(:pid_cmd) { 'sudo ls' }
+
+    it 'does not kill the process' do
+      expect(subject).not_to have_received(:system).with("pkill -TERM -P #{pid}")
+    end
+  end
+end

data/spec/unit/action/compress_rootfs_spec.rb

@@ -0,0 +1,29 @@
+require 'unit_helper'
+
+require 'vagrant-lxc/plugin'
+require 'vagrant-lxc/provider'
+require 'vagrant-lxc/action/compress_rootfs'
+
+describe Vagrant::LXC::Action::CompressRootFS do
+  let(:app)                    { double(:app, call: true) }
+  let(:env)                    { {machine: machine, ui: double(info: true)} }
+  let(:machine)                { double(Vagrant::Machine, provider: provider) }
+  let(:provider)               { double(Vagrant::LXC::Provider, driver: driver) }
+  let(:driver)                 { double(Vagrant::LXC::Driver, compress_rootfs: compressed_rootfs_path) }
+  let(:compressed_rootfs_path) { '/path/to/rootfs.tar.gz' }
+
+  subject { described_class.new(app, env) }
+
+  before do
+    provider.stub_chain(:state, :id).and_return(:stopped)
+    subject.call(env)
+  end
+
+  it "asks the driver to compress container's rootfs" do
+    expect(driver).to have_received(:compress_rootfs)
+  end
+
+  it 'sets export.temp_dir on action env' do
+    expect(env['package.rootfs']).to eq(compressed_rootfs_path)
+  end
+end

data/spec/unit/action/forward_ports_spec.rb

@@ -0,0 +1,117 @@
+require 'unit_helper'
+
+require 'tmpdir'
+require 'vagrant-lxc/provider'
+require 'vagrant-lxc/action/forward_ports'
+
+describe Vagrant::LXC::Action::ForwardPorts do
+  let(:app)          { double(:app, call: true) }
+  let(:env)          { {machine: machine, ui: double(info: true, warn: true)} }
+  let(:machine)      { double(:machine) }
+  let!(:data_dir)    { Pathname.new(Dir.mktmpdir) }
+  let(:provider)     { double(Vagrant::LXC::Provider, ssh_info: {host: container_ip}) }
+  let(:host_ip)      { '127.0.0.1' }
+  let(:host_port)    { 8080 }
+  let(:guest_port)   { 80 }
+  let(:container_ip) { '10.0.1.234' }
+  let(:pid)          { 'a-pid' }
+  let(:forward_conf) { {guest: guest_port, host: host_port, host_ip: host_ip} }
+  let(:networks)     { [[:other_config, {}], [:forwarded_port, forward_conf]] }
+
+  subject { described_class.new(app, env) }
+
+  before do
+    machine.stub_chain(:config, :vm, :networks).and_return(networks)
+    machine.stub(provider: provider, data_dir: data_dir)
+
+    subject.stub(redir_version: 3)
+    subject.stub(exec: true)
+    subject.stub(spawn: pid)
+  end
+
+  after { FileUtils.rm_rf data_dir.to_s }
+
+  it 'forwards ports using redir' do
+    subject.stub(system: true)
+    subject.call(env)
+    expect(subject).to have_received(:spawn).with(
+      "redir #{host_ip}:#{host_port} #{container_ip}:#{guest_port} 2>/dev/null"
+    )
+  end
+
+  it 'Uses 127.0.0.1 as default if host_ip is nil' do
+    forward_conf.delete(:host_ip)
+    subject.stub(system: true)
+    subject.call(env)
+    expect(subject).to have_received(:spawn).with(
+      "redir 127.0.0.1:#{host_port} #{container_ip}:#{guest_port} 2>/dev/null"
+    )
+  end
+
+  it 'Uses 127.0.0.1 by default if host_ip is a blank string' do
+    forward_conf[:host_ip] = ' '
+    subject.stub(system: true)
+    subject.call(env)
+    expect(subject).to have_received(:spawn).with(
+      "redir 127.0.0.1:#{host_port} #{container_ip}:#{guest_port} 2>/dev/null"
+    )
+  end
+
+  it "stores redir pids on machine's data dir" do
+    subject.stub(system: true)
+    subject.call(env)
+    pid_file = data_dir.join('pids', "redir_#{host_port}.pid").read
+    expect(pid_file).to eq(pid)
+  end
+
+  it 'allows disabling a previously forwarded port' do
+    forward_conf[:disabled] = true
+    subject.stub(system: true)
+    subject.call(env)
+    expect(subject).not_to have_received(:spawn)
+  end
+
+  it 'uses redir 2.x command line interface' do
+    subject.stub(system: true)
+    subject.stub(redir_version: 2)
+    subject.call(env)
+    expect(subject).to have_received(:spawn).with(
+      "redir --laddr=#{host_ip} --lport=#{host_port} --caddr=#{container_ip} --cport=#{guest_port} 2>/dev/null"
+    )
+  end
+
+  it 'raises RedirNotInstalled error if `redir` is not installed' do
+    subject.stub(system: false)
+    expect { subject.call(env) }.to raise_error(Vagrant::LXC::Errors::RedirNotInstalled)
+  end
+
+  context 'when a privileged port is used' do
+    let(:host_port) { 80 }
+
+    it 'forwards ports using redir' do
+      subject.stub(system: true)
+      subject.call(env)
+      expect(subject).to have_received(:spawn).with(
+        "sudo redir #{host_ip}:#{host_port} #{container_ip}:#{guest_port} 2>/dev/null"
+      )
+    end
+
+    it 'Uses 127.0.0.1 by default if host_ip is nil' do
+      forward_conf.delete(:host_ip)
+      subject.stub(system: true)
+      subject.call(env)
+      expect(subject).to have_received(:spawn).with(
+        "sudo redir 127.0.0.1:#{host_port} #{container_ip}:#{guest_port} 2>/dev/null"
+      )
+    end
+
+    it 'Uses 127.0.0.1 by default if host_ip is a blank string' do
+      forward_conf[:host_ip] = ' '
+      subject.stub(system: true)
+      subject.call(env)
+      expect(subject).to have_received(:spawn).with(
+        "sudo redir 127.0.0.1:#{host_port} #{container_ip}:#{guest_port} 2>/dev/null"
+      )
+    end
+  end
+end

data/spec/unit/action/handle_box_metadata_spec.rb

@@ -0,0 +1,126 @@
+require 'unit_helper'
+
+require 'vagrant'
+require 'vagrant-lxc/errors'
+require 'vagrant-lxc/action/handle_box_metadata'
+
+describe Vagrant::LXC::Action::HandleBoxMetadata do
+  let(:app)           { double(:app, call: true) }
+  let(:env)           { {machine: machine, ui: double(info: true, warn: true)} }
+  let(:machine)       { double(:machine, box: box) }
+  let(:box)           { double(:box, name: 'box-name', metadata: metadata, directory: box_directory) }
+  let(:box_directory) { Pathname.new('/path/to/box') }
+  let(:version)       { '2' }
+  let(:metadata)      { {'template-opts' => {'--foo' => 'bar'}, 'version' => version} }
+  let(:vagrant_key)   { Vagrant.source_root.join('keys', 'vagrant.pub').expand_path.to_s }
+
+  subject { described_class.new(app, env) }
+
+  context 'with 1.0.0 box' do
+    let(:version) { '1.0.0' }
+
+    before do
+      File.stub(exists?: true)
+      # REFACTOR: This is pretty bad
+      subject.stub_chain(:template_config_file, :exist?).and_return(true)
+      subject.stub_chain(:template_config_file, :to_s).and_return(box_directory.join('lxc-config').to_s)
+      subject.call(env)
+    end
+
+    it 'sets the tarball argument for the template' do
+      expect(env[:lxc_template_opts]).to include(
+        '--tarball' => box_directory.join('rootfs.tar.gz').to_s
+      )
+    end
+
+    it 'sets the template --config parameter' do
+      expect(env[:lxc_template_opts]).to include(
+        '--config' => box_directory.join('lxc-config').to_s
+      )
+    end
+
+    it 'does not set the auth key argument for the template' do
+      expect(env[:lxc_template_opts]).not_to include(
+        '--auth-key' => vagrant_key
+      )
+    end
+
+    it 'sets the template options from metadata on env hash' do
+      expect(env[:lxc_template_opts]).to include(metadata['template-opts'])
+    end
+
+    xit 'sets the template source path on env hash' do
+      expect(env[:lxc_template_src]).to eq(box_directory.join('lxc-template').to_s)
+    end
+
+    it 'does not warn about deprecation' do
+      expect(env[:ui]).not_to have_received(:warn)
+    end
+  end
+
+  context 'with valid pre 1.0.0 box' do
+    before do
+      File.stub(exists?: true)
+      # REFACTOR: This is pretty bad
+      subject.stub_chain(:old_template_config_file, :exist?).and_return(true)
+      subject.stub_chain(:old_template_config_file, :to_s).and_return(box_directory.join('lxc.conf').to_s)
+      subject.call(env)
+    end
+
+    it 'sets the tarball argument for the template' do
+      expect(env[:lxc_template_opts]).to include(
+        '--tarball' => box_directory.join('rootfs.tar.gz').to_s
+      )
+    end
+
+    it 'sets the auth key argument for the template' do
+      expect(env[:lxc_template_opts]).to include(
+        '--auth-key' => vagrant_key
+      )
+    end
+
+    it 'sets the lxc config file parameter' do
+      expect(env[:lxc_template_config]).to eq(box_directory.join('lxc.conf').to_s)
+    end
+
+    it 'sets the template options from metadata on env hash' do
+      expect(env[:lxc_template_opts]).to include(metadata['template-opts'])
+    end
+
+    xit 'sets the template source path on env hash' do
+      expect(env[:lxc_template_src]).to eq(box_directory.join('lxc-template').to_s)
+    end
+
+    it 'warns about deprecation' do
+      expect(env[:ui]).to have_received(:warn)
+    end
+  end
+
+  describe 'with invalid contents' do
+    before { File.stub(exists?: true) }
+
+    it 'validates box versions' do
+      %w( 2 3 1.0.0 ).each do |v|
+        metadata['version'] = v
+        expect { subject.call(env) }.to_not raise_error
+      end
+
+      metadata['version'] = '1'
+      expect { subject.call(env) }.to raise_error
+    end
+
+    it 'raises an error if the rootfs tarball cant be found' do
+      allow(File).to receive(:exists?).with(box_directory.join('rootfs.tar.gz').to_s).and_return(false)
+      expect {
+        subject.call(env)
+      }.to raise_error(Vagrant::LXC::Errors::RootFSTarballMissing)
+    end
+
+    it 'does not raise an error if the lxc-template script cant be found' do
+      allow(File).to receive(:exists?).with(box_directory.join('lxc-template').to_s).and_return(false)
+      expect {
+        subject.call(env)
+      }.to_not raise_error
+    end
+  end
+end

data/spec/unit/action/setup_package_files_spec.rb

@@ -0,0 +1,83 @@
+require 'unit_helper'
+
+require 'vagrant-lxc/action/setup_package_files'
+
+describe Vagrant::LXC::Action::SetupPackageFiles do
+  let(:app)         { double(:app, call: true) }
+  let(:env)         { {machine: machine, tmp_path: tmp_path, ui: double(info: true), 'package.rootfs' => rootfs_path} }
+  let(:machine)     { double(Vagrant::Machine, box: box) }
+  let!(:tmp_path)   { Pathname.new(Dir.mktmpdir) }
+  let(:box)         { double(Vagrant::Box, directory: tmp_path.join('box')) }
+  let(:rootfs_path) { tmp_path.join('rootfs-amd64.tar.gz') }
+
+  subject { described_class.new(app, env) }
+
+  before do
+    box.directory.mkdir
+    files = %w( lxc-template metadata.json lxc.conf lxc-config ).map { |f| box.directory.join(f) }
+    (files + [rootfs_path]).each do |file|
+      file.open('w') { |f| f.puts file.to_s }
+    end
+
+    subject.stub(recover: true) # Prevents files from being removed on specs
+  end
+
+  after do
+    FileUtils.rm_rf(tmp_path.to_s)
+  end
+
+  context 'when all files exist' do
+    before { subject.call(env) }
+
+    it 'copies box lxc-template to package directory' do
+      expect(env['package.directory'].join('lxc-template')).to be_file
+    end
+
+    it 'copies metadata.json to package directory' do
+      expect(env['package.directory'].join('metadata.json')).to be_file
+    end
+
+    it 'copies box lxc.conf to package directory' do
+      expect(env['package.directory'].join('lxc-template')).to be_file
+    end
+
+    it 'copies box lxc-config to package directory' do
+      expect(env['package.directory'].join('lxc-config')).to be_file
+    end
+
+    it 'moves the compressed rootfs to package directory' do
+      expect(env['package.directory'].join(rootfs_path.basename)).to be_file
+      expect(env['package.rootfs']).not_to be_file
+    end
+  end
+
+  context 'when lxc-template file is not present' do
+    before do
+      box.directory.join('lxc-template').delete
+    end
+
+    it 'does not blow up' do
+      expect { subject.call(env) }.to_not raise_error
+    end
+  end
+
+  context 'when lxc.conf file is not present' do
+    before do
+      box.directory.join('lxc.conf').delete
+    end
+
+    it 'does not blow up' do
+      expect { subject.call(env) }.to_not raise_error
+    end
+  end
+
+  context 'when lxc-config file is not present' do
+    before do
+      box.directory.join('lxc-config').delete
+    end
+
+    it 'does not blow up' do
+      expect { subject.call(env) }.to_not raise_error
+    end
+  end
+end