vagrant-lxc-2.1-patch 1.4.0

data/lib/vagrant-lxc/errors.rb

@@ -0,0 +1,62 @@
+require 'vagrant/errors'
+
+module Vagrant
+  module LXC
+    module Errors
+      class ExecuteError < Vagrant::Errors::VagrantError
+        error_key(:lxc_execute_error)
+        attr_reader :stderr, :stdout, :exitcode
+        def initialize(message, *args)
+          super
+          if message.is_a?(Hash)
+            @stderr = message[:stderr]
+            @stdout = message[:stdout]
+            @exitcode = message[:exitcode]
+          end
+        end
+      end
+
+      # Raised when user interrupts a subprocess
+      class SubprocessInterruptError < Vagrant::Errors::VagrantError
+        error_key(:lxc_interrupt_error)
+        def initialize(message, *args)
+          super
+        end
+      end
+
+
+      class LxcLinuxRequired < Vagrant::Errors::VagrantError
+        error_key(:lxc_linux_required)
+      end
+
+      class LxcNotInstalled < Vagrant::Errors::VagrantError
+        error_key(:lxc_not_installed)
+      end
+
+      class ContainerAlreadyExists < Vagrant::Errors::VagrantError
+        error_key(:lxc_container_already_exists)
+      end
+
+      class CommandNotSupported < Vagrant::Errors::VagrantError
+        error_key(:lxc_command_not_supported)
+      end
+
+      # Box related errors
+      class TemplateFileMissing < Vagrant::Errors::VagrantError
+        error_key(:lxc_template_file_missing)
+      end
+      class TemplatesDirMissing < Vagrant::Errors::VagrantError
+        error_key(:lxc_templates_dir_missing)
+      end
+      class RootFSTarballMissing < Vagrant::Errors::VagrantError
+        error_key(:lxc_invalid_box_version)
+      end
+      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/plugin.rb

@@ -0,0 +1,51 @@
+require 'vagrant'
+
+module Vagrant
+  module LXC
+    class Plugin < Vagrant.plugin("2")
+      name "vagrant-lxc"
+      description <<-EOF
+      The LXC provider allows Vagrant to manage and control
+      LXC-based virtual machines.
+      EOF
+
+      provider(:lxc, parallel: true, priority: 7) do
+        require File.expand_path("../provider", __FILE__)
+        init!
+        Provider
+      end
+
+      command "lxc" do
+        require_relative 'command/root'
+        init!
+        Command::Root
+      end
+
+      config(:lxc, :provider) do
+        require File.expand_path("../config", __FILE__)
+        init!
+        Config
+      end
+
+      synced_folder(:lxc) do
+        require File.expand_path("../synced_folder", __FILE__)
+        SyncedFolder
+      end
+
+      provider_capability("lxc", "public_address") do
+        require_relative "provider/cap/public_address"
+        Provider::Cap::PublicAddress
+      end
+
+      protected
+
+      def self.init!
+        return if defined?(@_init)
+        I18n.load_path << File.expand_path(File.dirname(__FILE__) + '/../../locales/en.yml')
+        I18n.reload!
+        @_init = true
+      end
+
+    end
+  end
+end

data/lib/vagrant-lxc/provider.rb

@@ -0,0 +1,101 @@
+require "log4r"
+
+require "vagrant-lxc/action"
+require "vagrant-lxc/driver"
+
+module Vagrant
+  module LXC
+    class Provider < Vagrant.plugin("2", :provider)
+      attr_reader :driver
+
+      def self.usable?(raise_error=false)
+        if !Vagrant::Util::Platform.linux?
+          raise Errors::LxcLinuxRequired
+        end
+
+        true
+      end
+
+      def initialize(machine)
+        @logger    = Log4r::Logger.new("vagrant::provider::lxc")
+        @machine   = machine
+
+        ensure_lxc_installed!
+        machine_id_changed
+      end
+
+      def ensure_lxc_installed!
+        begin
+          SudoWrapper.new(privileged: @machine.provider_config.privileged).run("which", "lxc-create")
+        rescue Vagrant::LXC::Errors::ExecuteError
+          raise Errors::LxcNotInstalled
+        end
+      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}")
+          @driver = Driver.new(id, privileged: @machine.provider_config.privileged)
+          @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.")
+          id = nil
+          retry
+        end
+      end
+
+      # @see Vagrant::Plugin::V2::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}"
+        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 running then we cannot possibly SSH into it, so
+        # we return nil.
+        return nil if state.id != :running
+
+        # Run a custom action called "ssh_ip" which does what it says and puts
+        # the IP found into the `:machine_ip` key in the environment.
+        env = @machine.action("ssh_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 => env[:machine_ip],
+          :port => @machine.config.ssh.guest_port
+        }
+      end
+
+      def state
+        state_id = nil
+        state_id = :not_created if !@driver.container_name
+        state_id = @driver.state if !state_id
+        state_id = :unknown if !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
+        id = @machine.id ? @machine.id : "new VM"
+        "LXC (#{id})"
+      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/sudo_wrapper.rb

@@ -0,0 +1,104 @@
+module Vagrant
+  module LXC
+    class SudoWrapper
+      # Include this so we can use `Subprocess` more easily.
+      include Vagrant::Util::Retryable
+
+      attr_reader :wrapper_path
+
+      def self.dest_path
+        "/usr/local/bin/vagrant-lxc-wrapper"
+      end
+
+      def initialize(privileged: true)
+        @wrapper_path = Pathname.new(SudoWrapper.dest_path).exist? && SudoWrapper.dest_path || nil
+        @privileged   = privileged
+        @logger       = Log4r::Logger.new("vagrant::lxc::sudo_wrapper")
+      end
+
+      def run(*command)
+        options = command.last.is_a?(Hash) ? command.last : {}
+
+        # Avoid running LXC commands with a restrictive umask.
+        # Otherwise disasters occur, like the container root directory
+        # having permissions `rwxr-x---` which prevents the `vagrant`
+        # user from accessing its own home directory; among other
+        # problems, SSH cannot then read `authorized_keys`!
+        old_mask = File.umask
+        File.umask(old_mask & 022)  # allow all `r` and `x` bits
+
+        begin
+          if @privileged
+            if @wrapper_path && !options[:no_wrapper]
+              command.unshift @wrapper_path
+              execute *(['sudo'] + command)
+            else
+              execute *(['sudo', '/usr/bin/env'] + command)
+            end
+          else
+            execute *(['/usr/bin/env'] + command)
+          end
+        ensure
+          File.umask(old_mask)
+        end
+      end
+
+      private
+
+      # 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
+              raise LXC::Errors::SubprocessInterruptError, command.inspect
+            else
+              raise LXC::Errors::ExecuteError,
+                command: command.inspect, stderr: r.stderr, stdout: r.stdout, exitcode: r.exit_code
+            end
+          end
+        end
+
+        # Return the output, making sure to replace any Windows-style
+        # newlines with Unix-style.
+        stdout = r.stdout.gsub("\r\n", "\n")
+        if opts[:show_stderr]
+          { :stdout => stdout, :stderr => r.stderr.gsub("\r\n", "\n") }
+        else
+          stdout
+        end
+      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

data/lib/vagrant-lxc/synced_folder.rb

@@ -0,0 +1,72 @@
+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"))
+        # short guestpaths first, so we don't step on ourselves
+        folders = folders.sort_by do |id, data|
+          if data[:guestpath]
+            data[:guestpath].length
+          else
+            # A long enough path to just do this at the end.
+            10000
+          end
+        end
+
+        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
+
+      def enable(machine, folders, _opts)
+        # Emit an upstart event if we can
+        return unless machine.communicate.test("test -x /sbin/initctl")
+
+        # short guestpaths first, so we don't step on ourselves
+        folders = folders.sort_by do |id, data|
+          if data[:guestpath]
+            data[:guestpath].length
+          else
+            # A long enough path to just do this at the end.
+            10000
+          end
+        end
+
+        folders.each do |id, data|
+          guest_path = data[:guestpath]
+          machine.communicate.sudo(
+            "/sbin/initctl emit --no-wait vagrant-mounted MOUNTPOINT=#{guest_path}")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/version.rb

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

data/locales/en.yml

@@ -0,0 +1,82 @@
+en:
+  vagrant_lxc:
+    messages:
+      not_created: |-
+        The container hasn't been created yet.
+      not_running: |-
+        The container is not currently running.
+      will_not_destroy: |-
+        The container '%{name}' will not be destroyed, since the confirmation
+        was declined.
+      starting: |-
+        Starting container...
+      force_shutdown: |-
+        Forcing shutdown of container...
+      warn_networks: |-
+        Warning! The LXC provider doesn't support public networks, the settings
+        will be silently ignored.
+      warn_group: |-
+        Warning! The LXC provider doesn't support the :group parameter for synced
+        folders. It will be silently ignored.
+      warn_owner: |-
+        Warning! The LXC provider doesn't support the :owner parameter for synced
+        folders. It will be silently ignored.
+      setup_private_network: |-
+        Setting up private networks...
+      remove_bridge: |-
+        Removing bridge '%{name}'...
+
+  vagrant:
+    commands:
+      status:
+        stopped: |-
+          The container is currently stopped. Run `vagrant up` to bring it up again.
+
+    actions:
+      lxc:
+        compressing_rootfs: Compressing container's rootfs...
+
+        share_folders:
+          preparing: Setting up mount entries for shared folders...
+
+    errors:
+      lxc_interrupt_error: |-
+        Interrupted
+
+      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_incompatible_box: |-
+        The base box you are trying to use is not compatible with the installed
+        vagrant-lxc version. Supported box versions are %{supported} but %{found} was found.
+
+      lxc_template_file_missing: |-
+        The template file used for creating the container was not found for %{name}
+        box.
+
+      lxc_templates_dir_missing: |-
+        Unable to identify lxc templates path.
+
+        Looked up under: %{paths}
+
+      lxc_linux_required: |-
+        The LXC provider only works on Linux. Please try to use
+        another provider.
+
+      lxc_not_installed: |-
+        The `lxc` package does not seem to be installed or `lxc-create` is not accessible on the PATH.
+
+      lxc_redir_not_installed: |-
+        `redir` is not installed or is not accessible on the PATH.
+
+      lxc_container_already_exists: |-
+        There is container on your system with the same name you've specified
+        on your Vagrantfile (%{name}), please choose a different one or
+        run `lxc-destroy --name %{name}` and try again.
+
+      lxc_command_not_supported: |-
+        Command (lxc-%{command}) not supported in version %{version}.
+        This command is available with version %{available_version}.