vagrant-lxc 0.2.0 → 0.3.0

data/lib/vagrant-lxc/driver.rb

@@ -0,0 +1,162 @@
+require "vagrant/util/retryable"
+require "vagrant/util/subprocess"
+
+require "vagrant-lxc/errors"
+require "vagrant-lxc/driver/cli"
+
+module Vagrant
+  module LXC
+    class Driver
+      # This is raised if the container can't be found when initializing it with
+      # a name.
+      class ContainerNotFound < StandardError; end
+
+      attr_reader :container_name,
+                  :customizations
+
+      def initialize(container_name, cli = CLI.new(container_name))
+        @container_name = container_name
+        @cli            = cli
+        @logger         = Log4r::Logger.new("vagrant::provider::lxc::driver")
+        @customizations = []
+      end
+
+      def validate!
+        raise ContainerNotFound if @container_name && ! @cli.list.include?(@container_name)
+      end
+
+      def base_path
+        Pathname.new("#{CONTAINERS_PATH}/#{@container_name}")
+      end
+
+      def rootfs_path
+        Pathname.new(base_path.join('config').read.match(/^lxc\.rootfs\s+=\s+(.+)$/)[1])
+      end
+
+      def create(name, template_path, template_options = {})
+        @cli.name = @container_name = name
+
+        import_template(template_path) do |template_name|
+          @logger.debug "Creating container..."
+          @cli.create template_name, template_options
+        end
+      end
+
+      def share_folders(folders)
+        folders.each do |folder|
+          guestpath = rootfs_path.join(folder[:guestpath].gsub(/^\//, ''))
+          unless guestpath.directory?
+            begin
+              @logger.debug("Guest path doesn't exist, creating: #{guestpath}")
+              system "sudo mkdir -p #{guestpath.to_s}"
+            rescue Errno::EACCES
+              raise Vagrant::Errors::SharedFolderCreateFailed, :path => guestpath.to_s
+            end
+          end
+
+          @customizations << ['mount.entry', "#{folder[:hostpath]} #{guestpath} none bind 0 0"]
+        end
+      end
+
+      def start(customizations)
+        @logger.info('Starting container...')
+
+        if ENV['LXC_START_LOG_FILE']
+          extra = ['-o', ENV['LXC_START_LOG_FILE'], '-l', 'DEBUG']
+        end
+        customizations = customizations + @customizations
+
+        @cli.transition_to(:running) { |c| c.start(customizations, (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
+        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 tar --numeric-owner -czf #{target_path} #{basename}/*"
+
+          @logger.info "Changing rootfs tarbal owner"
+          system "sudo chown #{ENV['USER']}:#{ENV['USER']} #{target_path}"
+        end
+
+        target_path
+      end
+
+      def state
+        if @container_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_ip_addr
+            # retry
+            raise LXC::Errors::ExecuteError, :command => "lxc-attach"
+          end
+        end
+        ip
+      end
+
+      # From: https://github.com/lxc/lxc/blob/staging/src/python-lxc/lxc/__init__.py#L371-L385
+      def get_container_ip_from_ip_addr
+        output = @cli.attach '/sbin/ip', '-4', 'addr', 'show', 'scope', 'global', 'eth0', namespaces: 'network'
+        if output =~ /^\s+inet ([0-9.]+)\/[0-9]+\s+/
+          return $1.to_s
+        end
+      end
+
+      protected
+
+      # Root folder where container configs are stored
+      CONTAINERS_PATH = '/var/lib/lxc'
+
+      def base_path
+        Pathname.new("#{CONTAINERS_PATH}/#{@container_name}")
+      end
+
+      def import_template(path)
+        template_name     = "vagrant-tmp-#{@container_name}"
+        tmp_template_path = templates_path.join("lxc-#{template_name}").to_s
+
+        @logger.debug 'Copying LXC template into place'
+        system(%Q[sudo su root -c "cp #{path} #{tmp_template_path}"])
+
+        yield template_name
+      ensure
+        system(%Q[sudo su root -c "rm #{tmp_template_path}"])
+      end
+
+      TEMPLATES_PATH_LOOKUP = %w(
+        /usr/share/lxc/templates
+        /usr/lib/lxc/templates
+      )
+      def templates_path
+        return @templates_path if @templates_path
+
+        path = TEMPLATES_PATH_LOOKUP.find { |candidate| File.directory?(candidate) }
+        # TODO: Raise an user friendly error
+        raise 'Unable to identify lxc templates path!' unless path
+
+        @templates_path = Pathname(path)
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/driver/builder.rb

@@ -0,0 +1,21 @@
+require_relative 'fetch_ip_with_attach'
+require_relative 'fetch_ip_from_dnsmasq'
+
+module Vagrant
+  module LXC
+    class Driver
+      class Builder
+        def self.build(id)
+          version = CLI.new.version.match(/^(\d+\.\d+)\./)[1].to_f
+          Driver.new(id).tap do |driver|
+            mod = version >= 0.8 ?
+              Driver::FetchIpWithAttach :
+              Driver::FetchIpFromDsnmasq
+
+            driver.extend(mod)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/{container → driver}/cli.rb

@@ -5,7 +5,7 @@ require "vagrant-lxc/errors"
 
 module Vagrant
   module LXC
-    class Container
+    class Driver
       class CLI
         attr_accessor :name
 
@@ -23,6 +23,15 @@ module Vagrant
           run(:ls).split(/\s+/).uniq
         end
 
+        def version
+          if run(:version) =~ /lxc version:\s+(.+)\s*$/
+            $1.downcase
+          else
+            # TODO: Raise an user friendly error
+            raise 'Unable to parse lxc version!'
+          end
+        end
+
         def state
           if @name && run(:info, '--name', @name) =~ /^state:[^A-Z]+([A-Z]+)$/
             $1.downcase.to_sym
@@ -31,28 +40,24 @@ module Vagrant
           end
         end
 
-        def create(template, target_rootfs_path, template_opts = {})
+        def create(template, template_opts = {})
           extra = template_opts.to_a.flatten
           extra.unshift '--' unless extra.empty?
 
-          rootfs_args = target_rootfs_path ?
-            ['-B', 'dir', '--dir', target_rootfs_path] :
-            []
-
           run :create,
               '--template', template,
               '--name',     @name,
-              *(rootfs_args + extra)
+              *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
+        def start(overrides = [], extra_opts = [])
+          options = overrides.map { |key, value| ["-s", "lxc.#{key}=#{value}"] }.flatten
+          options += extra_opts if extra_opts
+          run :start, '-d', '--name', @name, *options
         end
 
         def shutdown

data/lib/vagrant-lxc/driver/fetch_ip_from_dnsmasq.rb

@@ -0,0 +1,41 @@
+module Vagrant
+  module LXC
+    class Driver
+      module FetchIpFromDsnmasq
+        def assigned_ip
+          @logger.debug 'Loading ip from dnsmasq leases'
+          ip = nil
+          # TODO: Use Vagrant::Util::Retryable
+          10.times do
+            if dnsmasq_leases =~ /#{Regexp.escape mac_address}\s+([0-9.]+)\s+/
+              ip = $1.to_s
+              break
+            else
+              @logger.debug 'Ip could not be parsed from dnsmasq leases file'
+              sleep 2
+            end
+          end
+          # TODO: Raise an user friendly error
+          raise 'Unable to identify container IP!' unless ip
+          ip
+        end
+
+        def mac_address
+          @mac_address ||= base_path.join('config').read.match(/^lxc\.network\.hwaddr\s+=\s+(.+)$/)[1]
+        end
+
+        LEASES_PATHS = %w(
+          /var/lib/misc/dnsmasq.leases
+          /var/lib/dnsmasq/dnsmasq.leases
+          /var/db/dnsmasq.leases
+        )
+
+        def dnsmasq_leases
+          LEASES_PATHS.map do |path|
+            File.read(path) if File.exists?(path)
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/driver/fetch_ip_with_attach.rb

@@ -0,0 +1,29 @@
+module Vagrant
+  module LXC
+    class Driver
+      module FetchIpWithAttach
+        # Include this so we can use `Subprocess` more easily.
+        include Vagrant::Util::Retryable
+
+        def assigned_ip
+          ip = ''
+          retryable(:on => LXC::Errors::ExecuteError, :tries => 10, :sleep => 3) do
+            unless ip = get_container_ip_from_ip_addr
+              # retry
+              raise LXC::Errors::ExecuteError, :command => "lxc-attach"
+            end
+          end
+          ip
+        end
+
+        # From: https://github.com/lxc/lxc/blob/staging/src/python-lxc/lxc/__init__.py#L371-L385
+        def get_container_ip_from_ip_addr
+          output = @cli.attach '/sbin/ip', '-4', 'addr', 'show', 'scope', 'global', 'eth0', namespaces: 'network'
+          if output =~ /^\s+inet ([0-9.]+)\/[0-9]+\s+/
+            return $1.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/errors.rb

@@ -1,12 +1,22 @@
+require 'vagrant/errors'
+
 module Vagrant
   module LXC
     module Errors
       class ExecuteError < Vagrant::Errors::VagrantError
         error_key(:lxc_execute_error)
       end
+
+      # Box related errors
       class TemplateFileMissing < Vagrant::Errors::VagrantError
         error_key(:lxc_template_file_missing)
       end
+      class RootFSTarballMissing < Vagrant::Errors::VagrantError
+        error_key(:lxc_invalid_box_version)
+      end
+      class InvalidBoxVersion < Vagrant::Errors::VagrantError
+        error_key(:lxc_invalid_box_version)
+      end
     end
   end
 end

data/lib/vagrant-lxc/plugin.rb

@@ -11,6 +11,10 @@ module Vagrant
 
       provider(:lxc) do
         require File.expand_path("../provider", __FILE__)
+
+        I18n.load_path << File.expand_path(File.dirname(__FILE__) + '/../../locales/en.yml')
+        I18n.reload!
+
         Provider
       end
 

data/lib/vagrant-lxc/provider.rb

@@ -1,13 +1,13 @@
 require "log4r"
 
 require "vagrant-lxc/action"
-require "vagrant-lxc/container"
-require "vagrant-lxc/machine_state"
+require "vagrant-lxc/driver"
+require "vagrant-lxc/driver/builder"
 
 module Vagrant
   module LXC
     class Provider < Vagrant.plugin("2", :provider)
-      attr_reader :container
+      attr_reader :driver
 
       def initialize(machine)
         @logger    = Log4r::Logger.new("vagrant::provider::lxc")
@@ -23,9 +23,9 @@ module Vagrant
 
         begin
           @logger.debug("Instantiating the container for: #{id.inspect}")
-          @container = Container.new(id)
-          @container.validate!
-        rescue Container::NotFound
+          @driver = Driver::Builder.build(id)
+          @driver.validate!
+        rescue Driver::ContainerNotFound
           # 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.")
@@ -40,7 +40,6 @@ module Vagrant
         # 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
@@ -52,17 +51,21 @@ module Vagrant
         return nil if state == :not_created
 
         {
-          :host => @container.assigned_ip,
+          :host => @driver.assigned_ip,
           :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 = :not_created if !@driver.container_name
+        state_id = @driver.state if !state_id
         state_id = :unknown if !state_id
-        LXC::MachineState.new(state_id)
+
+        short = state_id.to_s.gsub("_", " ")
+        long  = I18n.t("vagrant.commands.status.#{state_id}")
+
+        Vagrant::MachineState.new(state_id, short, long)
       end
 
       def to_s

data/lib/vagrant-lxc/version.rb

@@ -1,5 +1,5 @@
 module Vagrant
   module LXC
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 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

@@ -17,6 +17,7 @@ Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
 if ENV['VERIFY_CONSTANT_NAMES']
   require 'vagrant-lxc/plugin'
   require 'vagrant-lxc/provider'
+  require 'vagrant-lxc/config'
 end
 
 require 'rspec/fire'

data/spec/unit/action/compress_rootfs_spec.rb

@@ -6,8 +6,8 @@ describe Vagrant::LXC::Action::CompressRootFS do
   let(:app)                    { mock(:app, call: true) }
   let(:env)                    { {machine: machine, ui: stub(info: true)} }
   let(:machine)                { fire_double('Vagrant::Machine', provider: provider) }
-  let(:provider)               { fire_double('Vagrant::LXC::Provider', container: container) }
-  let(:container)              { fire_double('Vagrant::LXC::Container', compress_rootfs: compressed_rootfs_path) }
+  let(:provider)               { fire_double('Vagrant::LXC::Provider', driver: driver) }
+  let(:driver)                 { fire_double('Vagrant::LXC::Driver', compress_rootfs: compressed_rootfs_path) }
   let(:compressed_rootfs_path) { '/path/to/rootfs.tar.gz' }
 
   subject { described_class.new(app, env) }
@@ -17,8 +17,8 @@ describe Vagrant::LXC::Action::CompressRootFS do
     subject.call(env)
   end
 
-  it 'asks the container to compress its rootfs' do
-    container.should have_received(:compress_rootfs)
+  it "asks the driver to compress container's rootfs" do
+    driver.should have_received(:compress_rootfs)
   end
 
   it 'sets export.temp_dir on action env' do