vagrant-libvirt 0.0.41 → 0.0.42

data/lib/vagrant-libvirt/driver.rb

@@ -0,0 +1,118 @@
+require 'fog/libvirt'
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    class Driver
+      # store the connection at the process level
+      #
+      # possibly this should be a connection pool using the connection
+      # settings as a key to allow per machine connection attributes
+      # to be used.
+      @@connection = nil
+
+      def initialize(machine)
+        @logger = Log4r::Logger.new('vagrant_libvirt::driver')
+        @machine = machine
+      end
+
+      def connection
+        # If already connected to libvirt, just use it and don't connect
+        # again.
+        return @@connection if @@connection
+
+        # Get config options for libvirt provider.
+        config = @machine.provider_config
+        uri = config.uri
+
+        conn_attr = {}
+        conn_attr[:provider] = 'libvirt'
+        conn_attr[:libvirt_uri] = uri
+        conn_attr[:libvirt_username] = config.username if config.username
+        conn_attr[:libvirt_password] = config.password if config.password
+
+        # Setup command for retrieving IP address for newly created machine
+        # with some MAC address. Get it from dnsmasq leases table
+        ip_command = %q( awk "/$mac/ {print \$1}" /proc/net/arp )
+        conn_attr[:libvirt_ip_command] = ip_command
+
+        @logger.info("Connecting to Libvirt (#{uri}) ...")
+        begin
+          @@connection = Fog::Compute.new(conn_attr)
+        rescue Fog::Errors::Error => e
+          raise Errors::FogLibvirtConnectionError,
+                error_message: e.message
+        end
+
+        @@connection
+      end
+
+      def get_domain(mid)
+        begin
+          domain = connection.servers.get(mid)
+        rescue Libvirt::RetrieveError => e
+          if e.libvirt_code == ProviderLibvirt::Util::ErrorCodes::VIR_ERR_NO_DOMAIN
+            @logger.debug("machine #{mid} not found #{e}.")
+            return nil
+          else
+            raise e
+          end
+        end
+
+        domain
+      end
+
+      def created?(mid)
+        domain = get_domain(mid)
+        !domain.nil?
+      end
+
+      def get_ipaddress(machine)
+        # Find the machine
+        domain = get_domain(machine.id)
+
+        if domain.nil?
+          # The machine can't be found
+          return nil
+        end
+
+        # Get IP address from arp table
+        ip_address = nil
+        begin
+          domain.wait_for(2) do
+            addresses.each_pair do |_type, ip|
+              # Multiple leases are separated with a newline, return only
+              # the most recent address
+              ip_address = ip[0].split("\n").first unless ip[0].nil?
+            end
+            !ip_address.nil?
+          end
+        rescue Fog::Errors::TimeoutError
+          @logger.info('Timeout at waiting for an ip address for machine %s' % machine.name)
+        end
+
+        unless ip_address
+          @logger.info('No arp table entry found for machine %s' % machine.name)
+          return nil
+        end
+
+        ip_address
+      end
+
+      def state(machine)
+        # may be other error states with initial retreival we can't handle
+        begin
+          domain = get_domain(machine.id)
+        rescue Libvirt::RetrieveError => e
+          @logger.debug("Machine #{machine.id} not found #{e}.")
+          return :not_created
+        end
+
+        # TODO: terminated no longer appears to be a valid fog state, remove?
+        return :not_created if domain.nil? || domain.state.to_sym == :terminated
+
+        domain.state.tr('-', '_').to_sym
+      end
+    end
+  end
+end

data/lib/vagrant-libvirt/errors.rb

@@ -0,0 +1,153 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Errors
+      class VagrantLibvirtError < Vagrant::Errors::VagrantError
+        error_namespace('vagrant_libvirt.errors')
+      end
+
+      # package not supported
+      class PackageNotSupported < VagrantLibvirtError
+        error_key(:package_not_supported)
+      end
+
+      # Storage pools and volumes exceptions
+      class NoStoragePool < VagrantLibvirtError
+        error_key(:no_storage_pool)
+      end
+
+      class DomainVolumeExists < VagrantLibvirtError
+        error_key(:domain_volume_exists)
+      end
+
+      class NoDomainVolume < VagrantLibvirtError
+        error_key(:no_domain_volume)
+      end
+
+      class CreatingStoragePoolError < VagrantLibvirtError
+        error_key(:creating_storage_pool_error)
+      end
+
+      class ImageUploadError < VagrantLibvirtError
+        error_key(:image_upload_error)
+      end
+
+      # Box exceptions
+      class NoBoxVolume < VagrantLibvirtError
+        error_key(:no_box_volume)
+      end
+
+      class NoBoxVirtualSizeSet < VagrantLibvirtError
+        error_key(:no_box_virtual_size)
+      end
+
+      class NoBoxFormatSet < VagrantLibvirtError
+        error_key(:no_box_format)
+      end
+
+      class WrongBoxFormatSet < VagrantLibvirtError
+        error_key(:wrong_box_format)
+      end
+
+      # Fog libvirt exceptions
+      class FogError < VagrantLibvirtError
+        error_key(:fog_error)
+      end
+
+      class FogLibvirtConnectionError < VagrantLibvirtError
+        error_key(:fog_libvirt_connection_error)
+      end
+
+      class FogCreateVolumeError < VagrantLibvirtError
+        error_key(:fog_create_volume_error)
+      end
+
+      class FogCreateDomainVolumeError < VagrantLibvirtError
+        error_key(:fog_create_domain_volume_error)
+      end
+
+      class FogCreateServerError < VagrantLibvirtError
+        error_key(:fog_create_server_error)
+      end
+
+      # Network exceptions
+      class ManagementNetworkError < VagrantLibvirtError
+        error_key(:management_network_error)
+      end
+
+      class NetworkNameAndAddressMismatch < VagrantLibvirtError
+        error_key(:network_name_and_address_mismatch)
+      end
+
+      class DHCPMismatch < VagrantLibvirtError
+        error_key(:dhcp_mismatch)
+      end
+
+      class CreateNetworkError < VagrantLibvirtError
+        error_key(:create_network_error)
+      end
+
+      class DestroyNetworkError < VagrantLibvirtError
+        error_key(:destroy_network_error)
+      end
+
+      class NetworkNotAvailableError < VagrantLibvirtError
+        error_key(:network_not_available_error)
+      end
+
+      class AutostartNetworkError < VagrantLibvirtError
+        error_key(:autostart_network_error)
+      end
+
+      class ActivateNetworkError < VagrantLibvirtError
+        error_key(:activate_network_error)
+      end
+
+      class TunnelPortNotDefined < VagrantLibvirtError
+        error_key(:tunnel_port_not_defined)
+      end
+
+      class ManagementNetworkRequired < VagrantLibvirtError
+        error_key(:management_network_required)
+      end
+
+      # Other exceptions
+      class InterfaceSlotNotAvailable < VagrantLibvirtError
+        error_key(:interface_slot_not_available)
+      end
+
+      class InterfaceSlotExhausted < VagrantLibvirtError
+        error_key(:interface_slot_exhausted)
+      end
+
+      class RsyncError < VagrantLibvirtError
+        error_key(:rsync_error)
+      end
+
+      class DomainNameExists < VagrantLibvirtError
+        error_key(:domain_name_exists)
+      end
+
+      class NoDomainError < VagrantLibvirtError
+        error_key(:no_domain_error)
+      end
+
+      class AttachDeviceError < VagrantLibvirtError
+        error_key(:attach_device_error)
+      end
+
+      class DetachDeviceError < VagrantLibvirtError
+        error_key(:detach_device_error)
+      end
+
+      class NoIpAddressError < VagrantLibvirtError
+        error_key(:no_ip_address_error)
+      end
+
+      class DeleteSnapshotError < VagrantLibvirtError
+        error_key(:delete_snapshot_error)
+      end
+    end
+  end
+end

data/lib/vagrant-libvirt/plugin.rb

@@ -0,0 +1,92 @@
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The Vagrant Libvirt plugin must be run within Vagrant.'
+end
+
+# compatibility fix to define constant not available vagrant <1.6
+::Vagrant::MachineState::NOT_CREATED_ID ||= :not_created
+
+module VagrantPlugins
+  module ProviderLibvirt
+    class Plugin < Vagrant.plugin('2')
+      name 'libvirt'
+      description <<-DESC
+      Vagrant plugin to manage VMs in libvirt.
+      DESC
+
+      config('libvirt', :provider) do
+        require_relative 'config'
+        Config
+      end
+
+      provider('libvirt', parallel: true, box_optional: true) do
+        require_relative 'provider'
+        Provider
+      end
+
+      action_hook(:remove_libvirt_image) do |hook|
+        hook.after Vagrant::Action::Builtin::BoxRemove, Action.remove_libvirt_image
+      end
+
+      guest_capability('linux', 'mount_p9_shared_folder') do
+        require_relative 'cap/mount_p9'
+        Cap::MountP9
+      end
+
+      provider_capability(:libvirt, :nic_mac_addresses) do
+        require_relative 'cap/nic_mac_addresses'
+        Cap::NicMacAddresses
+      end
+
+      # lower priority than nfs or rsync
+      # https://github.com/vagrant-libvirt/vagrant-libvirt/pull/170
+      synced_folder('9p', 4) do
+        require_relative 'cap/synced_folder'
+        VagrantPlugins::SyncedFolder9p::SyncedFolder
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path('locales/en.yml',
+                                           ProviderLibvirt.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require 'log4r'
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV['VAGRANT_LOG'].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil unless level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new('vagrant_libvirt')
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+
+      # Setup logging and i18n before any autoloading loads other classes
+      # with logging configured as this prevents inheritance of the log level
+      # from the parent logger.
+      setup_logging
+      setup_i18n
+    end
+  end
+end

data/lib/vagrant-libvirt/provider.rb

@@ -0,0 +1,130 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    autoload :Driver, 'vagrant-libvirt/driver'
+
+    # This is the base class for a provider for the V2 API. A provider
+    # is responsible for creating compute resources to match the
+    # needs of a Vagrant-configured system.
+    class Provider < Vagrant.plugin('2', :provider)
+      def initialize(machine)
+        @machine = machine
+        raise 'REQUIRE USE RUBY >= 1.9.3 VERSION' if RUBY_VERSION < '1.9.3'
+      end
+
+      # This should return an action callable for the given name.
+      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 Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def driver
+        return @driver if @driver
+
+        @driver = Driver.new(@machine)
+      end
+
+      # This method is called if the underying machine ID changes. Providers
+      # can use this method to load in new data for the actual backing
+      # machine or to realize that the machine is now gone (the ID can
+      # become `nil`).
+      def machine_id_changed; end
+
+      # This should return a hash of information that explains how to
+      # SSH into the machine. If the machine is not at a point where
+      # SSH is even possible, then `nil` should be returned.
+      def ssh_info
+        # Return the ssh_info if already retrieved otherwise call the driver
+        # and save the result.
+        #
+        # Ssh info has following format..
+        #
+        # {
+        #  :host => "1.2.3.4",
+        #  :port => "22",
+        #  :username => "mitchellh",
+        #  :private_key_path => "/path/to/my/key"
+        # }
+        # note that modifing @machine.id or accessing @machine.state is not
+        # thread safe, so be careful to avoid these here as this method may
+        # be called from other threads of execution.
+        return nil if state.id != :running
+
+        ip = driver.get_ipaddress(@machine)
+
+        # if can't determine the IP, just return nil and let the core
+        # deal with it, similar to the docker provider
+        return nil unless ip
+
+        ssh_info = {
+          host: ip,
+          port: @machine.config.ssh.guest_port,
+          forward_agent: @machine.config.ssh.forward_agent,
+          forward_x11: @machine.config.ssh.forward_x11
+        }
+
+        if @machine.provider_config.connect_via_ssh
+          ssh_info[:proxy_command] =
+            "ssh '#{@machine.provider_config.host}' " \
+            "-l '#{@machine.provider_config.username}' " \
+            "-i '#{@machine.provider_config.id_ssh_key_file}' " \
+            'nc %h %p'
+
+        end
+
+        ssh_info
+      end
+
+      def mac_addresses
+        # Run a custom action called "read_mac_addresses" which will return
+        # a list of mac addresses used by the machine. The returned data will
+        # be in the following format:
+        #
+        # {
+        #   <ADAPTER_ID>: <MAC>
+        # }
+        env = @machine.action('read_mac_addresses')
+        env[:machine_mac_addresses]
+      end
+
+      # This should return the state of the machine within this provider.
+      # The state must be an instance of {MachineState}.
+      def state
+        state_id = nil
+        state_id = :not_created unless @machine.id
+        state_id = :not_created if
+          !state_id && (!@machine.id || !driver.created?(@machine.id))
+        # Query the driver for the current state of the machine
+        state_id = driver.state(@machine) if @machine.id && !state_id
+        state_id = :unknown unless state_id
+
+        # This is a special pseudo-state so that we don't set the
+        # NOT_CREATED_ID while we're setting up the machine. This avoids
+        # clearing the data dir.
+        state_id = :preparing if @machine.id == 'preparing'
+
+        # Get the short and long description
+        short = state_id.to_s.tr('_', ' ')
+        long  = I18n.t("vagrant_libvirt.states.#{state_id}")
+
+        # If we're not created, then specify the special ID flag
+        if state_id == :not_created
+          state_id = Vagrant::MachineState::NOT_CREATED_ID
+        end
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id.nil? ? 'new' : @machine.id
+        "Libvirt (#{id})"
+      end
+    end
+  end
+end