vagrant-ovirt3 1.0.0

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

@@ -0,0 +1,37 @@
+require "log4r"
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_ovirt3::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:ovirt_compute], env[:machine])
+          @app.call(env)
+        end
+
+        def read_state(ovirt, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          server = ovirt.servers.get(machine.id)
+          if server.nil? || [:"shutting-down", :terminated].include?(server.status.to_sym)
+            # The machine can't be found
+            @logger.info("Machine not found or terminated, assuming it got destroyed.")
+            machine.id = nil
+            return :not_created
+          end
+
+          # Return the state
+          return server.status
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'log4r'
+require 'vagrant/util/scoped_hash_override'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      # Resize the disk if necessary, before VM is running.
+      class ResizeDisk
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt::action::resize_disk")
+          @app = app
+        end
+
+        def call(env)
+          # Is it necessary to resize the disk?
+          config = env[:machine].provider_config
+          if config.disk_size.nil?
+            # Nothing to do
+            @app.call(env)
+            return
+          end
+
+          # 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
+
+          # Extend disk size if necessary
+          begin
+            machine.update_volume(
+              :id      => machine.volumes.first.id,
+              :size    => config.disk_size*1024*1024*1024,
+            )
+          rescue => e
+            raise Errors::UpdateVolumeError,
+              :error_message => e.message
+          end
+
+          # Wait till all volumes are ready.
+          env[:ui].info(I18n.t("vagrant_ovirt3.wait_for_ready_volume"))
+          for i in 0..10
+            ready = true
+            machine = env[:ovirt_compute].servers.get(env[:machine].id.to_s)
+            machine.volumes.each do |volume|
+              if volume.status != 'ok'
+                ready = false
+                break
+              end
+            end
+            break if ready
+            sleep 2
+          end
+
+          if not ready
+            raise Errors::WaitForReadyResizedVolumeTimeout
+          end
+
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,31 @@
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+
+      # Setup name for domain and domain volumes.
+      class SetNameOfDomain
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:domain_name] = env[:root_path].basename.to_s.dup
+          env[:domain_name].gsub!(/[^-a-z0-9_]/i, "")
+          env[:domain_name] << "_#{Time.now.to_i}"
+
+          # Check if the domain name is not already taken
+          domain = OVirtProvider::Util::Collection.find_matching(
+            env[:ovirt_compute].servers.all, env[:domain_name])
+          if domain != nil
+            raise Vagrant::Errors::DomainNameExists,
+              :domain_name => env[:domain_name]
+          end
+
+          @app.call(env)
+        end
+      end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,37 @@
+require 'log4r'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+
+      # Just start the VM.
+      class StartVM
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt::action::start_vm")
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_ovirt3.starting_vm"))
+
+          machine = env[:ovirt_compute].servers.get(env[:machine].id.to_s)
+          if machine == nil
+            raise Errors::NoVMError,
+              :vm_name => env[:machine].id.to_s
+          end
+
+          # Start VM.
+          begin
+            machine.start
+          rescue OVIRT::OvirtException => e
+            raise Errors::StartVMError,
+              :error_message => e.message
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require "log4r"
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # oVirt VM.
+      class SyncFolders
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_ovirt::action::sync_folders")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          ssh_info = env[:machine].ssh_info
+
+          env[:machine].config.vm.synced_folders.each do |id, data|
+            hostpath  = File.expand_path(data[:hostpath], env[:root_path])
+            guestpath = data[:guestpath]
+
+            # Make sure there is a trailing slash on the host path to
+            # avoid creating an additional directory with rsync
+            hostpath = "#{hostpath}/" if hostpath !~ /\/$/
+
+            # on windows rsync.exe requires cygdrive-style paths.
+            # assumes: /c/...
+            # Should be msysgit and cygwin compatible if /etc/fstab in cygwin contains:
+            #    none / cygdrive binary,posix=0,user 0 0
+            if Vagrant::Util::Platform.windows?
+              hostpath = hostpath.gsub(/^(\w):/) { "/#{$1}" }
+            end
+
+            env[:ui].info(I18n.t("vagrant_ovirt3.rsync_folder",
+                                :hostpath => hostpath,
+                                :guestpath => guestpath))
+
+            # Create the guest path
+            env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
+            env[:machine].communicate.sudo("chown #{ssh_info[:username]} '#{guestpath}'")
+
+            # Rsync over to the guest path using the SSH info
+            command = [
+              "rsync", "--verbose", "--archive", "-z", "--owner", "--perms",
+              "--exclude", ".vagrant/",
+              "-e", "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no -i '#{ssh_info[:private_key_path][0]}'",
+              hostpath,
+              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+
+            r = Vagrant::Util::Subprocess.execute(*command)
+            if r.exit_code != 0
+              raise Errors::RsyncError,
+                :guestpath => guestpath,
+                :hostpath => hostpath,
+                :stderr => r.stderr
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,94 @@
+require 'log4r'
+require 'vagrant-ovirt3/util/timer'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+
+      # Wait till VM is started, till it obtains an IP address and is
+      # accessible via ssh.
+      class WaitTillUp
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt3::action::wait_till_up")
+          @app = app
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          # Get config.
+          config = env[:machine].provider_config
+
+          # Wait for VM to obtain an ip address.
+          env[:ip_address] = nil
+          env[:metrics]["instance_ip_time"] = Util::Timer.time do
+            env[:ui].info(I18n.t("vagrant_ovirt3.waiting_for_ip"))
+            #retryable(:on => Fog::Errors::TimeoutError, :tries => 300) do
+            for i in 1..300
+              # If we're interrupted don't worry about waiting
+              next if env[:interrupted]
+
+              # Get VM.
+              server = env[:ovirt_compute].servers.get(env[:machine].id.to_s)
+              if server == nil
+                raise NoVMError, :vm_name => ''
+              end
+
+              env[:ip_address] = server.ips.first
+              @logger.debug("Got output #{env[:ip_address]}")
+              break if env[:ip_address] =~ /[0-9\.]+/
+              sleep 2
+            end
+            #end
+          end
+          terminate(env) if env[:interrupted]
+          @logger.info("Got IP address #{env[:ip_address]}")
+          @logger.info("Time for getting IP: #{env[:metrics]["instance_ip_time"]}")
+          
+          # Machine has ip address assigned, now wait till we are able to
+          # connect via ssh.
+          env[:metrics]["instance_ssh_time"] = Util::Timer.time do
+            env[:ui].info(I18n.t("vagrant_ovirt3.waiting_for_ssh"))
+            retryable(:on => Fog::Errors::TimeoutError, :tries => 60) do
+              # If we're interrupted don't worry about waiting
+              next if env[:interrupted]
+
+              # Wait till we are able to connect via ssh.
+              next if env[:machine].communicate.ready?
+              sleep 2
+            end
+          end
+          terminate(env) if env[:interrupted]
+          @logger.info("Time for SSH ready: #{env[:metrics]["instance_ssh_time"]}")
+
+          # Booted and ready for use.
+          env[:ui].info(I18n.t("vagrant_ovirt3.ready"))
+          
+          @app.call(env)
+        end
+
+        def recover(env)
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          if env[:machine].provider.state.id != :not_created
+            # Undo the import
+            terminate(env)
+          end
+        end
+
+        def terminate(env)
+          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/config.rb

@@ -0,0 +1,58 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module OVirtProvider
+    class Config < Vagrant.plugin('2', :config)
+
+      attr_accessor :url
+      attr_accessor :username
+      attr_accessor :password
+      attr_accessor :datacenter
+      attr_accessor :cluster
+
+      # Domain specific settings used while creating new machine.
+      attr_accessor :memory
+      attr_accessor :cpus
+      attr_accessor :template
+      attr_accessor :console
+      attr_accessor :disk_size
+
+      def initialize
+        @url            = UNSET_VALUE
+        @username       = UNSET_VALUE
+        @password       = UNSET_VALUE
+        @datacenter     = UNSET_VALUE
+        @cluster        = UNSET_VALUE
+
+        # Domain specific settings.
+        @memory     = UNSET_VALUE
+        @cpus       = UNSET_VALUE
+        @template   = UNSET_VALUE
+        @console    = UNSET_VALUE
+        @disk_size  = UNSET_VALUE
+      end
+
+      def finalize!
+        @url = nil if @url == UNSET_VALUE
+        @username = nil if @username == UNSET_VALUE
+        @password = nil if @password == UNSET_VALUE
+        @datacenter = nil if @datacenter == UNSET_VALUE
+        @cluster = nil if @cluster == UNSET_VALUE
+
+        # Domain specific settings.
+        @memory = 512 if @memory == UNSET_VALUE
+        @cpus = 1 if @cpus == UNSET_VALUE
+        @template = 'Blank' if @template == UNSET_VALUE
+        @console = 'spice' if @console == UNSET_VALUE
+        @disk_size = nil if @disk_size == UNSET_VALUE
+      end
+
+      def validate(machine)
+        valid_console_types = ['vnc', 'spice']
+        raise Error::InvalidConsoleType,
+          :console => @console unless valid_console_types.include? @console
+      end
+    end
+  end
+end
+

data/lib/vagrant-ovirt3/errors.rb

@@ -0,0 +1,76 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Errors
+      class VagrantOVirtError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_ovirt3.errors")
+      end
+
+      class RsyncError < VagrantOVirtError
+        error_key(:rsync_error)
+      end
+
+      class FogOVirtConnectionError < VagrantOVirtError
+        error_key(:fog_ovirt_connection_error)
+      end
+
+      class NoDatacenterError < VagrantOVirtError
+        error_key(:no_datacenter_error)
+      end
+
+      class NoClusterError < VagrantOVirtError
+        error_key(:no_cluster_error)
+      end
+
+      class NoTemplateError < VagrantOVirtError
+        error_key(:no_template_error)
+      end
+
+      class NoQuotaError < VagrantOVirtError
+        error_key(:no_template_error)
+      end
+
+      class FogCreateServerError < VagrantOVirtError
+        error_key(:fog_create_server_error)
+      end
+
+      class InterfaceSlotNotAvailable < VagrantOVirtError
+        error_key(:interface_slot_not_available)
+      end
+
+      class AddInterfaceError < VagrantOVirtError
+        error_key(:add_interface_error)
+      end
+
+      class NoVMError < VagrantOVirtError
+        error_key(:no_vm_error)
+      end
+
+      class StartVMError < VagrantOVirtError
+        error_key(:start_vm_error)
+      end
+
+      class WaitForReadyVmTimeout < VagrantOVirtError
+        error_key(:wait_for_ready_vm_timeout)
+      end
+
+      class NoIpAddressError < VagrantOVirtError
+        error_key(:no_ip_address_error)
+      end
+
+      class NoNetworkError < VagrantOVirtError
+        error_key(:no_network_error)
+      end
+
+      class UpdateVolumeError < VagrantOVirtError
+        error_key(:update_volume_error)
+      end
+
+      class WaitForReadyResizedVolumeTimeout < VagrantOVirtError
+        error_key(:wait_for_ready_resized_volume_timeout)
+      end
+    end
+  end
+end
+