vagrant-libvirt 0.0.40 → 0.0.41

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

@@ -1,221 +0,0 @@
-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
-            ))
-
-            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'}
-          ) + 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 = ''
-          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

@@ -1,35 +0,0 @@
-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?
-
-          @logger.info('Trying gracefull shutdown.')
-          domain.shutdown
-          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

@@ -1,156 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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