vagrant-libvirt 0.0.41 → 0.0.42

data/lib/vagrant-libvirt/action/forward_ports.rb

@@ -0,0 +1,227 @@
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      # Adds support for vagrant's `forward_ports` configuration directive.
+      class ForwardPorts
+        @@lock = Mutex.new
+
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::forward_ports')
+        end
+
+        def call(env)
+          @env = env
+
+          # Get the ports we're forwarding
+          env[:forwarded_ports] = compile_forwarded_ports(env[:machine].config)
+
+          # Warn if we're port forwarding to any privileged ports
+          env[:forwarded_ports].each do |fp|
+            next unless fp[:host] <= 1024
+            env[:ui].warn I18n.t(
+              'vagrant.actions.vm.forward_ports.privileged_ports'
+            )
+            break
+          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
+          end
+        end
+
+        def forward_ports
+          @env[:forwarded_ports].each do |fp|
+            message_attributes = {
+              adapter: fp[:adapter] || 'eth0',
+              guest_port: fp[:guest],
+              host_port: fp[:host]
+            }
+
+            @env[:ui].info(I18n.t(
+                             'vagrant.actions.vm.forward_ports.forwarding_entry',
+                             message_attributes
+            ))
+
+            if fp[:protocol] == 'udp'
+              env[:ui].warn I18n.t('vagrant_libvirt.warnings.forwarding_udp')
+              next
+            end
+
+            ssh_pid = redirect_port(
+              @env[:machine],
+              fp[:host_ip] || 'localhost',
+              fp[:host],
+              fp[:guest_ip] || @env[:machine].provider.ssh_info[:host],
+              fp[:guest],
+              fp[:gateway_ports] || false
+            )
+            store_ssh_pid(fp[:host], ssh_pid)
+          end
+        end
+
+        private
+
+        def compile_forwarded_ports(config)
+          mappings = {}
+
+          config.vm.networks.each do |type, options|
+            next if options[:disabled]
+
+            next unless type == :forwarded_port && options[:id] != 'ssh'
+            if options.fetch(:host_ip, '').to_s.strip.empty?
+              options.delete(:host_ip)
+            end
+            mappings[options[:host]] = options
+          end
+
+          mappings.values
+        end
+
+        def redirect_port(machine, host_ip, host_port, guest_ip, guest_port,
+                          gateway_ports)
+          ssh_info = machine.ssh_info
+          params = %W(
+            -L
+            #{host_ip}:#{host_port}:#{guest_ip}:#{guest_port}
+            -N
+            #{ssh_info[:host]}
+          ).join(' ')
+          params += ' -g' if gateway_ports
+
+          options = (%W(
+            User=#{ssh_info[:username]}
+            Port=#{ssh_info[:port]}
+            UserKnownHostsFile=/dev/null
+            StrictHostKeyChecking=no
+            PasswordAuthentication=no
+            ForwardX11=#{ssh_info[:forward_x11] ? 'yes' : 'no'}
+            IdentitiesOnly=#{ssh_info[:keys_only] ? 'yes' : 'no'}
+          ) + ssh_info[:private_key_path].map do |pk|
+                "IdentityFile='\"#{pk}\"'"
+              end).map { |s| s.prepend('-o ') }.join(' ')
+
+          options += " -o ProxyCommand=\"#{ssh_info[:proxy_command]}\"" if machine.provider_config.connect_via_ssh
+
+          # TODO: instead of this, try and lock and get the stdin from spawn...
+          ssh_cmd = 'exec '
+          if host_port <= 1024
+            @@lock.synchronize do
+              # TODO: add i18n
+              @env[:ui].info 'Requesting sudo for host port(s) <= 1024'
+              r = system('sudo -v')
+              if r
+                ssh_cmd << 'sudo ' # add sudo prefix
+              end
+            end
+          end
+
+          ssh_cmd << "ssh #{options} #{params}"
+
+          @logger.debug "Forwarding port with `#{ssh_cmd}`"
+          log_file = ssh_forward_log_file(host_ip, host_port,
+                                          guest_ip, guest_port)
+          @logger.info "Logging to #{log_file}"
+          spawn(ssh_cmd, [:out, :err] => [log_file, 'w'])
+        end
+
+        def ssh_forward_log_file(host_ip, host_port, guest_ip, guest_port)
+          log_dir = @env[:machine].data_dir.join('logs')
+          log_dir.mkdir unless log_dir.directory?
+          File.join(
+            log_dir,
+            'ssh-forwarding-%s_%s-%s_%s.log' %
+              [host_ip, host_port, guest_ip, guest_port]
+          )
+        end
+
+        def store_ssh_pid(host_port, ssh_pid)
+          data_dir = @env[:machine].data_dir.join('pids')
+          data_dir.mkdir unless data_dir.directory?
+
+          data_dir.join("ssh_#{host_port}.pid").open('w') do |pid_file|
+            pid_file.write(ssh_pid)
+          end
+        end
+      end
+    end
+  end
+end
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      # Cleans up ssh-forwarded ports on VM halt/destroy.
+      class ClearForwardedPorts
+        @@lock = Mutex.new
+
+        def initialize(app, _env)
+          @app = app
+          @logger = Log4r::Logger.new(
+            'vagrant_libvirt::action::clear_forward_ports'
+          )
+        end
+
+        def call(env)
+          @env = env
+
+          if ssh_pids.any?
+            env[:ui].info I18n.t(
+              'vagrant.actions.vm.clear_forward_ports.deleting'
+            )
+            ssh_pids.each do |tag|
+              next unless ssh_pid?(tag[:pid])
+              @logger.debug "Killing pid #{tag[:pid]}"
+              kill_cmd = ''
+
+              if tag[:port] <= 1024
+                kill_cmd << 'sudo ' # add sudo prefix
+              end
+
+              kill_cmd << "kill #{tag[:pid]}"
+              @@lock.synchronize do
+                system(kill_cmd)
+              end
+            end
+
+            @logger.info 'Removing ssh pid files'
+            remove_ssh_pids
+          else
+            @logger.info 'No ssh pids found'
+          end
+
+          @app.call env
+        end
+
+        protected
+
+        def ssh_pids
+          glob = @env[:machine].data_dir.join('pids').to_s + '/ssh_*.pid'
+          @ssh_pids = Dir[glob].map do |file|
+            {
+              pid: File.read(file).strip.chomp,
+              port: File.basename(file)['ssh_'.length..-1 * ('.pid'.length + 1)].to_i
+            }
+          end
+        end
+
+        def ssh_pid?(pid)
+          @logger.debug 'Checking if #{pid} is an ssh process '\
+                        'with `ps -o cmd= #{pid}`'
+          `ps -o cmd= #{pid}`.strip.chomp =~ /ssh/
+        end
+
+        def remove_ssh_pids
+          glob = @env[:machine].data_dir.join('pids').to_s + '/ssh_*.pid'
+          Dir[glob].each do |file|
+            File.delete file
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-libvirt/action/halt_domain.rb

@@ -0,0 +1,41 @@
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      # Halt the domain.
+      class HaltDomain
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::halt_domain')
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t('vagrant_libvirt.halt_domain'))
+
+          domain = env[:machine].provider.driver.connection.servers.get(env[:machine].id.to_s)
+          raise Errors::NoDomainError if domain.nil?
+
+          begin
+            env[:machine].guest.capability(:halt)
+          rescue
+            @logger.info('Trying libvirt graceful shutdown.')
+            domain.shutdown
+          end
+
+
+          begin
+            domain.wait_for(30) do
+              !ready?
+            end
+          rescue Fog::Errors::TimeoutError
+            @logger.info('VM is still running. Calling force poweroff.')
+            domain.poweroff
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-libvirt/action/handle_box_image.rb

@@ -0,0 +1,156 @@
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      class HandleBoxImage
+        @@lock = Mutex.new
+
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::handle_box_image')
+          @app = app
+        end
+
+        def call(env)
+          # Verify box metadata for mandatory values.
+          #
+          # Virtual size has to be set for allocating space in storage pool.
+          box_virtual_size = env[:machine].box.metadata['virtual_size']
+          raise Errors::NoBoxVirtualSizeSet if box_virtual_size.nil?
+
+          # Support qcow2 format only for now, but other formats with backing
+          # store capability should be usable.
+          box_format = env[:machine].box.metadata['format']
+          if box_format.nil?
+            raise Errors::NoBoxFormatSet
+          elsif box_format != 'qcow2'
+            raise Errors::WrongBoxFormatSet
+          end
+
+          # Get config options
+          config = env[:machine].provider_config
+          box_image_file = env[:machine].box.directory.join('box.img').to_s
+          env[:box_volume_name] = env[:machine].box.name.to_s.dup.gsub('/', '-VAGRANTSLASH-')
+          env[:box_volume_name] << "_vagrant_box_image_#{begin
+                                                           env[:machine].box.version.to_s
+                                                         rescue
+                                                           ''
+                                                         end}.img"
+
+          # Override box_virtual_size
+          if config.machine_virtual_size
+            if config.machine_virtual_size < box_virtual_size
+              # Warn that a virtual size less than the box metadata size
+              # is not supported and will be ignored
+              env[:ui].warn I18n.t(
+                'vagrant_libvirt.warnings.ignoring_virtual_size_too_small',
+                requested: config.machine_virtual_size, minimum: box_virtual_size
+              )
+            else
+              env[:ui].info I18n.t('vagrant_libvirt.manual_resize_required')
+              box_virtual_size = config.machine_virtual_size
+            end
+          end
+          # save for use by later actions
+          env[:box_virtual_size] = box_virtual_size
+
+          # while inside the synchronize block take care not to call the next
+          # action in the chain, as must exit this block first to prevent
+          # locking all subsequent actions as well.
+          @@lock.synchronize do
+            # Don't continue if image already exists in storage pool.
+            break if ProviderLibvirt::Util::Collection.find_matching(
+              env[:machine].provider.driver.connection.volumes.all, env[:box_volume_name]
+            )
+
+            # Box is not available as a storage pool volume. Create and upload
+            # it as a copy of local box image.
+            env[:ui].info(I18n.t('vagrant_libvirt.uploading_volume'))
+
+            # Create new volume in storage pool
+            unless File.exist?(box_image_file)
+              raise Vagrant::Errors::BoxNotFound, name: env[:machine].box.name
+            end
+            box_image_size = File.size(box_image_file) # B
+            message = "Creating volume #{env[:box_volume_name]}"
+            message << " in storage pool #{config.storage_pool_name}."
+            @logger.info(message)
+            begin
+              fog_volume = env[:machine].provider.driver.connection.volumes.create(
+                name:         env[:box_volume_name],
+                allocation:   "#{box_image_size / 1024 / 1024}M",
+                capacity:     "#{box_virtual_size}G",
+                format_type:  box_format,
+                pool_name:    config.storage_pool_name
+              )
+            rescue Fog::Errors::Error => e
+              raise Errors::FogCreateVolumeError,
+                    error_message: e.message
+            end
+
+            # Upload box image to storage pool
+            ret = upload_image(box_image_file, config.storage_pool_name,
+                               env[:box_volume_name], env) do |progress|
+              env[:ui].clear_line
+              env[:ui].report_progress(progress, box_image_size, false)
+            end
+
+            # Clear the line one last time since the progress meter doesn't
+            # disappear immediately.
+            env[:ui].clear_line
+
+            # If upload failed or was interrupted, remove created volume from
+            # storage pool.
+            if env[:interrupted] || !ret
+              begin
+                fog_volume.destroy
+              rescue
+                nil
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+
+        protected
+
+        # Fog libvirt currently doesn't support uploading images to storage
+        # pool volumes. Use ruby-libvirt client instead.
+        def upload_image(image_file, pool_name, volume_name, env)
+          image_size = File.size(image_file) # B
+
+          begin
+            pool = env[:machine].provider.driver.connection.client.lookup_storage_pool_by_name(
+              pool_name
+            )
+            volume = pool.lookup_volume_by_name(volume_name)
+            stream = env[:machine].provider.driver.connection.client.stream
+            volume.upload(stream, offset = 0, length = image_size)
+
+            # Exception ProviderLibvirt::RetrieveError can be raised if buffer is
+            # longer than length accepted by API send function.
+            #
+            # TODO: How to find out if buffer is too large and what is the
+            # length that send function will accept?
+
+            buf_size = 1024 * 250 # 250K
+            progress = 0
+            open(image_file, 'rb') do |io|
+              while (buff = io.read(buf_size))
+                sent = stream.send buff
+                progress += sent
+                yield progress
+              end
+            end
+          rescue => e
+            raise Errors::ImageUploadError,
+                  error_message: e.message
+          end
+
+          progress == image_size
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-libvirt/action/handle_storage_pool.rb

@@ -0,0 +1,57 @@
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      class HandleStoragePool
+        include VagrantPlugins::ProviderLibvirt::Util::ErbTemplate
+
+        @@lock = Mutex.new
+
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::handle_storage_pool')
+          @app = app
+        end
+
+        def call(env)
+          # Get config options.
+          config = env[:machine].provider_config
+
+          # while inside the synchronize block take care not to call the next
+          # action in the chain, as must exit this block first to prevent
+          # locking all subsequent actions as well.
+          @@lock.synchronize do
+            # Check for storage pool, where box image should be created
+            break if ProviderLibvirt::Util::Collection.find_matching(
+              env[:machine].provider.driver.connection.pools.all, config.storage_pool_name
+            )
+
+            @logger.info("No storage pool '#{config.storage_pool_name}' is available.")
+
+            # If user specified other pool than default, don't create default
+            # storage pool, just write error message.
+            raise Errors::NoStoragePool if config.storage_pool_name != 'default'
+
+            @logger.info("Creating storage pool 'default'")
+
+            # Fog libvirt currently doesn't support creating pools. Use
+            # ruby-libvirt client directly.
+            begin
+              libvirt_pool = env[:machine].provider.driver.connection.client.define_storage_pool_xml(
+                to_xml('default_storage_pool')
+              )
+              libvirt_pool.build
+              libvirt_pool.create
+            rescue => e
+              raise Errors::CreatingStoragePoolError,
+                    error_message: e.message
+            end
+            raise Errors::NoStoragePool unless libvirt_pool
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end