vagrant-lxc 0.8.0 → 1.0.0.alpha.1

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

@@ -1,23 +0,0 @@
-module Vagrant
-  module LXC
-    module Action
-      # XXX: Is this really needed? Should we contribute this back to Vagrant's core?
-      class Message
-        def initialize(app, env, msg_key, type = :info)
-          @app     = app
-          @msg_key = msg_key
-          @type    = type
-        end
-
-        def call(env)
-          machine = env[:machine]
-          message = I18n.t("vagrant_lxc.messages.#{@msg_key}", name: machine.name)
-
-          env[:ui].send @type, message
-
-          @app.call env
-        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/setup_package_files.rb

@@ -43,12 +43,16 @@ module Vagrant
 
         def copy_box_files_to_pkg_dir
           box_dir = @env[:machine].box.directory
-          FileUtils.cp box_dir.join('lxc-template').to_s, @env['package.directory'].to_s
           FileUtils.cp box_dir.join('metadata.json').to_s, @env['package.directory'].to_s
-          # TODO: Update built-on metadata.json
+          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

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,87 @@
+require 'tempfile'
+
+module Vagrant
+  module LXC
+    module Command
+      class Sudoers < Vagrant.plugin("2", :command)
+        def execute
+          options = { user: ENV['USER'] }
+
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: vagrant lxc sudoers"
+            opts.separator ""
+            opts.on('-u', '--user', "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
+
+          filename = "vagrant-lxc-#{options[:user]}"
+          to_sudoers!(create_tempfile!(options[:user], filename), filename)
+        end
+
+        private
+
+        # REFACTOR: Make use ERB rendering after https://github.com/mitchellh/vagrant/issues/3231
+        #           lands into core
+        def create_tempfile!(user, filename)
+          sudoers = Tempfile.new(filename).tap do |file|
+            file.write "# Automatically created by vagrant-lxc\n"
+            commands.each do |command|
+              file.write sudoers_policy(user, command[:cmd], command[:args])
+            end
+          end
+          sudoers.close
+          File.chmod(0644, sudoers.path)
+          sudoers.path
+        end
+
+        def to_sudoers!(source, destination)
+          destination = "/etc/sudoers.d/#{destination}"
+          commands = [
+            "rm -f #{destination}",
+            "cp #{source} #{destination}",
+            "chmod 440 #{destination}"
+          ]
+          `echo "#{commands.join('; ')}" | sudo sh`
+        end
+
+        def sudoers_policy(user, command, args)
+          vagrant_home = "#{`echo ~#{user}`.chomp}/.vagrant.d"
+          args = args.gsub /%\{VAGRANT_D\}/, vagrant_home
+          args = args.gsub /%\{BOXES\}/, "#{vagrant_home}/boxes"
+          "#{user} ALL=(root) NOPASSWD: #{command} #{args}\n"
+        end
+
+        def commands
+         [
+           { cmd: '/usr/bin/lxc-ls',        args: '' },
+           { cmd: '/usr/bin/lxc-info',      args: '' },
+           { cmd: '/usr/bin/lxc-attach',    args: '' },
+           { cmd: '/usr/bin/which',         args: 'lxc-*' },
+           { cmd: '/bin/cat',               args: '/var/lib/lxc/*' },
+           { cmd: '/bin/mkdir',             args: '-p /var/lib/lxc/*' },
+           { cmd: '/bin/su',                args: "root -c sed -e '*' -ibak /var/lib/lxc/*" },
+           { cmd: '/bin/su',                args: "root -c echo '*' >> /var/lib/lxc/*" },
+           { cmd: '/usr/bin/lxc-start',     args: '-d --name *' },
+           { cmd: '/bin/cp',                args: '%{BOXES}/*/lxc/lxc-template /usr/lib/lxc/templates/*' },
+           { cmd: '/bin/cp',                args: '%{VAGRANT_D}/gems/gems/vagrant-lxc-*/scripts/lxc-template /usr/lib/lxc/templates/*' },
+           { cmd: '/bin/cp',                args: '%{BOXES}/*/lxc/lxc-template /usr/share/lxc/templates/*' },
+           { cmd: '/bin/cp',                args: '%{VAGRANT_D}/gems/gems/vagrant-lxc-*/scripts/lxc-template /usr/share/lxc/templates/*' },
+           { cmd: '/bin/rm',                args: '/usr/lib/lxc/templates/*' },
+           { cmd: '/bin/rm',                args: '/usr/share/lxc/templates/*' },
+           { cmd: '/bin/chmod',             args: '+x /usr/lib/lxc/*' },
+           { cmd: '/bin/chmod',             args: '+x /usr/share/lxc/*' },
+           { cmd: '/usr/bin/lxc-create',    args: '--template * --name * -- --tarball %{BOXES}/*' },
+           { cmd: '/bin/rm',                args: '-rf /var/lib/lxc/*/rootfs/tmp/*' },
+           { cmd: '/usr/bin/lxc-shutdown',  args: '--name *' },
+           { cmd: '/usr/bin/lxc-stop',      args: '--name *' },
+           { cmd: '/usr/bin/lxc-destroy',   args: '--name *' }
+         ]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/driver.rb

@@ -31,6 +31,10 @@ module Vagrant
         raise ContainerNotFound if @container_name && ! @cli.list.include?(@container_name)
       end
 
+      def all_containers
+        @cli.list
+      end
+
       def base_path
         Pathname.new("#{CONTAINERS_PATH}/#{@container_name}")
       end
@@ -57,19 +61,24 @@ module Vagrant
       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}")
-              @sudo_wrapper.run('mkdir', '-p', guestpath.to_s)
-            rescue Errno::EACCES
-              raise Vagrant::Errors::SharedFolderCreateFailed, :path => guestpath.to_s
-            end
-          end
+        folders.each do |f|
+          share_folder(f[:hostpath], f[:guestpath], f.fetch(:mount_options, 'bind'))
+        end
+      end
 
-          @customizations << ['mount.entry', "#{folder[:hostpath]} #{guestpath} none bind 0 0"]
+      def share_folder(host_path, guest_path, mount_options = nil)
+        guest_path = rootfs_path.join(guest_path.gsub(/^\//, ''))
+        unless guest_path.directory?
+          begin
+            @logger.debug("Guest path doesn't exist, creating: #{guest_path}")
+            @sudo_wrapper.run('mkdir', '-p', guest_path.to_s)
+          rescue Errno::EACCES
+            raise Vagrant::Errors::SharedFolderCreateFailed, :path => guest_path.to_s
+          end
         end
+
+        mount_options = Array(mount_options || ['bind'])
+        @customizations << ['mount.entry', "#{host_path} #{guest_path} none #{mount_options.join(',')} 0 0"]
       end
 
       def start(customizations)
@@ -87,6 +96,7 @@ module Vagrant
 
       def forced_halt
         @logger.info('Shutting down container...')
+        # TODO: Remove `lxc-shutdown` usage, graceful halt is enough
         @cli.transition_to(:stopped) { |c| c.shutdown }
       # REFACTOR: Do not use exception to control the flow
       rescue CLI::TargetStateNotReached, CLI::ShutdownNotSupported

data/lib/vagrant-lxc/plugin.rb

@@ -1,4 +1,5 @@
-require "vagrant"
+require 'vagrant'
+require 'vagrant-backports/utils'
 
 module Vagrant
   module LXC
@@ -9,7 +10,9 @@ module Vagrant
       LXC-based virtual machines.
       EOF
 
-      provider(:lxc, parallel: true) do
+      extra = []
+      extra << {parallel: true} if Vagrant::Backports.vagrant_1_2_or_later?
+      provider(:lxc, *extra) do
         require File.expand_path("../provider", __FILE__)
 
         I18n.load_path << File.expand_path(File.dirname(__FILE__) + '/../../locales/en.yml')
@@ -18,14 +21,29 @@ module Vagrant
         Provider
       end
 
+      command "lxc" do
+        require_relative 'command/root'
+        Command::Root
+      end
+
       config(:lxc, :provider) do
         require File.expand_path("../config", __FILE__)
         Config
       end
-    end
 
-    def self.vagrant_1_3_or_later
-      Gem::Version.new(Vagrant::VERSION) >= Gem::Version.new('1.3.0')
+      if Vagrant::Backports.vagrant_1_4_or_later?
+        synced_folder(:lxc) do
+          require File.expand_path("../synced_folder", __FILE__)
+          SyncedFolder
+        end
+      end
+
+      if Vagrant::Backports.vagrant_1_5_or_later?
+        provider_capability("lxc", "public_address") do
+          require_relative "provider/cap/public_address"
+          Provider::Cap::PublicAddress
+        end
+      end
     end
   end
 end

data/lib/vagrant-lxc/provider/cap/public_address.rb

@@ -0,0 +1,17 @@
+module Vagrant
+  module LXC
+    class Provider
+      module Cap
+        module PublicAddress
+          def self.public_address(machine)
+            return nil if machine.state.id != :running
+
+            ssh_info = machine.ssh_info
+            return nil if !ssh_info
+            ssh_info[:host]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/synced_folder.rb

@@ -0,0 +1,42 @@
+module Vagrant
+  module LXC
+    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
+      def usable?(machine)
+        # These synced folders only work if the provider is LXC
+        machine.provider_name == :lxc
+      end
+
+      def prepare(machine, folders, _opts)
+        machine.ui.output(I18n.t("vagrant.actions.lxc.share_folders.preparing"))
+
+        folders.each do |id, data|
+          host_path  = Pathname.new(File.expand_path(data[:hostpath], machine.env.root_path))
+          guest_path = data[:guestpath]
+
+          machine.env.ui.warn(I18n.t("vagrant_lxc.messages.warn_owner")) if data[:owner]
+          machine.env.ui.warn(I18n.t("vagrant_lxc.messages.warn_group")) if data[:group]
+
+          if !host_path.directory? && data[:create]
+            # Host path doesn't exist, so let's create it.
+            @logger.info("Host path doesn't exist, creating: #{host_path}")
+
+            begin
+              host_path.mkpath
+            rescue Errno::EACCES
+              raise Vagrant::Errors::SharedFolderCreateFailed,
+                :path => hostpath.to_s
+            end
+          end
+
+          mount_opts = data[:mount_options]
+          machine.provider.driver.share_folder(host_path, guest_path, mount_opts)
+          # Guest path specified, so mount the folder to specified point
+          machine.ui.detail(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
+                                guestpath:  data[:guestpath],
+                                hostpath:   data[:hostpath],
+                                guest_path: data[:guestpath]))
+        end
+      end
+    end
+  end
+end