vagrant-lxc 0.4.0 → 0.5.0

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

@@ -0,0 +1,46 @@
+module Vagrant
+  module LXC
+    module Action
+        class FetchIpWithLxcAttach
+          # Include this so we can use `Subprocess` more easily.
+          include Vagrant::Util::Retryable
+
+          def initialize(app, env)
+            @app    = app
+            @logger = Log4r::Logger.new("vagrant::lxc::action::fetch_ip_with_lxc_attach")
+          end
+
+          def call(env)
+            env[:machine_ip] ||= assigned_ip(env)
+            @app.call(env)
+          end
+
+          def assigned_ip(env)
+            driver  = env[:machine].provider.driver
+            version = driver.version.match(/^(\d+\.\d+)\./)[1].to_f
+            unless version >= 0.8
+              @logger.debug "lxc version does not support the --namespaces argument to lxc-attach"
+              return nil
+            end
+
+            ip = ''
+            retryable(:on => LXC::Errors::ExecuteError, :tries => 10, :sleep => 3) do
+              unless ip = get_container_ip_from_ip_addr(driver)
+                # 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(driver)
+            output = driver.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/action/forward_ports.rb

@@ -10,12 +10,13 @@ module Vagrant
         def call(env)
           @env = env
 
-          # Continue, we need the VM to be booted in order to grab its IP
-          @app.call env
-
           # Get the ports we're forwarding
           env[:forwarded_ports] = compile_forwarded_ports(env[:machine].config)
 
+          if @env[:forwarded_ports].any? and not redir_installed?
+            raise Errors::RedirNotInstalled
+          end
+
           # Warn if we're port forwarding to any privileged ports
           env[:forwarded_ports].each do |fp|
             if fp[:host] <= 1024
@@ -24,6 +25,9 @@ module Vagrant
             end
           end
 
+          # Continue, we need the VM to be booted in order to grab its IP
+          @app.call env
+
           if @env[:forwarded_ports].any?
             env[:ui].info I18n.t("vagrant.actions.vm.forward_ports.forwarding")
             forward_ports
@@ -31,8 +35,6 @@ module Vagrant
         end
 
         def forward_ports
-          @container_ip = @env[:machine].provider.driver.assigned_ip
-
           @env[:forwarded_ports].each do |fp|
             message_attributes = {
               # TODO: Add support for multiple adapters
@@ -45,7 +47,12 @@ module Vagrant
             @env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.forwarding_entry",
                                   message_attributes))
 
-            redir_pid = redirect_port(fp[:host], fp[:guest])
+            redir_pid = redirect_port(
+              fp[:host_ip],
+              fp[:host],
+              fp[:guest_ip] || @env[:machine].provider.ssh_info[:host],
+              fp[:guest]
+            )
             store_redir_pid(fp[:host], redir_pid)
           end
         end
@@ -64,8 +71,11 @@ module Vagrant
           mappings.values
         end
 
-        def redirect_port(host, guest)
-          redir_cmd = "sudo redir --laddr=127.0.0.1 --lport=#{host} --cport=#{guest} --caddr=#{@container_ip} 2>/dev/null"
+        def redirect_port(host_ip, host_port, guest_ip, guest_port)
+          params = %W( --lport=#{host_port} --caddr=#{guest_ip} --cport=#{guest_port} )
+          params.unshift "--laddr=#{host_ip}" if host_ip
+          params << '--syslog' if ENV['REDIR_LOG']
+          redir_cmd = "redir #{params.join(' ')} 2>/dev/null"
 
           @logger.debug "Forwarding port with `#{redir_cmd}`"
           spawn redir_cmd
@@ -79,6 +89,10 @@ module Vagrant
             pid_file.write(redir_pid)
           end
         end
+
+        def redir_installed?
+          system "which redir > /dev/null"
+        end
       end
     end
   end

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

@@ -14,7 +14,7 @@ module Vagrant
           if env[:machine].state.id == :stopped
             @logger.debug 'Removing temporary files'
             tmp_path = env[:machine].provider.driver.rootfs_path.join('tmp')
-            system "sudo rm -rf #{tmp_path}/*"
+            env[:machine].provider.sudo_wrapper.run('rm', '-rf', "#{tmp_path}/*")
           end
         end
       end

data/lib/vagrant-lxc/config.rb

@@ -6,8 +6,15 @@ module Vagrant
       # @return [Array]
       attr_reader :customizations
 
+      # A String that points to a file that acts as a wrapper for sudo commands.
+      #
+      # This allows us to have a single entry when whitelisting NOPASSWD commands
+      # on /etc/sudoers
+      attr_accessor :sudo_wrapper
+
       def initialize
         @customizations = []
+        @sudo_wrapper   = UNSET_VALUE
       end
 
       # Customize the container by calling `lxc-start` with the given
@@ -25,7 +32,24 @@ module Vagrant
         @customizations << [key, value]
       end
 
-      # TODO: At some point in the future it would be nice to validate these options
+      def finalize!
+        @sudo_wrapper = nil if @sudo_wrapper == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+
+        if @sudo_wrapper
+          hostpath = Pathname.new(@sudo_wrapper).expand_path(machine.env.root_path)
+          if ! hostpath.file?
+            errors << I18n.t('vagrant_lxc.sudo_wrapper_not_found', path: hostpath.to_s)
+          elsif ! hostpath.executable?
+            errors << I18n.t('vagrant_lxc.sudo_wrapper_not_executable', path: hostpath.to_s)
+          end
+        end
+
+        { "lxc provider" => errors }
+      end
     end
   end
 end

data/lib/vagrant-lxc/driver.rb

@@ -11,12 +11,16 @@ module Vagrant
       # a name.
       class ContainerNotFound < StandardError; end
 
+      # Root folder where container configs are stored
+      CONTAINERS_PATH = '/var/lib/lxc'
+
       attr_reader :container_name,
                   :customizations
 
-      def initialize(container_name, cli = CLI.new(container_name))
+      def initialize(container_name, sudo_wrapper, cli = nil)
         @container_name = container_name
-        @cli            = cli
+        @sudo_wrapper   = sudo_wrapper
+        @cli            = cli || CLI.new(sudo_wrapper, container_name)
         @logger         = Log4r::Logger.new("vagrant::provider::lxc::driver")
         @customizations = []
       end
@@ -33,6 +37,10 @@ module Vagrant
         Pathname.new(base_path.join('config').read.match(/^lxc\.rootfs\s+=\s+(.+)$/)[1])
       end
 
+      def mac_address
+        @mac_address ||= base_path.join('config').read.match(/^lxc\.network\.hwaddr\s+=\s+(.+)$/)[1]
+      end
+
       def create(name, template_path, config_file, template_options = {})
         @cli.name = @container_name = name
 
@@ -48,7 +56,7 @@ module Vagrant
           unless guestpath.directory?
             begin
               @logger.debug("Guest path doesn't exist, creating: #{guestpath}")
-              system "sudo mkdir -p #{guestpath.to_s}"
+              @sudo_wrapper.run('mkdir', '-p', guestpath.to_s)
             rescue Errno::EACCES
               raise Vagrant::Errors::SharedFolderCreateFailed, :path => guestpath.to_s
             end
@@ -64,9 +72,11 @@ module Vagrant
         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)) }
+        prune_customizations
+        write_customizations(customizations + @customizations)
+
+        @cli.transition_to(:running) { |c| c.start(extra) }
       end
 
       def forced_halt
@@ -80,6 +90,14 @@ module Vagrant
         @cli.destroy
       end
 
+      def attach(*command)
+        @cli.attach(*command)
+      end
+
+      def version
+        @version ||= @cli.version
+      end
+
       # TODO: This needs to be reviewed and specs needs to be written
       def compress_rootfs
         rootfs_dirname = File.dirname rootfs_path
@@ -89,10 +107,11 @@ module Vagrant
 
         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}/*"
+          @sudo_wrapper.run('rm', '-f', 'rootfs.tar.gz')
+          @sudo_wrapper.run('tar', '--numeric-owner', '-czf', target_path, "#{basename}/*")
 
           @logger.info "Changing rootfs tarbal owner"
-          system "sudo chown #{ENV['USER']}:#{ENV['USER']} #{target_path}"
+          @sudo_wrapper.run('chown', "#{ENV['USER']}:#{ENV['USER']}", target_path)
         end
 
         target_path
@@ -104,16 +123,25 @@ module Vagrant
         end
       end
 
-      def assigned_ip
+      def prune_customizations
+        # Use sed to just strip out the block of code which was inserted by Vagrant
+        @logger.debug 'Prunning vagrant-lxc customizations'
+        @sudo_wrapper.su_c("sed -e '/^# VAGRANT-BEGIN/,/^# VAGRANT-END/ d' -ibak #{base_path.join('config')}")
       end
 
       protected
 
-      # Root folder where container configs are stored
-      CONTAINERS_PATH = '/var/lib/lxc'
+      def write_customizations(customizations)
+        customizations = customizations.map do |key, value|
+          "lxc.#{key}=#{value}"
+        end
+        customizations.unshift '# VAGRANT-BEGIN'
+        customizations      << '# VAGRANT-END'
 
-      def base_path
-        Pathname.new("#{CONTAINERS_PATH}/#{@container_name}")
+        config_file = base_path.join('config').to_s
+        customizations.each do |line|
+          @sudo_wrapper.su_c("echo '#{line}' >> #{config_file}")
+        end
       end
 
       def import_template(path)
@@ -121,11 +149,11 @@ module Vagrant
         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}"])
+        @sudo_wrapper.run('cp', path, tmp_template_path)
 
         yield template_name
       ensure
-        system(%Q[sudo su root -c "rm #{tmp_template_path}"])
+        @sudo_wrapper.run('rm', tmp_template_path)
       end
 
       TEMPLATES_PATH_LOOKUP = %w(

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

@@ -17,12 +17,10 @@ module Vagrant
           end
         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")
+        def initialize(sudo_wrapper, name = nil)
+          @sudo_wrapper = sudo_wrapper
+          @name         = name
+          @logger       = Log4r::Logger.new("vagrant::provider::lxc::container::cli")
         end
 
         def list
@@ -65,10 +63,8 @@ module Vagrant
           run :destroy, '--name', @name
         end
 
-        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
+        def start(options = [])
+          run :start, '-d', '--name', @name, *Array(options)
         end
 
         def stop
@@ -110,56 +106,7 @@ module Vagrant
         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
+          @sudo_wrapper.run("lxc-#{command}", *args)
         end
       end
     end

data/lib/vagrant-lxc/errors.rb

@@ -7,6 +7,10 @@ module Vagrant
         error_key(:lxc_execute_error)
       end
 
+      class LxcNotInstalled < Vagrant::Errors::VagrantError
+        error_key(:lxc_not_installed)
+      end
+
       # Box related errors
       class TemplateFileMissing < Vagrant::Errors::VagrantError
         error_key(:lxc_template_file_missing)
@@ -17,6 +21,9 @@ module Vagrant
       class IncompatibleBox < Vagrant::Errors::VagrantError
         error_key(:lxc_incompatible_box)
       end
+      class RedirNotInstalled < Vagrant::Errors::VagrantError
+        error_key(:lxc_redir_not_installed)
+      end
     end
   end
 end

data/lib/vagrant-lxc/provider.rb

@@ -2,7 +2,7 @@ require "log4r"
 
 require "vagrant-lxc/action"
 require "vagrant-lxc/driver"
-require "vagrant-lxc/driver/builder"
+require "vagrant-lxc/sudo_wrapper"
 
 module Vagrant
   module LXC
@@ -13,9 +13,24 @@ module Vagrant
         @logger    = Log4r::Logger.new("vagrant::provider::lxc")
         @machine   = machine
 
+        ensure_lxc_installed!
         machine_id_changed
       end
 
+      def sudo_wrapper
+        @shell ||= begin
+          wrapper = @machine.provider_config.sudo_wrapper
+          wrapper = Pathname(wrapper).expand_path(@machine.env.root_path).to_s if wrapper
+          SudoWrapper.new(wrapper)
+        end
+      end
+
+      def ensure_lxc_installed!
+        unless system("which lxc-version > /dev/null")
+          raise Errors::LxcNotInstalled
+        end
+      end
+
       # If the machine ID changed, then we need to rebuild our underlying
       # container.
       def machine_id_changed
@@ -23,7 +38,7 @@ module Vagrant
 
         begin
           @logger.debug("Instantiating the container for: #{id.inspect}")
-          @driver = Driver::Builder.build(id)
+          @driver = Driver.new(id, self.sudo_wrapper)
           @driver.validate!
         rescue Driver::ContainerNotFound
           # The container doesn't exist, so we probably have a stale
@@ -50,8 +65,16 @@ module Vagrant
         # we return nil.
         return nil if state == :not_created
 
+        # Run a custom action called "fetch_ip" which does what it says and puts
+        # the IP found into the `:machine_ip` key in the environment.
+        env = @machine.action("fetch_ip")
+
+        # If we were not able to identify the container's IP, we return nil
+        # here and we let Vagrant core deal with it ;)
+        return nil unless env[:machine_ip]
+
         {
-          :host => @driver.assigned_ip,
+          :host => env[:machine_ip],
           :port => @machine.config.ssh.guest_port
         }
       end