vagrant-ovirt4 1.0.0

data/lib/vagrant-ovirt4/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_ovirt4::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env)
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(env)
+          vms_service, machine = env[:vms_service], env[:machine]
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          server = vms_service.vm_service(machine.id)
+          begin
+            if server.get.nil?
+              machine.id = nil
+              return :not_created
+            end
+          rescue Exception => e
+            machine.id = nil
+            return :not_created
+            raise e
+          end
+
+          nics_service = server.nics_service
+          nics = nics_service.list
+          ip_addr = nics.collect { |nic_attachment| env[:connection].follow_link(nic_attachment).reported_devices.collect { |dev| dev.ips.collect { |ip| ip.address if ip.version == 'v4' } } }.flatten.reject { |ip| ip.nil? }.first rescue nil
+
+          # Return the info
+          # TODO: Some info should be configurable in Vagrantfile
+          return {
+            :host             => ip_addr,
+            :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

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

@@ -0,0 +1,47 @@
+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_ovirt4::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env)
+          @app.call(env)
+        end
+
+        def read_state(env)
+          vms_service = env[:vms_service]
+          machine = env[:machine]
+          return :not_created if machine.id.nil?
+
+          server = vms_service.vm_service(machine.id)
+          begin
+            if server.get.nil?
+              machine.id = nil
+              return :not_created
+            end
+          rescue 
+            machine.id = nil
+            return :not_created
+          end
+          nics_service = server.nics_service
+          nics = nics_service.list
+          ip_addr = nics.collect { |nic_attachment| env[:connection].follow_link(nic_attachment).reported_devices.collect { |dev| dev.ips.collect { |ip| ip.address if ip.version == 'v4' } } }.flatten.reject { |ip| ip.nil? }.first rescue nil
+          unless ip_addr.nil?
+            env[:ip_address] = ip_addr
+            @logger.debug("Got output #{env[:ip_address]}")
+          end
+
+          return server.get.status.to_sym
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+
+      class SetNameOfDomain
+        @@MAX_NAME_LENGTH = 64
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          dir_name = env[:root_path].basename.to_s.dup.gsub(/[^-a-z0-9_]/i, "")
+          timestamp = "_#{Time.now.to_f}"
+          max_dir_name_length = dir_name.length-[(dir_name + timestamp).length-(@@MAX_NAME_LENGTH-1), 0].max
+          env[:domain_name] = dir_name[0..max_dir_name_length] << timestamp
+
+          @app.call(env)
+        end
+      end
+
+    end
+  end
+end
+

data/lib/vagrant-ovirt4/action/snapshot_delete.rb

@@ -0,0 +1,37 @@
+require 'log4r'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      class SnapshotDelete
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt4::action::snapshot_delete")
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_ovirt4.snapshot_delete"))
+          
+          snapshots_service = env[:vms_service].vm_service(env[:machine].id).snapshots_service
+          require 'pry'
+          
+          snapshot = snapshots_service.snapshot_service(env[:snapshot_name])
+
+          begin
+            raise RemoveActiveSnapshotError, :id => env[:snapshot_name] if snapshot.get.snapshot_type == 'active' 
+            snapshot.remove
+          rescue OvirtSDK4::Error => e
+            fault_detail = /Fault detail is \"\[(.*)\]\".*/.match(e.message)
+            error_message = e.message
+            error_message = fault_detail[1] unless fault_detail.nil?
+            raise Errors::RemoveSnapshotError,
+              :id => env[:snapshot_name],
+              :error_message => error_message
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ovirt4/action/snapshot_list.rb

@@ -0,0 +1,58 @@
+require 'log4r'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      class SnapshotList
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt4::action::snapshot_list")
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_ovirt4.snapshot_list"))
+
+          system_service = env[:connection].system_service
+
+          # Find all the virtual machines and store the id and name in a
+          # hash, so that looking them up later will be faster:
+          vms_map = Hash[env[:vms_service].list.map { |vm| [vm.id, vm.name] }]
+          
+          # Same for storage domains:
+          sds_service = system_service.storage_domains_service
+          sds_map = Hash[sds_service.list.map { |sd| [sd.id, sd.name] }]
+          
+          # For each virtual machine find its snapshots, then for each snapshot
+          # find its disks:
+          xs = [['id', 'description', 'date']]
+          vms_map.each do |vm_id, vm_name|
+            vm_service = env[:vms_service].vm_service(vm_id)
+            snaps_service = vm_service.snapshots_service
+            snaps_map = Hash[snaps_service.list.map { |snap| [snap.id, { description: snap.description, date: snap.date }] }]
+            snaps_map.each do |snap_id, metadata|
+              snap_description = metadata[:description]
+              snap_date = metadata[:date]
+              snap_service = snaps_service.snapshot_service(snap_id)
+              disks_service = snap_service.disks_service
+              disks_service.list.each do |disk|
+                next unless disk.storage_domains.any?
+                sd_id = disk.storage_domains.first.id
+                sd_name = sds_map[sd_id]
+                xs.push([snap_id, snap_description, snap_date.to_s])
+              end
+            end
+          end
+          widths = xs.transpose.map { |column_arr| column_arr.map(&:size).max }
+          env[:machine_snapshot_list] = 
+              xs.map { |row_arr| 
+                row_arr.map.with_index { |str, idx| 
+                        "%#{widths[idx]}s" % str 
+                } .join(" " * 5)
+              }
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ovirt4/action/snapshot_save.rb

@@ -0,0 +1,28 @@
+require 'log4r'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      class SnapshotSave
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt4::action::snapshot_save")
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_ovirt4.snapshot_save"))
+          
+          snapshots_service = env[:vms_service].vm_service(env[:machine].id).snapshots_service
+          
+          snapshots_service.add(
+            OvirtSDK4::Snapshot.new(
+              description: env[:snapshot_name]
+            )
+          )
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+require 'log4r'
+require 'vagrant/util/scoped_hash_override'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+
+      # Just start the VM.
+      class StartVM
+        include Vagrant::Util::ScopedHashOverride
+
+        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_ovirt4.starting_vm"))
+
+          machine = env[:vms_service].vm_service(env[:machine].id)
+          if machine.get.status == nil
+            raise Errors::NoVMError,
+              :vm_name => env[:machine].id.to_s
+          end
+
+          iface_options = nil
+          env[:machine].config.vm.networks.each do |config|
+            type, options = config
+            next unless [:private_network].include? type
+
+            iface_options = scoped_hash_override(options, :ovirt)
+          end
+
+          my_script = ""
+          #runcmd:
+          # - [ service, network, restart]
+          #"
+
+          hostname = env[:machine].config.vm.hostname
+          hostname = 'vagrant' if hostname.nil?
+
+          nic_configuration = nil
+          if iface_options[:ip] then
+            nic_configuration = {
+              name: 'eth0',
+              on_boot: true,
+              boot_protocol: OvirtSDK4::BootProtocol::STATIC,
+              ip: {
+                version: OvirtSDK4::IpVersion::V4,
+                address: iface_options[:ip],
+                gateway: iface_options[:gateway],
+              }
+            }
+          else
+            nic_configuration = {
+              name: 'eth0',
+              on_boot: true,
+              boot_protocol: OvirtSDK4::BootProtocol::DYNAMIC,
+            }
+          end
+
+          vm_configuration = {
+            initialization: {
+              host_name: hostname,
+              nic_configurations: [nic_configuration],
+              custom_script: my_script,
+            }
+          }
+          
+          machine.start(
+            use_cloud_init: true,
+            vm: vm_configuration
+          )
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ovirt4/action/suspend_vm.rb

@@ -0,0 +1,24 @@
+require 'log4r'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      class SuspendVM
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt4::action::suspend_vm")
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_ovirt4.suspend_vm"))
+
+          machine = env[:vms_service].vm_service(env[:machine].id)
+          machine.suspend
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,69 @@
+require "log4r"
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      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|
+            next if data[:disabled]
+            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_ovirt4.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-ovirt4/action/wait_til_suspended.rb

@@ -0,0 +1,44 @@
+require 'log4r'
+require 'vagrant-ovirt4/util/timer'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+      class WaitTilSuspended
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt4::action::wait_til_suspended")
+          @app = app
+        end
+
+        def call(env)
+          vm_service = env[:vms_service].vm_service(env[:machine].id)
+
+          env[:ui].info(I18n.t("vagrant_ovirt4.wait_til_suspended"))
+          for i in 1..300
+            ready = true
+            if vm_service.get == nil
+              raise NoVMError, :vm_name => ''
+            end
+
+            if vm_service.get.status.to_sym != :suspended
+              ready = false
+            end
+            break if ready
+            sleep 2
+          end
+
+          if not ready
+            raise Errors::WaitForShutdownVmTimeout
+          end
+
+          
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-ovirt4/action/wait_till_down.rb

@@ -0,0 +1,47 @@
+require 'log4r'
+require 'vagrant-ovirt4/util/timer'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module OVirtProvider
+    module Action
+
+      # Wait till VM is stopped
+      class WaitTillDown
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_ovirt4::action::wait_till_down")
+          @app = app
+        end
+
+        def call(env)
+          vm_service = env[:vms_service].vm_service(env[:machine].id)
+
+          env[:ui].info(I18n.t("vagrant_ovirt4.wait_till_down"))
+          for i in 1..300
+            ready = true
+            if vm_service.get == nil
+              raise NoVMError, :vm_name => ''
+            end
+
+            if vm_service.get.status.to_sym != :down
+              ready = false
+            end
+            break if ready
+            sleep 2
+          end
+
+          if not ready
+            raise Errors::WaitForShutdownVmTimeout
+          end
+
+          
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,83 @@
+require 'log4r'
+require 'vagrant-ovirt4/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_ovirt4::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[:metrics]["instance_ip_time"] = Util::Timer.time do
+            env[:ui].info(I18n.t("vagrant_ovirt4.waiting_for_ip"))
+            for i in 1..300
+              # If we're interrupted don't worry about waiting
+              next if env[:interrupted]
+
+              # Get VM.
+              server = env[:vms_service].vm_service(env[:machine].id)
+              if server == nil
+                raise NoVMError, :vm_name => ''
+              end
+
+              nics_service = server.nics_service
+              nics = nics_service.list
+              ip_addr = nics.collect { |nic_attachment| env[:connection].follow_link(nic_attachment).reported_devices.collect { |dev| dev.ips.collect { |ip| ip.address if ip.version == 'v4' } } }.flatten.reject { |ip| ip.nil? }.first rescue nil
+              unless ip_addr.nil?
+                env[:ip_address] = ip_addr
+                break
+                @logger.debug("Got output #{env[:ip_address]}")
+              end
+              sleep 5
+            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"]}")
+          
+         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_ovirt4.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
+