vagrant-lxc 0.0.1

data/lib/vagrant-lxc/container/cli.rb

@@ -0,0 +1,124 @@
+require "vagrant/util/retryable"
+require "vagrant/util/subprocess"
+
+require "vagrant-lxc/errors"
+
+module Vagrant
+  module LXC
+    class Container
+      class CLI
+        attr_accessor :name
+
+        class TransitionBlockNotProvided < RuntimeError; end
+
+        # Include this so we can use `Subprocess` more easily.
+        include Vagrant::Util::Retryable
+
+        def initialize(name = nil)
+          @name   = name
+          @logger = Log4r::Logger.new("vagrant::provider::lxc::container::cli")
+        end
+
+        def list
+          run(:ls).split(/\s+/).uniq
+        end
+
+        def state
+          if @name && run(:info, '--name', @name) =~ /^state:[^A-Z]+([A-Z]+)$/
+            $1.downcase.to_sym
+          elsif @name
+            :unknown
+          end
+        end
+
+        def create(template, template_opts = {})
+          extra = template_opts.to_a.flatten
+          extra.unshift '--' unless extra.empty?
+
+          run :create,
+              # lxc-create options
+              '--template', template,
+              '--name',     @name,
+              *extra
+        end
+
+        def destroy
+          run :destroy, '--name', @name
+        end
+
+        def start(configs = [], extra_opts = [])
+          configs = configs.map { |conf| ["-s", conf] }.flatten
+          configs += extra_opts if extra_opts
+          run :start, '-d', '--name', @name, *configs
+        end
+
+        def shutdown
+          run :shutdown, '--name', @name
+        end
+
+        def transition_to(state, &block)
+          raise TransitionBlockNotProvided unless block_given?
+
+          yield self
+
+          run :wait, '--name', @name, '--state', state.to_s.upcase
+        end
+
+        private
+
+        def run(command, *args)
+          execute('sudo', "lxc-#{command}", *args)
+        end
+
+        # TODO: Review code below this line, it was pretty much a copy and
+        #       paste from VirtualBox base driver and has no tests
+        def execute(*command, &block)
+          # Get the options hash if it exists
+          opts = {}
+          opts = command.pop if command.last.is_a?(Hash)
+
+          tries = 0
+          tries = 3 if opts[:retryable]
+
+          sleep = opts.fetch(:sleep, 1)
+
+          # Variable to store our execution result
+          r = nil
+
+          retryable(:on => LXC::Errors::ExecuteError, :tries => tries, :sleep => sleep) do
+            # Execute the command
+            r = raw(*command, &block)
+
+            # If the command was a failure, then raise an exception that is
+            # nicely handled by Vagrant.
+            if r.exit_code != 0
+              if @interrupted
+                @logger.info("Exit code != 0, but interrupted. Ignoring.")
+              else
+                raise LXC::Errors::ExecuteError, :command => command.inspect
+              end
+            end
+          end
+
+          # Return the output, making sure to replace any Windows-style
+          # newlines with Unix-style.
+          r.stdout.gsub("\r\n", "\n")
+        end
+
+        def raw(*command, &block)
+          int_callback = lambda do
+            @interrupted = true
+            @logger.info("Interrupted.")
+          end
+
+          # Append in the options for subprocess
+          command << { :notify => [:stdout, :stderr] }
+
+          Vagrant::Util::Busy.busy(int_callback) do
+            Vagrant::Util::Subprocess.execute(*command, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/errors.rb

@@ -0,0 +1,12 @@
+module Vagrant
+  module LXC
+    module Errors
+      class ExecuteError < Vagrant::Errors::VagrantError
+        error_key(:lxc_execute_error)
+      end
+      class TemplateFileMissing < Vagrant::Errors::VagrantError
+        error_key(:lxc_template_file_missing)
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/machine_state.rb

@@ -0,0 +1,25 @@
+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/lib/vagrant-lxc/plugin.rb

@@ -0,0 +1,23 @@
+require "vagrant"
+
+module Vagrant
+  module LXC
+    class Plugin < Vagrant.plugin("2")
+      name "Linux Containers (LXC) provider"
+      description <<-EOF
+      The LXC provider allows Vagrant to manage and control
+      LXC-based virtual machines.
+      EOF
+
+      provider(:lxc) do
+        require File.expand_path("../provider", __FILE__)
+        Provider
+      end
+
+      config(:lxc, :provider) do
+        require File.expand_path("../config", __FILE__)
+        Config
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/provider.rb

@@ -0,0 +1,74 @@
+require "log4r"
+
+require "vagrant-lxc/action"
+require "vagrant-lxc/container"
+require "vagrant-lxc/machine_state"
+
+module Vagrant
+  module LXC
+    class Provider < Vagrant.plugin("2", :provider)
+      attr_reader :container
+
+      def initialize(machine)
+        @logger    = Log4r::Logger.new("vagrant::provider::lxc")
+        @machine   = machine
+
+        machine_id_changed
+      end
+
+      # If the machine ID changed, then we need to rebuild our underlying
+      # container.
+      def machine_id_changed
+        id = @machine.id
+
+        begin
+          @logger.debug("Instantiating the container for: #{id.inspect}")
+          @container = Container.new(id)
+          @container.validate!
+        rescue Container::NotFound
+          # The container doesn't exist, so we probably have a stale
+          # ID. Just clear the id out of the machine and reload it.
+          @logger.debug("Container not found! Clearing saved machine ID and reloading.")
+          id = nil
+          retry
+        end
+      end
+
+      # @see Vagrant::Plugin::V1::Provider#action
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        # TODO: Rename to singular
+        return LXC::Action.send(action_method) if LXC::Action.respond_to?(action_method)
+        nil
+      end
+
+      # Returns the SSH info for accessing the Container.
+      def ssh_info
+        # If the Container is not created then we cannot possibly SSH into it, so
+        # we return nil.
+        return nil if state == :not_created
+
+        {
+          :host => @container.assigned_ip,
+          :port => 22 # @driver.ssh_port(@machine.config.ssh.guest_port)
+        }
+      end
+
+      def state
+        state_id = nil
+        state_id = :not_created if !@container.name
+        state_id = @container.state if !state_id
+        state_id = :unknown if !state_id
+        LXC::MachineState.new(state_id)
+      end
+
+      def to_s
+        id = @machine.id ? @machine.id : "new VM"
+        "LXC (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/version.rb

@@ -0,0 +1,5 @@
+module Vagrant
+  module LXC
+    VERSION = "0.0.1"
+  end
+end

data/lib/vendored_vagrant.rb

@@ -0,0 +1,9 @@
+# Tks to: https://github.com/carlhuda/bundler/blob/master/lib/bundler/vendored_thor.rb
+
+if defined?(Vagrant) && Vagrant.respond_to?(:in_installer?)
+  puts "vagrant has already been required. This may cause vagrant-lxc to malfunction in unexpected ways."
+end
+vendor = File.expand_path('../../vendor/vagrant/lib', __FILE__)
+$:.unshift(vendor) unless $:.include?(vendor)
+
+require 'vagrant'

data/locales/en.yml

@@ -0,0 +1,17 @@
+en:
+  vagrant:
+    actions:
+      lxc:
+        share_folders:
+          preparing: Setting up mount entries for shared folders...
+
+    errors:
+      lxc_execute_error: |-
+        There was an error executing %{command}
+
+        For more information on the failure, enable detailed logging by setting
+        the environment variable VAGRANT_LOG to DEBUG.
+
+      lxc_template_file_missing: |-
+        The template file used for creating the container was not found for %{name}
+        box.

data/spec/fixtures/sample-arp-output

@@ -0,0 +1,4 @@
+Address                  HWtype  HWaddress           Flags Mask            Iface
+120.0.3.30               ether   10:16:3e:c8:f9:b7   C                     lxcbr0
+10.0.3.30                ether   00:16:3e:64:d6:74   C                     lxcbr0
+192.168.25.1             ether   2c:e4:12:95:90:45   C                     wlan0

data/spec/fixtures/sample-config

@@ -0,0 +1,47 @@
+lxc.network.type=veth
+lxc.network.link=lxcbr0
+lxc.network.flags=up
+lxc.network.hwaddr = 00:16:3e:64:d6:74
+lxc.rootfs = /var/lib/lxc/a91df47bfc6e/rootfs
+lxc.utsname = a91df47bfc6e
+
+lxc.devttydir = lxc
+lxc.tty = 4
+lxc.pts = 1024
+lxc.mount  = /var/lib/lxc/a91df47bfc6e/fstab
+lxc.arch = amd64
+lxc.cap.drop = sys_module mac_admin mac_override
+lxc.pivotdir = lxc_putold
+
+# uncomment the next line to run the container unconfined:
+#lxc.aa_profile = unconfined
+
+lxc.cgroup.devices.deny = a
+# Allow any mknod (but not using the node)
+lxc.cgroup.devices.allow = c *:* m
+lxc.cgroup.devices.allow = b *:* m
+# /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
+#fuse
+lxc.cgroup.devices.allow = c 10:229 rwm
+#tun
+lxc.cgroup.devices.allow = c 10:200 rwm
+#full
+lxc.cgroup.devices.allow = c 1:7 rwm
+#hpet
+lxc.cgroup.devices.allow = c 10:228 rwm
+#kvm
+lxc.cgroup.devices.allow = c 10:232 rwm

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start do
+    # This can probably go away once we stop using vagrant as submodule
+    add_filter { |source_file| source_file.filename =~ /\/vagrant\/plugins\// }
+    add_filter { |source_file| source_file.filename =~ /\/vagrant\/lib\/vagrant(\/|\.rb)/ }
+    add_filter { |source_file| source_file.filename =~ /\/spec\/support/ }
+  end
+end
+
+require 'bundler'
+
+require 'rspec-spies'
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
+
+require 'rspec/fire'
+RSpec::Fire.configure do |config|
+  config.verify_constant_names = ENV['VERIFY_CONSTANT_NAMES'] == '1'
+end
+
+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'
+end

data/spec/support/unit_example_group.rb

@@ -0,0 +1,28 @@
+module UnitExampleGroup
+  def self.included(base)
+    base.metadata[:type] = :unit
+    base.before do
+      Object.any_instance.stub(:system) { |*args, &block|
+        UnitExampleGroup.prevent_system_calls(*args, &block)
+      }
+      Object.any_instance.stub(:`) { |*args, &block|
+        UnitExampleGroup.prevent_system_calls(*args, &block)
+      }
+      require 'vagrant/util/subprocess'
+      Vagrant::Util::Subprocess.stub(:execute) { |*args, &block|
+        UnitExampleGroup.prevent_system_calls(*args, &block)
+      }
+    end
+  end
+
+  def self.prevent_system_calls(*args, &block)
+    args.pop if args.last.is_a?(Hash)
+
+    raise <<-MSG
+Somehow your code under test is trying to execute a command on your system,
+please stub it out or move your spec code to an acceptance spec.
+
+Command: "#{args.join(' ')}"
+    MSG
+  end
+end

data/spec/unit/action/handle_box_metadata_spec.rb

@@ -0,0 +1,44 @@
+require 'unit_helper'
+
+require 'vagrant-lxc/action/base_action'
+require 'vagrant-lxc/action/handle_box_metadata'
+
+describe Vagrant::LXC::Action::HandleBoxMetadata do
+  let(:metadata)      { {'template-opts' => {'--foo' => 'bar'}} }
+  let(:box)           { mock(:box, name: 'box-name', metadata: metadata, directory: box_directory) }
+  let(:box_directory) { Pathname.new('/path/to/box') }
+  let(:machine)       { mock(:machine, box: box) }
+  let(:app)           { mock(:app, call: true) }
+  let(:env)           { {machine: machine, ui: stub(info: true)} }
+  let(:tmpdir)        { '/tmp/rootfs/dir' }
+
+  subject { described_class.new(app, env) }
+
+  before do
+    Dir.stub(mktmpdir: tmpdir)
+    File.stub(exists?: true)
+    subject.stub(:system)
+    subject.call(env)
+  end
+
+  it 'creates a tmp directory to store rootfs-cache-path' do
+    metadata['rootfs-cache-path'].should == tmpdir
+  end
+
+  it 'prepends vagrant and box name to template-name' do
+    metadata['template-name'].should == "vagrant-#{box.name}"
+  end
+
+  it 'copies box template file to the right folder' do
+    src  = box_directory.join('lxc-template').to_s
+    dest = "/usr/share/lxc/templates/lxc-#{metadata['template-name']}"
+
+    subject.should have_received(:system).
+                   with("sudo su root -c \"cp #{src} #{dest}\"")
+  end
+
+  it 'extracts rootfs into a tmp folder' do
+    subject.should have_received(:system).
+                   with(%Q[sudo su root -c "cd #{box_directory} && tar xfz rootfs.tar.gz -C #{tmpdir}"])
+  end
+end