vagrant-lxc-2.1-patch 1.4.0

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

@@ -0,0 +1,94 @@
+module Vagrant
+  module LXC
+    module Action
+      # Prepare arguments to be used for lxc-create
+      class HandleBoxMetadata
+        SUPPORTED_VERSIONS  = ['1.0.0', '2', '3']
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::lxc::action::handle_box_metadata")
+        end
+
+        def call(env)
+          @env = env
+          @box = @env[:machine].box
+
+          @env[:ui].info I18n.t("vagrant.actions.vm.import.importing",
+                                :name => @env[:machine].box.name)
+
+          @logger.info 'Validating box contents'
+          validate_box
+
+          @logger.info 'Setting box options on environment'
+          @env[:lxc_template_src]  = template_src
+          @env[:lxc_template_opts] = template_opts
+
+          # FIXME: Remove support for pre 1.0.0 boxes
+          if box_version != '1.0.0'
+            @env[:ui].warn "WARNING: You are using a base box that has a format that has been deprecated, please upgrade to a new one."
+            @env[:lxc_template_opts].merge!(
+              '--auth-key' => Vagrant.source_root.join('keys', 'vagrant.pub').expand_path.to_s
+            )
+          end
+
+          if template_config_file.exist?
+            @env[:lxc_template_opts].merge!('--config' => template_config_file.to_s)
+          elsif old_template_config_file.exist?
+            @env[:lxc_template_config] = old_template_config_file.to_s
+          end
+
+          @app.call env
+        end
+
+        def template_src
+          @template_src ||=
+            if (box_template = @box.directory.join('lxc-template')).exist?
+              box_template.to_s
+            else
+              Vagrant::LXC.source_root.join('scripts/lxc-template').to_s
+            end
+        end
+
+        def template_config_file
+          @template_config_file ||= @box.directory.join('lxc-config')
+        end
+
+        # TODO: Remove this once we remove compatibility for < 1.0.0 boxes
+        def old_template_config_file
+          @old_template_config_file ||= @box.directory.join('lxc.conf')
+        end
+
+        def template_opts
+          @template_opts ||= @box.metadata.fetch('template-opts', {}).dup.merge!(
+            '--tarball'  => rootfs_tarball
+          )
+        end
+
+        def rootfs_tarball
+          @rootfs_tarball ||= @box.directory.join('rootfs.tar.gz').to_s
+        end
+
+        def validate_box
+          unless SUPPORTED_VERSIONS.include? box_version
+            raise Errors::IncompatibleBox.new name: @box.name,
+                                              found: box_version,
+                                              supported: SUPPORTED_VERSIONS.join(', ')
+          end
+
+          unless File.exists?(template_src)
+            raise Errors::TemplateFileMissing.new name: @box.name
+          end
+
+          unless File.exists?(rootfs_tarball)
+            raise Errors::RootFSTarballMissing.new name: @box.name
+          end
+        end
+
+        def box_version
+          @box.metadata.fetch('version')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Vagrant
+  module LXC
+    module Action
+      class PrepareNFSSettings
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          @machine = env[:machine]
+
+          @app.call(env)
+
+          # if using_nfs? # TODO: && !privileged_container?
+          #   raise Errors::NfsWithoutPrivilegedError
+          # end
+
+          if using_nfs?
+            @logger.info("Using NFS, preparing NFS settings by reading host IP and machine IP")
+            add_ips_to_env!(env)
+          end
+        end
+
+        # We're using NFS if we have any synced folder with NFS configured. If
+        # we are not using NFS we don't need to do the extra work to
+        # populate these fields in the environment.
+        def using_nfs?
+          @machine.config.vm.synced_folders.any? { |_, opts| opts[:type] == :nfs }
+        end
+
+        # TODO:
+        # def privileged_container?
+        #   @machine.provider.driver.privileged?(@machine.id)
+        # end
+
+        # Extracts the proper host and guest IPs for NFS mounts and stores them
+        # in the environment for the SyncedFolder action to use them in
+        # mounting.
+        #
+        # The ! indicates that this method modifies its argument.
+        def add_ips_to_env!(env)
+          provider = @machine.provider
+
+          host_ip    = read_host_ip
+          machine_ip = provider.ssh_info[:host]
+
+          raise Vagrant::Errors::NFSNoHostonlyNetwork if !host_ip || !machine_ip
+
+          env[:nfs_host_ip]    = host_ip
+          env[:nfs_machine_ip] = machine_ip
+        end
+
+        def read_host_ip
+          @machine.communicate.execute 'echo $SSH_CLIENT' do |buffer, output|
+            return output.chomp.split(' ')[0] if buffer == :stdout
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Vagrant
+  module LXC
+    module Action
+      class PrepareNFSValidIds
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          env[:nfs_valid_ids] = machine.provider.driver.all_containers
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Vagrant
+  module LXC
+    module Action
+      class PrivateNetworks
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+
+          if private_network_configured?(env[:machine].config)
+            env[:ui].output(I18n.t("vagrant_lxc.messages.setup_private_network"))
+            configure_private_networks(env)
+          end
+        end
+
+        def private_network_configured?(config)
+          config.vm.networks.find do |type, _|
+            type.to_sym == :private_network
+          end
+        end
+
+        def configure_private_networks(env)
+          env[:machine].config.vm.networks.find do |type, config|
+            next if type.to_sym != :private_network
+
+            container_name = env[:machine].provider.driver.container_name
+            address_type   = config[:type]
+            ip             = config[:ip]
+            bridge_ip      = config.fetch(:lxc__bridge_ip) { build_bridge_ip(ip) }
+            bridge         = config.fetch(:lxc__bridge_name)
+
+            env[:machine].provider.driver.configure_private_network(bridge, bridge_ip, container_name, address_type, ip)
+          end
+        end
+
+        def build_bridge_ip(ip)
+          if ip
+            ip.sub(/^(\d+\.\d+\.\d+)\.\d+/, '\1.254')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'fileutils'
+
+module Vagrant
+  module LXC
+    module Action
+      class SetupPackageFiles
+        def initialize(app, env)
+          @app = app
+
+          env["package.include"]     ||= []
+          env["package.vagrantfile"] ||= nil
+        end
+
+        def call(env)
+          @env = env
+
+          create_package_temp_dir
+          move_rootfs_to_pkg_dir
+          copy_box_files_to_pkg_dir
+
+          @app.call env
+
+          recover # called to cleanup temp directory
+        end
+
+        def recover(*)
+          if @temp_dir && File.exist?(@temp_dir)
+            FileUtils.rm_rf(@temp_dir)
+          end
+        end
+
+        private
+
+        def create_package_temp_dir
+          @env[:ui].info I18n.t("vagrant.actions.vm.export.create_dir")
+          @temp_dir = @env["package.directory"] = @env[:tmp_path].join("container-export-#{Time.now.to_i.to_s}")
+          FileUtils.mkpath(@temp_dir)
+        end
+
+        def move_rootfs_to_pkg_dir
+          FileUtils.mv @env['package.rootfs'].to_s, @env['package.directory'].to_s
+        end
+
+        def copy_box_files_to_pkg_dir
+          box_dir = @env[:machine].box.directory
+          FileUtils.cp box_dir.join('metadata.json').to_s, @env['package.directory'].to_s
+          if (template = box_dir.join('lxc-template')).exist?
+            FileUtils.cp template.to_s, @env['package.directory'].to_s
+          end
+          if (conf = box_dir.join('lxc.conf')).exist?
+            FileUtils.cp conf.to_s, @env['package.directory'].to_s
+          end
+          if (conf = box_dir.join('lxc-config')).exist?
+            FileUtils.cp conf.to_s, @env['package.directory'].to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Vagrant
+  module LXC
+    module Action
+      class WarnNetworks
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if public_network_configured?(env[:machine].config)
+            env[:ui].warn(I18n.t("vagrant_lxc.messages.warn_networks"))
+          end
+
+          @app.call(env)
+        end
+
+        def public_network_configured?(config)
+          config.vm.networks.find do |type, _|
+            type.to_sym == :public_network
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/command/root.rb

@@ -0,0 +1,58 @@
+module Vagrant
+  module LXC
+    module Command
+      class Root < Vagrant.plugin("2", :command)
+        def self.synopsis
+          'vagrant-lxc specific commands'
+        end
+
+        def initialize(argv, env)
+          @args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+          @subcommands = Vagrant::Registry.new.tap do |registry|
+            registry.register(:sudoers) do
+              require_relative 'sudoers'
+              Sudoers
+            end
+          end
+          super(argv, env)
+        end
+
+        def execute
+          # Print the help
+          return help if @args.include?("-h") || @args.include?("--help")
+
+          klazz = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help unless klazz
+
+          @logger.debug("Executing command: #{klazz} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          klazz.new(@sub_args, @env).execute
+        end
+
+        def help
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: vagrant lxc <subcommand> [<args>]"
+            opts.separator ""
+            opts.separator "Available subcommands:"
+
+            # REFACTOR Use @subcommands.keys.sort  
+            #          https://github.com/mitchellh/vagrant/commit/4194da19c60956f6e59239c0145f772be257e79d
+            keys = []
+            @subcommands.each { |key, value| keys << key }
+
+            keys.sort.each do |key|
+              opts.separator "    #{key}"
+            end
+
+            opts.separator ""
+            opts.separator "For help on any individual subcommand run `vagrant lxc <subcommand> -h`"
+          end
+
+          @env.ui.info(opts.help, :prefix => false)
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/command/sudoers.rb

@@ -0,0 +1,97 @@
+require 'tempfile'
+
+require "vagrant-lxc/driver"
+require "vagrant-lxc/sudo_wrapper"
+
+module Vagrant
+  module LXC
+    module Command
+      class Sudoers < Vagrant.plugin("2", :command)
+
+        def initialize(argv, env)
+          super
+          @argv
+          @env = env
+        end
+
+        def execute
+          options = { user: ENV['USER'] }
+
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: vagrant lxc sudoers"
+            opts.separator ""
+            opts.on('-u user', '--user user', String, "The user for which to create the policy (defaults to '#{options[:user]}')") do |u|
+              options[:user] = u
+            end
+          end
+
+          argv = parse_options(opts)
+          return unless argv
+
+          wrapper_path = SudoWrapper.dest_path
+          wrapper = create_wrapper!
+          sudoers = create_sudoers!(options[:user], wrapper_path)
+
+          su_copy([
+            {source: wrapper, target: wrapper_path, mode: "0555"},
+            {source: sudoers, target: sudoers_path, mode: "0440"}
+          ])
+        end
+
+        def sudoers_path
+          "/etc/sudoers.d/vagrant-lxc"
+        end
+
+        private
+
+        # This requires vagrant 1.5.2+ https://github.com/mitchellh/vagrant/commit/3371c3716278071680af9b526ba19235c79c64cb
+        def create_wrapper!
+          lxc_base_path = Driver.new("").containers_path
+          wrapper = Tempfile.new('lxc-wrapper').tap do |file|
+            template = Vagrant::Util::TemplateRenderer.new(
+              'sudoers.rb',
+              :template_root  => Vagrant::LXC.source_root.join('templates').to_s,
+              :cmd_paths      => build_cmd_paths_hash,
+              :lxc_base_path  => lxc_base_path,
+              :pipework_regex => "#{ENV['HOME']}/\.vagrant\.d/gems/(?:\\d+?\\.\\d+?\\.\\d+?/)?gems/vagrant-lxc.+/scripts/pipework"
+            )
+            file.puts template.render
+          end
+          wrapper.close
+          wrapper.path
+        end
+
+        def create_sudoers!(user, command)
+          sudoers = Tempfile.new('vagrant-lxc-sudoers').tap do |file|
+            file.puts "# Automatically created by vagrant-lxc"
+            file.puts "#{user} ALL=(root) NOPASSWD: #{command}"
+          end
+          sudoers.close
+          sudoers.path
+        end
+
+        def su_copy(files)
+          commands = files.map { |file|
+            [
+              "rm -f #{file[:target]}",
+              "cp #{file[:source]} #{file[:target]}",
+              "chown root:root #{file[:target]}",
+              "chmod #{file[:mode]} #{file[:target]}"
+            ]
+          }.flatten
+          system "echo \"#{commands.join("; ")}\" | sudo sh"
+        end
+
+        def build_cmd_paths_hash
+          {}.tap do |hash|
+            %w( which cat mkdir cp chown chmod rm tar chown ip ifconfig brctl ).each do |cmd|
+              hash[cmd] = `sudo which #{cmd}`.strip
+            end
+            hash['lxc_bin'] = Pathname(`sudo which lxc-create`.strip).parent.to_s
+            hash['ruby'] = Gem.ruby
+          end
+        end
+      end
+    end
+  end
+end