vagrant-ovirt3 1.0.0

data/lib/vagrant-ovirt3/action/connect_ovirt.rb

@@ -0,0 +1,84 @@
+require 'fog'
+require 'log4r'
+require 'pp'
+require 'rbovirt'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      class ConnectOVirt
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt3::action::connect_ovirt")
+          @app = app
+        end
+
+        def call(env)
+
+          # We need both, fog and rbovirt client. Sometimes fog doesn't
+          # support some operations like managing quotas, or working with
+          # networks. For this rbovirt client is used.
+          env[:ovirt_client] = OVirtProvider.ovirt_client if \
+            OVirtProvider.ovirt_client != nil
+
+          if OVirtProvider.ovirt_connection != nil
+            env[:ovirt_compute] = OVirtProvider.ovirt_connection
+            return @app.call(env)
+          end
+          
+          # Get config options for ovirt provider.
+          config = env[:machine].provider_config
+
+          conn_attr = {}
+          conn_attr[:provider] = 'ovirt'
+          conn_attr[:ovirt_url] = "#{config.url}/api"
+          conn_attr[:ovirt_username] = config.username if config.username
+          conn_attr[:ovirt_password] = config.password if config.password
+
+          # We need datacenter id in fog connection initialization. But it's
+          # much simpler to use datacenter name in Vagrantfile. So get
+          # datacenter id here from rbovirt client before connecting to fog.
+          env[:ovirt_client] = ovirt_connect(conn_attr)
+          begin
+            datacenter = OVirtProvider::Util::Collection.find_matching(
+              env[:ovirt_client].datacenters, config.datacenter)
+          rescue OVIRT::OvirtException => e
+            raise Errors::FogOVirtConnectionError,
+              :error_message => e.message
+          end
+
+          raise Errors::NoDatacenterError if datacenter == nil
+          conn_attr[:ovirt_datacenter] = datacenter.id
+
+          # Reconnect and prepar rbovirt client with datacenter set from
+          # configuration.
+          env[:ovirt_client] = ovirt_connect(conn_attr)
+          OVirtProvider.ovirt_client = env[:ovirt_client]
+          
+          # Establish fog connection now.
+          @logger.info("Connecting to oVirt (#{config.url}) ...")
+          begin
+            env[:ovirt_compute] = Fog::Compute.new(conn_attr)
+          rescue OVIRT::OvirtException => e
+            raise Errors::FogOVirtConnectionError,
+              :error_message => e.message
+          end
+          OVirtProvider.ovirt_connection = env[:ovirt_compute]
+
+          @app.call(env)
+        end
+
+        private
+
+        def ovirt_connect(credentials)
+          OVIRT::Client.new(
+            credentials[:ovirt_username],
+            credentials[:ovirt_password],
+            credentials[:ovirt_url],
+            credentials[:ovirt_datacenter],
+          )
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-ovirt3/action/create_network_interfaces.rb

@@ -0,0 +1,137 @@
+require 'log4r'
+require 'vagrant/util/scoped_hash_override'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      # Create network interfaces for machine, before VM is running.
+      class CreateNetworkInterfaces
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt3::action::create_network_interfaces")
+          @app = app
+        end
+
+        def call(env)
+          # Get machine first.
+          begin
+            machine = OVirtProvider::Util::Collection.find_matching(
+              env[:ovirt_compute].servers.all, env[:machine].id.to_s)
+          rescue => e
+            raise Errors::NoVMError,
+              :vm_name => env[:machine].id.to_s
+          end
+
+          # Setup list of interfaces before creating them
+          adapters = []
+
+          # First interface is for provisioning, so this slot is not usable.
+          # This interface should be available already from template.
+
+          env[:machine].config.vm.networks.each do |type, options|
+            # We support private and public networks only. They mean both the
+            # same right now.
+            next if type != :private_network and type != :public_network
+
+            # Get options for this interface. Options can be specified in
+            # Vagrantfile in short format (:ip => ...), or provider format
+            # (:ovirt__network_name => ...).
+            options = scoped_hash_override(options, :ovirt)
+            options = {
+              :netmask      => '255.255.255.0',
+              :network_name => 'rhevm',
+              :interface_type => 'virtio'
+            }.merge(options)
+
+            if options[:adapter]
+              if adapters[options[:adapter]]
+                raise Errors::InterfaceSlotNotAvailable
+              end
+
+              free_slot = options[:adapter].to_i
+            else
+              free_slot = find_empty(adapters, start=1)
+              raise Errors::InterfaceSlotNotAvailable if free_slot == nil
+            end
+
+            adapters[free_slot] = options
+          end
+
+          # Create each interface as new domain device
+          adapters.each_with_index do |opts, slot_number|
+            next if slot_number == 0 or opts.nil?
+            iface_number = slot_number + 1
+
+            # Get network id
+            network = OVirtProvider::Util::Collection.find_matching(
+              env[:ovirt_client].networks(:cluster_id => env[:ovirt_cluster].id),
+              opts[:network_name])
+            if network == nil
+              raise Errors::NoNetworkError,
+                :network_name => opts[:network_name]
+            end
+
+            @logger.info("Creating network interface nic#{iface_number}")
+            begin
+              machine.add_interface(
+                :name    => "nic#{iface_number}",
+                :network => network.id,
+                :interface => opts[:interface_type],
+              )
+            rescue => e
+              raise Errors::AddInterfaceError,
+                :error_message => e.message
+            end
+          end
+
+          # Continue the middleware chain.
+          @app.call(env)
+
+          # Configure interfaces that user requested. Machine should be up and
+          # running now.
+          networks_to_configure = []
+
+          adapters.each_with_index do |opts, slot_number|
+            # Skip configuring first interface. It's used for provisioning and
+            # it has to be available during provisioning - ifdown command is
+            # not acceptable here.
+            next if slot_number == 0
+
+            network = {
+              :interface => slot_number,
+              #:mac => ...,
+            }
+
+            if opts[:ip]
+              network = {
+                :type    => :static,
+                :ip      => opts[:ip],
+                :netmask => opts[:netmask],
+                :gateway => opts[:gateway],
+              }.merge(network)
+            else
+              network[:type] = :dhcp
+            end
+
+            networks_to_configure << network
+          end
+
+          env[:ui].info I18n.t("vagrant.actions.vm.network.configuring")
+          env[:machine].guest.capability(
+            :configure_networks, networks_to_configure)
+        end
+
+        private
+
+        def find_empty(array, start=0, stop=8)
+          for i in start..stop
+            return i if !array[i]
+          end
+          return nil
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-ovirt3/action/create_vm.rb

@@ -0,0 +1,113 @@
+require 'log4r'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      class CreateVM
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt3::action::create_vm")
+          @app = app
+        end
+
+        def call(env)
+          # Get config.
+          config = env[:machine].provider_config
+
+          # Gather some info about domain
+          name = env[:domain_name]
+          console = config.console
+          cpus = config.cpus
+          memory_size = config.memory*1024
+
+          # Get cluster
+          if config.cluster == nil
+            cluster = env[:ovirt_compute].clusters.first
+          else
+            cluster = OVirtProvider::Util::Collection.find_matching(
+              env[:ovirt_compute].clusters.all, config.cluster)
+          end
+          raise Error::NoClusterError if cluster == nil
+          # TODO fill env also with other ovirtoptions.
+          env[:ovirt_cluster] = cluster
+
+          # Get template
+          template = OVirtProvider::Util::Collection.find_matching(
+            env[:ovirt_compute].templates.all, config.template)
+          if template == nil
+            raise Error::NoTemplateError,
+              :template_name => config.template
+          end
+
+          # Output the settings we're going to use to the user
+          env[:ui].info(I18n.t("vagrant_ovirt3.creating_vm"))
+          env[:ui].info(" -- Name:          #{name}")
+          env[:ui].info(" -- Cpus:          #{cpus}")
+          env[:ui].info(" -- Memory:        #{memory_size/1024}M")
+          env[:ui].info(" -- Template:      #{template.name}")
+          env[:ui].info(" -- Datacenter:    #{config.datacenter}")
+          env[:ui].info(" -- Cluster:       #{cluster.name}")
+          env[:ui].info(" -- Console:       #{console}")
+          if config.disk_size
+            env[:ui].info(" -- Disk size:     #{config.disk_size}G")
+          end
+
+          # Create oVirt VM.
+          attr = {
+              :name     => name,
+              :cores    => cpus,
+              :memory   => memory_size*1024,
+              :cluster  => cluster.id,
+              :template => template.id,
+              :display  => {:type => console },
+          }
+
+          begin
+            server = env[:ovirt_compute].servers.create(attr)
+          rescue OVIRT::OvirtException => e
+            raise Errors::FogCreateServerError,
+              :error_message => e.message
+          end
+
+          # Immediately save the ID since it is created at this point.
+          env[:machine].id = server.id
+
+          # Wait till all volumes are ready.
+          env[:ui].info(I18n.t("vagrant_ovirt3.wait_for_ready_vm"))
+          for i in 0..10
+            ready = true
+            server = env[:ovirt_compute].servers.get(env[:machine].id.to_s)
+            server.volumes.each do |volume|
+              if volume.status != 'ok'
+                ready = false
+                break
+              end
+            end
+            break if ready
+            sleep 2
+          end
+
+          if not ready
+            raise Errors::WaitForReadyVmTimeout
+          end
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          # Undo the import
+          env[:ui].info(I18n.t("vagrant_ovirt3.error_recovering"))
+          destroy_env = env.dup
+          destroy_env.delete(:interrupted)
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+          env[:action_runner].run(Action.action_destroy, destroy_env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ovirt3/action/destroy_vm.rb

@@ -0,0 +1,25 @@
+require 'log4r'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      class DestroyVM
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt3::action::destroy_vm")
+          @app = app
+        end
+
+        def call(env)
+          # Destroy the server, remove the tracking ID
+          env[:ui].info(I18n.t("vagrant_ovirt3.destroy_vm"))
+
+          machine = env[:ovirt_compute].servers.get(env[:machine].id.to_s)
+          machine.destroy
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ovirt3/action/is_created.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ovirt3/action/message_already_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      class MessageAlreadyCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_ovirt3.already_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ovirt3/action/message_not_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      class MessageNotCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_ovirt3.not_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ovirt3/action/read_ssh_info.rb

@@ -0,0 +1,56 @@
+require "log4r"
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReadSSHInfo
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_ovirt3::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(
+            env[:ovirt_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(ovirt, machine)
+          return nil if machine.id.nil?
+
+          # Get config.
+          config = machine.provider_config
+
+          # Find the machine
+          server = ovirt.servers.get(machine.id.to_s)
+
+          if server.nil?
+            # The machine can't be found
+            @logger.info("Machine couldn't be found, assuming it got destroyed.")
+            machine.id = nil
+            return nil
+          end
+
+          ip_address = server.ips.first
+          if ip_address == nil or ip_address == ''
+            raise Errors::NoIpAddressError
+          end
+
+          # Return the info
+          # TODO: Some info should be configurable in Vagrantfile
+          return {
+            :host             => ip_address,
+            :port             => machine.config.ssh.guest_port,
+            :username         => machine.config.ssh.username,
+            :private_key_path => machine.config.ssh.private_key_path,
+            :forward_agent    => machine.config.ssh.forward_agent,
+            :forward_x11      => machine.config.ssh.forward_x11,
+          }
+        end 
+      end
+    end
+  end
+end