vagrant-lxc-2.1-patch 1.4.0

data/lib/vagrant-lxc/config.rb

@@ -0,0 +1,73 @@
+module Vagrant
+  module LXC
+    class Config < Vagrant.plugin("2", :config)
+      # An array of container's configuration overrides to be provided to `lxc-start`.
+      #
+      # @return [Array]
+      attr_reader :customizations
+
+      # A string that contains the backing store type used with lxc-create -B
+      attr_accessor :backingstore
+
+      # Optional arguments for the backing store, such as --fssize, --fstype, ...
+      #
+      # @return [Array]
+      attr_accessor :backingstore_options
+
+      # A string to explicitly set the container name. To use the vagrant
+      # machine name, set this to :machine
+      attr_accessor :container_name
+
+      # Size (as a string like '400M') of the tmpfs to mount at /tmp on boot.
+      # Set to false or nil to disable the tmpfs mount altogether. Defaults to '2G'.
+      attr_accessor :tmpfs_mount_size
+
+      attr_accessor :fetch_ip_tries
+
+      # Whether the container needs to be privileged. Defaults to true (unprivileged containers
+      # is a very new feature in vagrant-lxc). If false, will try creating an unprivileged
+      # container. If it can't, will revert to the old "sudo wrapper" method to create a privileged
+      # container.
+      attr_accessor :privileged
+
+      def initialize
+        @customizations = []
+        @backingstore = UNSET_VALUE
+        @backingstore_options = []
+        @container_name = UNSET_VALUE
+        @tmpfs_mount_size = UNSET_VALUE
+        @fetch_ip_tries = UNSET_VALUE
+        @privileged = UNSET_VALUE
+      end
+
+      # Customize the container by calling `lxc-start` with the given
+      # configuration overrides.
+      #
+      # For example, if you want to set the memory limit, you can use it
+      # like: config.customize 'cgroup.memory.limit_in_bytes', '400M'
+      #
+      # When `lxc-start`ing the container, vagrant-lxc will pass in
+      # "-s lxc.cgroup.memory.limit_in_bytes=400M" to it.
+      #
+      # @param [String] key Configuration key to override
+      # @param [String] value Configuration value to override
+      def customize(key, value)
+        @customizations << [key, value]
+      end
+
+      # Stores options for backingstores like lvm, btrfs, etc
+      def backingstore_option(key, value)
+        @backingstore_options << [key, value]
+      end
+
+      def finalize!
+        @container_name = nil if @container_name == UNSET_VALUE
+        @backingstore = nil if @backingstore == UNSET_VALUE
+        @existing_container_name = nil if @existing_container_name == UNSET_VALUE
+        @tmpfs_mount_size = '2G' if @tmpfs_mount_size == UNSET_VALUE
+        @fetch_ip_tries = 10 if @fetch_ip_tries == UNSET_VALUE
+        @privileged = true if @privileged == UNSET_VALUE
+      end
+    end
+  end
+end

data/lib/vagrant-lxc/driver.rb

@@ -0,0 +1,288 @@
+require "vagrant/util/retryable"
+require "vagrant/util/subprocess"
+
+require "vagrant-lxc/errors"
+require "vagrant-lxc/driver/cli"
+require "vagrant-lxc/sudo_wrapper"
+
+require "etc"
+
+require "tempfile"
+
+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
+
+      # Default root folder where container configs are stored
+      attr_reader :container_name,
+                  :customizations
+
+      def initialize(container_name, sudo_wrapper = nil, cli = nil, privileged: true)
+        @container_name = container_name
+        @sudo_wrapper   = sudo_wrapper || SudoWrapper.new(privileged: privileged)
+        @cli            = cli || CLI.new(@sudo_wrapper, container_name)
+        @logger         = Log4r::Logger.new("vagrant::provider::lxc::driver")
+        @customizations = []
+      end
+
+      def validate!
+        raise ContainerNotFound if @container_name && ! @cli.list.include?(@container_name)
+      end
+
+      # Root folder where container configs are stored
+      def containers_path
+        @containers_path ||= @cli.config('lxc.lxcpath')
+      end
+
+      def all_containers
+        @cli.list
+      end
+
+      def base_path
+        Pathname.new("#{containers_path}/#{@container_name}")
+      end
+
+      def config_path
+        base_path.join('config').to_s
+      end 
+
+      def rootfs_path
+        config_entry = config_string.match(/^lxc\.rootfs\s+=\s+(.+)$/)[1]
+        case config_entry
+        when /^overlayfs:/
+          # Split on colon (:), ignoring any colon escaped by an escape character ( \ )
+          # Pays attention to when the escape character is itself escaped.
+          fs_type, master_path, overlay_path = config_entry.split(/(?<!\\)(?:\\\\)*:/)
+          if overlay_path
+            Pathname.new(overlay_path)
+          else
+            # Malformed: fall back to prior behaviour
+            Pathname.new(config_entry)
+          end
+        else
+          Pathname.new(config_entry)
+        end
+      end
+
+      def mac_address
+        return @mac_address if @mac_address
+
+        if config_string =~ /^lxc\.network\.hwaddr\s*+=\s*+(.+)$/
+          @mac_address = $1
+        end
+      end
+
+      def config_string
+        @sudo_wrapper.run('cat', config_path)
+      end
+
+      def create(name, backingstore, backingstore_options, template_path, config_file, template_options = {})
+        @cli.name = @container_name = name
+
+        @logger.debug "Creating container..."
+        @cli.create template_path, backingstore, backingstore_options, config_file, template_options
+      end
+
+      def share_folders(folders)
+        folders.each do |f|
+          share_folder(f[:hostpath], f[:guestpath], f.fetch(:mount_options, nil))
+        end
+      end
+
+      def share_folder(host_path, guest_path, mount_options = nil)
+        guest_path    = guest_path.gsub(/^\//, '').gsub(' ', '\\\040')
+        mount_options = Array(mount_options || ['bind', 'create=dir'])
+        host_path     = host_path.to_s.gsub(' ', '\\\040')
+        @customizations << ['mount.entry', "#{host_path} #{guest_path} none #{mount_options.join(',')} 0 0"]
+      end
+
+      def start(customizations)
+        @logger.info('Starting container...')
+
+        if ENV['LXC_START_LOG_FILE']
+          extra = ['-o', ENV['LXC_START_LOG_FILE'], '-l', 'DEBUG']
+        end
+
+        prune_customizations
+        write_customizations(customizations + @customizations)
+
+        @cli.start(extra)
+      end
+
+      def forced_halt
+        @logger.info('Shutting down container...')
+        @cli.transition_to(:stopped) { |c| c.stop }
+      end
+
+      def destroy
+        @cli.destroy
+      end
+
+      def supports_attach?
+        @cli.supports_attach?
+      end
+
+      def attach(*command)
+        @cli.attach(*command)
+      end
+
+      def info(*command)
+        @cli.info(*command)
+      end
+
+      def configure_private_network(bridge_name, bridge_ip, container_name, address_type, ip)
+        @logger.info "Configuring network interface for #{container_name} using #{ip} and bridge #{bridge_name}"
+        if ip
+          ip += '/24'
+        end
+
+        if ! bridge_exists?(bridge_name)
+          if not bridge_ip
+            raise "Bridge is missing and no IP was specified!"
+          end
+
+          @logger.info "Creating the bridge #{bridge_name}"
+          cmd = [
+            'brctl',
+            'addbr',
+            bridge_name
+          ]
+          @sudo_wrapper.run(*cmd)
+        end
+
+        if ! bridge_has_an_ip?(bridge_name)
+          if not bridge_ip
+            raise "Bridge has no IP and none was specified!"
+          end
+          @logger.info "Adding #{bridge_ip} to the bridge #{bridge_name}"
+          cmd = [
+            'ip',
+            'addr',
+            'add',
+            "#{bridge_ip}/24",
+            'dev',
+            bridge_name
+          ]
+          @sudo_wrapper.run(*cmd)
+          @sudo_wrapper.run('ip', 'link', 'set', bridge_name, 'up')
+        end
+
+        cmd = [
+          Vagrant::LXC.source_root.join('scripts/pipework').to_s,
+          bridge_name,
+          container_name,
+          ip ||= "dhcp"
+        ]
+        @sudo_wrapper.run(*cmd)
+      end
+
+      def bridge_has_an_ip?(bridge_name)
+        @logger.info "Checking whether the bridge #{bridge_name} has an IP"
+        `ip -4 addr show scope global #{bridge_name}` =~ /^\s+inet ([0-9.]+)\/[0-9]+\s+/
+      end
+
+      def bridge_exists?(bridge_name)
+        @logger.info "Checking whether bridge #{bridge_name} exists"
+        brctl_output = `ip link | egrep -q " #{bridge_name}:"`
+        $?.to_i == 0
+      end
+
+      def bridge_is_in_use?(bridge_name)
+        # REFACTOR: This method is **VERY** hacky
+        @logger.info "Checking if bridge #{bridge_name} is in use"
+        brctl_output = `brctl show #{bridge_name} 2>/dev/null | tail -n +2 | grep -q veth`
+        $?.to_i == 0
+      end
+
+      def remove_bridge(bridge_name)
+        if ['lxcbr0', 'virbr0'].include? bridge_name
+           @logger.info "Skipping removal of system bridge #{bridge_name}"
+           return
+        end
+
+        return unless bridge_exists?(bridge_name)
+
+        @logger.info "Removing bridge #{bridge_name}"
+        @sudo_wrapper.run('ip', 'link', 'set', bridge_name, 'down')
+        @sudo_wrapper.run('brctl', 'delbr', bridge_name)
+      end
+
+      def version
+        @version ||= @cli.version
+      end
+
+      # TODO: This needs to be reviewed and specs needs to be written
+      def compress_rootfs
+        # TODO: Pass in tmpdir so we can clean up from outside
+        target_path    = "#{Dir.mktmpdir}/rootfs.tar.gz"
+
+        @logger.info "Compressing '#{rootfs_path}' rootfs to #{target_path}"
+        @sudo_wrapper.run('tar', '--numeric-owner', '-cvzf', target_path, '-C',
+          rootfs_path.parent.to_s, "./#{rootfs_path.basename.to_s}")
+
+        @logger.info "Changing rootfs tarball owner"
+        user_details = Etc.getpwnam(Etc.getlogin)
+        @sudo_wrapper.run('chown', "#{user_details.uid}:#{user_details.gid}", target_path)
+
+        target_path
+      end
+
+      def state
+        if @container_name
+          @cli.state
+        end
+      end
+
+      def prune_customizations
+        # Use sed to just strip out the block of code which was inserted by Vagrant
+        @logger.debug 'Prunning vagrant-lxc customizations'
+        contents = config_string
+        contents.gsub! /^# VAGRANT-BEGIN(.|\s)*# VAGRANT-END\n/, ''
+        write_config(contents)
+      end
+
+      def update_config_keys
+        @cli.update_config(config_path)
+      rescue Errors::ExecuteError
+        # not on LXC 2.1+. Doesn't matter, ignore.
+      end
+
+      protected
+
+      def write_customizations(customizations)
+        customizations = customizations.map do |key, value|
+          "lxc.#{key}=#{value}"
+        end
+        customizations.unshift '# VAGRANT-BEGIN'
+        customizations      << "# VAGRANT-END\n"
+
+        contents = config_string
+        contents << customizations.join("\n")
+
+        write_config(contents)
+      end
+
+      def write_config(contents)
+        confpath = base_path.join('config').to_s
+        begin
+          File.open(confpath, File::RDWR) do |file|
+            file.write contents
+          end
+        rescue
+          # We don't have permissions to write in the conf file. That's probably because it's a
+          # privileged container. Work around that through sudo_wrapper.
+          Tempfile.new('lxc-config').tap do |file|
+            file.chmod 0644
+            file.write contents
+            file.close
+            @sudo_wrapper.run 'cp', '-f', file.path, confpath
+            @sudo_wrapper.run 'chown', 'root:root', confpath
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+require "vagrant/util/retryable"
+require "vagrant/util/subprocess"
+
+require "vagrant-lxc/errors"
+
+module Vagrant
+  module LXC
+    class Driver
+      class CLI
+        attr_accessor :name
+
+        class TransitionBlockNotProvided < RuntimeError; end
+        class TargetStateNotReached < RuntimeError
+          def initialize(target_state, state)
+            msg = "Target state '#{target_state}' not reached, currently on '#{state}'"
+            super(msg)
+          end
+        end
+
+        def initialize(sudo_wrapper, name = nil)
+          @sudo_wrapper = sudo_wrapper
+          @name         = name
+          @logger       = Log4r::Logger.new("vagrant::provider::lxc::container::cli")
+        end
+
+        def list
+          run(:ls).split(/\s+/).uniq
+        end
+
+        def version
+          return @version if @version
+          @version = run(:create, '--version')
+          if @version =~ /(lxc version:\s+|)(.+)\s*$/
+            @version = $2.downcase
+          else
+            # TODO: Raise an user friendly error
+            raise 'Unable to parse lxc version!'
+          end
+        end
+
+        def config(param)
+          run(:config, param).gsub("\n", '')
+        end
+
+        def update_config(path)
+          run('update-config', '-c', path)
+        end
+
+        def state
+          if @name && run(:info, '--name', @name, retryable: true) =~ /^state:[^A-Z]+([A-Z]+)$/i
+            $1.downcase.to_sym
+          elsif @name
+            :unknown
+          end
+        end
+
+        def create(template, backingstore, backingstore_options, config_file, template_opts = {})
+          if config_file
+            config_opts = ['-f', config_file]
+          end
+
+          extra = template_opts.to_a.flatten
+          extra.unshift '--' unless extra.empty?
+
+          run :create,
+              '-B', backingstore,
+              '--template', template,
+              '--name',     @name,
+              *(backingstore_options.to_a.flatten),
+              *(config_opts),
+              *extra
+        rescue Errors::ExecuteError => e
+          if e.stderr =~ /already exists/i
+            raise Errors::ContainerAlreadyExists, name: @name
+          else
+            raise
+          end
+        end
+
+        def destroy
+          run :destroy, '--name', @name
+        end
+
+        def start(options = [])
+          run :start, '-d', '--name', @name, *Array(options)
+        end
+
+        ## lxc-stop will exit 2 if machine was already stopped
+        # Man Page:
+        # 2      The specified container exists but was not running.
+        def stop
+          attach '/sbin/halt' if supports_attach?
+          begin
+            run :stop, '--name', @name
+          rescue LXC::Errors::ExecuteError => e
+            if e.exitcode == 2
+               @logger.debug "Machine already stopped, lxc-stop returned 2"
+            else
+		raise e
+            end
+          end
+        end
+
+        def attach(*cmd)
+          cmd = ['--'] + cmd
+
+          if cmd.last.is_a?(Hash)
+            opts       = cmd.pop
+            namespaces = Array(opts[:namespaces]).map(&:upcase).join('|')
+
+            # HACK: The wrapper script should be able to handle this
+            if @sudo_wrapper.wrapper_path
+              namespaces = "'#{namespaces}'"
+            end
+
+            if namespaces
+              extra = ['--namespaces', namespaces]
+            end
+          end
+
+          run :attach, '--name', @name, *((extra || []) + cmd)
+        end
+
+        def info(*cmd)
+          run(:info, '--name', @name, *cmd)
+        end
+
+        def transition_to(target_state, tries = 30, timeout = 1, &block)
+          raise TransitionBlockNotProvided unless block_given?
+
+          yield self
+
+          while (last_state = self.state) != target_state && tries > 0
+            @logger.debug "Target state '#{target_state}' not reached, currently on '#{last_state}'"
+            sleep timeout
+            tries -= 1
+          end
+
+          unless last_state == target_state
+            # TODO: Raise an user friendly message
+            raise TargetStateNotReached.new target_state, last_state
+          end
+        end
+
+        def supports_attach?
+          unless defined?(@supports_attach)
+            begin
+              @supports_attach = true
+              run(:attach, '--name', @name, '--', '/bin/true')
+            rescue LXC::Errors::ExecuteError
+              @supports_attach = false
+            end
+          end
+
+          return @supports_attach
+        end
+
+        private
+
+        def run(command, *args)
+          @sudo_wrapper.run("lxc-#{command}", *args)
+        end
+      end
+    end
+  end
+end