fog 1.35.0 → 1.36.0

data/lib/fog/vsphere/models/compute/network.rb

@@ -7,6 +7,7 @@ module Fog
         attribute :name
         attribute :datacenter
         attribute :accessible # reachable by at least one hypervisor
+        attribute :virtualswitch
 
         def to_s
           name

data/lib/fog/vsphere/models/compute/process.rb

@@ -0,0 +1,18 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Compute
+    class Vsphere
+      class Process < Fog::Model
+        attribute :cmd_line
+        attribute :end_time
+        attribute :exit_code
+        attribute :name
+        attribute :owner
+        attribute :pid
+        attribute :start_time
+      end
+    end
+  end
+end
+

data/lib/fog/vsphere/models/compute/server.rb

@@ -148,6 +148,11 @@ module Fog
           new_vm
         end
 
+        def take_snapshot(options = {})
+          requires :instance_uuid
+          service.vm_take_snapshot(options.merge('instance_uuid' => instance_uuid))
+        end
+
         def ready?
           power_state == "poweredOn"
         end
@@ -213,6 +218,30 @@ module Fog
           attributes[:volumes] ||= id.nil? ? [] : service.volumes(:server_id => self.id)
         end
 
+        def snapshots(opts = {})
+          service.snapshots(server_id: self.id).all(opts)
+        end
+
+        def find_snapshot(snapshot_ref)
+          snapshots.get(snapshot_ref)
+        end
+
+        def revert_snapshot(snapshot)
+          case snapshot
+          when Snapshot
+            service.revert_to_snapshot(snapshot)
+          when String
+            service.revert_to_snapshot(find_snapshot(snapshot))
+          else
+            fail ArgumentError, "snapshot has to be kind of Snapshot or String class"
+          end
+        end
+
+        def guest_processes(opts = {})
+          fail 'VM tools must be running' unless tools_running?
+          service.list_processes(self.id, opts)
+        end
+
         def customvalues
           attributes[:customvalues] ||= id.nil? ? [] : service.customvalues( :vm => self )
         end

data/lib/fog/vsphere/models/compute/snapshot.rb

@@ -0,0 +1,35 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Compute
+    class Vsphere
+      class Snapshot < Fog::Model
+
+        identity  :ref
+        attribute :server_id
+
+        attribute :name
+        attribute :quiescedi, :default => false
+        attribute :description, :default => ''
+        attribute :create_time
+        attribute :power_state, :default => 'none'
+        attribute :ref
+        attribute :mo_ref
+        attribute :tree_node
+        attribute :snapshot_name_chain
+        attribute :ref_chain
+
+        def child_snapshots(filters = {})
+          service.snapshots(
+            { :server_id => server_id, :parent_snapshot => self }.update(filters)
+          )
+        end
+
+        def get_child(snapshot_ref)
+          return self if ref == snapshot_ref
+          child_snapshots().get(snapshot_ref)
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/models/compute/snapshots.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/vsphere/models/compute/snapshot'
+
+module Fog
+  module Compute
+    class Vsphere
+      class Snapshots < Fog::Collection
+        attribute :server_id, alias: :instance_uuid
+        attribute :parent_snapshot
+        model Fog::Compute::Vsphere::Snapshot
+
+        def all(filters = {})
+          if parent_snapshot
+            load service.list_child_snapshots(parent_snapshot, filters)
+          else
+            requires :server_id
+            load service.list_vm_snapshots(server_id, filters)
+          end
+        end
+
+        def get(snapshot_ref)
+          all.find { |snapshot| snapshot.get_child(snapshot_ref) }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/create_vm.rb

@@ -19,6 +19,7 @@ module Fog
           vm_cfg[:cpuHotAddEnabled] = attributes[:cpuHotAddEnabled] if attributes.key?(:cpuHotAddEnabled)
           vm_cfg[:memoryHotAddEnabled] = attributes[:memoryHotAddEnabled] if attributes.key?(:memoryHotAddEnabled)
           vm_cfg[:firmware] = attributes[:firmware] if attributes.key?(:firmware)
+          vm_cfg[:bootOptions] = boot_options(attributes) if attributes.key?(:boot_order)
           resource_pool = if attributes[:resource_pool]
                             get_raw_resource_pool(attributes[:resource_pool], attributes[:cluster], attributes[:datacenter])
                           else
@@ -54,6 +55,63 @@ module Fog
           devices.flatten
         end
 
+        def boot_options attributes
+          # NOTE: you must be using vsphere_rev 5.0 or greater to set boot_order
+          # e.g. Fog::Compute.new(provider: "vsphere", vsphere_rev: "5.5", etc)
+          RbVmomi::VIM::VirtualMachineBootOptions.new(
+            :bootOrder => boot_order(attributes)
+          )
+        end
+
+        def boot_order attributes
+          # attributes[:boot_order] may be an array like this ['network', 'disk']
+          # stating, that we want to prefer network boots over disk boots
+          boot_order = []
+          attributes[:boot_order].each do |boot_device|
+            case boot_device
+            when 'network'
+              if nics = attributes[:interfaces]
+                # key is based on 4000 + the interface index
+                # we allow booting from all network interfaces, the first interface has the highest priority
+                nics.each do |nic|
+                  boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableEthernetDevice.new(
+                    :deviceKey => 4000 + nics.index(nic),
+                  )
+                end
+              end
+            when 'disk'
+              if disks = attributes[:volumes]
+                disks.each do |disk|
+                  # we allow booting from all harddisks, the first disk has the highest priority
+                  boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableDiskDevice.new(
+                    :deviceKey => disk.key || get_disk_device_key(disks.index(disk)),
+                  )
+                end
+              end
+            when 'cdrom'
+              boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableCdromDevice.new()
+            when 'floppy'
+              boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableFloppyDevice.new()
+            else
+              raise "failed to create boot device because \"#{boot_device}\" is unknown"
+            end
+          end
+          boot_order
+        end
+
+        def get_disk_device_key(index)
+          # disk key is based on 2000 + the SCSI ID + the controller bus * 16
+          # the scsi host adapter appears as SCSI ID 7, so we have to skip that
+          # host adapter key is based on 1000 + bus id
+          # fog assumes that there is only a single scsi controller, see device_change()
+          if (index > 6) then
+            _index = index + 1
+          else
+            _index = index
+          end
+          2000 + _index
+        end
+
         def create_nic_backing nic, attributes
           raw_network = get_raw_network(nic.network, attributes[:datacenter], if nic.virtualswitch then nic.virtualswitch end)
 
@@ -122,18 +180,23 @@ module Fog
         end
 
         def create_disk disk, index = 0, operation = :add, controller_key = 1000
+          if (index > 6) then
+            _index = index + 1
+          else
+            _index = index
+          end
           payload = {
             :operation     => operation,
             :fileOperation => operation == :add ? :create : :destroy,
             :device        => RbVmomi::VIM.VirtualDisk(
-              :key           => disk.key || index,
+              :key           => disk.key || _index,
               :backing       => RbVmomi::VIM.VirtualDiskFlatVer2BackingInfo(
                 :fileName        => "[#{disk.datastore}]",
                 :diskMode        => disk.mode.to_sym,
                 :thinProvisioned => disk.thin
               ),
               :controllerKey => controller_key,
-              :unitNumber    => index,
+              :unitNumber    => _index,
               :capacityInKB  => disk.size
             )
           }

data/lib/fog/vsphere/requests/compute/list_child_snapshots.rb

@@ -0,0 +1,71 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_child_snapshots(snapshot, opts = {})
+          normalized_snapshot = Hash === snapshot ?
+            Snapshot.new(snapshot.update(service: self)) : snapshot
+
+          child_snapshots = normalized_snapshot.tree_node.childSnapshotList.map do |snap|
+            item = child_snapshot_info(snap, normalized_snapshot)
+            [
+              item,
+              opts[:recursive] ? list_child_snapshots(item, opts) : nil
+            ]
+          end
+
+          child_snapshots.flatten.compact
+        end
+
+        protected
+
+          def child_snapshot_info(snap_tree, parent_snap)
+            {
+              name: snap_tree.name,
+              quiesced: snap_tree.quiesced,
+              description: snap_tree.description,
+              create_time: snap_tree.createTime,
+              power_state: snap_tree.state,
+              ref: snap_tree.snapshot._ref,
+              mo_ref: snap_tree.snapshot,
+              tree_node: snap_tree,
+              snapshot_name_chain:
+                "#{parent_snap.snapshot_name_chain}/#{snap_tree.name}",
+              ref_chain:
+                "#{parent_snap.ref_chain}/#{snap_tree.snapshot._ref}"
+            }
+          end
+      end
+      class Mock
+        def list_child_snapshots(snapshot, opts = {})
+          [
+            {
+              name: 'clean',
+              quiesced: false,
+              description: '',
+              create_time: Time.now.utc,
+              power_state: 'poweredOn',
+              ref: 'snapshot-0101',
+              mo_ref: nil,
+              tree_node: nil,
+              snapshot_name_chain: '123/clean',
+              ref_chain: '123/snap-0101'
+            },
+            {
+              name: 'dirty',
+              quiesced: false,
+              description: '',
+              create_time: Time.now.utc,
+              power_state: 'poweredOn',
+              ref: 'snapshot-0102',
+              mo_ref: nil,
+              tree_node: nil,
+              snapshot_name_chain: '123/dirty',
+              ref_chain: '123/snap-0102'
+            }
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/list_networks.rb

@@ -20,10 +20,11 @@ module Fog
 
         def network_attributes network, datacenter
           {
-            :id         => managed_obj_id(network),
-            :name       => network.name,
-            :accessible => network.summary.accessible,
-            :datacenter => datacenter,
+            :id            => managed_obj_id(network),
+            :name          => network.name,
+            :accessible    => network.summary.accessible,
+            :datacenter    => datacenter,
+            :virtualswitch => network.class.name == "DistributedVirtualPortgroup" ? network.config.distributedVirtualSwitch.name : nil
           }
         end
       end

data/lib/fog/vsphere/requests/compute/list_processes.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_processes(vm_id, opts)
+          vm = get_vm_ref(vm_id)
+
+          auth = RbVmomi::VIM::NamePasswordAuthentication(
+            username: opts[:user],
+            password: opts[:password],
+            interactiveSession: false
+          )
+
+          p_manager = @connection.serviceContent.guestOperationsManager.processManager
+          processes = p_manager.ListProcessesInGuest(vm: vm, auth: auth)
+          processes.map do |pi|
+            Process.new(
+              cmd_line: pi.cmdLine,
+              end_time: pi.endTime,
+              exit_code: pi.exitCode,
+              name: pi.name,
+              owner: pi.owner,
+              pid: pi.pid,
+              start_time: pi.startTime
+            )
+          end
+        end
+      end
+
+      class Mock
+        def list_processes(vm_id, opts = {})
+          [
+            Process.new(name: 'winlogon'),
+            Process.new(name: 'init')
+          ]
+        end
+      end
+    end
+  end
+end
+

data/lib/fog/vsphere/requests/compute/list_vm_snapshots.rb

@@ -0,0 +1,66 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_vm_snapshots(vm_id, opts = {})
+          root_snapshots = get_vm_ref(vm_id).snapshot.rootSnapshotList.map do |snap|
+            item = snapshot_info(snap, vm_id)
+            [
+              item,
+              opts[:recursive] ? list_child_snapshots(item, opts) : nil
+            ]
+          end
+
+          root_snapshots.flatten.compact
+        end
+
+        protected
+
+          def snapshot_info(snap_tree, vm_id)
+            {
+              name: snap_tree.name,
+              quiesced: snap_tree.quiesced,
+              description: snap_tree.description,
+              create_time: snap_tree.createTime,
+              power_state: snap_tree.state,
+              ref: snap_tree.snapshot._ref,
+              mo_ref: snap_tree.snapshot,
+              tree_node: snap_tree,
+              ref_chain: "#{vm_id}/#{snap_tree.snapshot._ref}",
+              snapshot_name_chain: "#{vm_id}/#{snap_tree.name}"
+            }
+          end
+      end
+      class Mock
+        def list_vm_snapshots(vm_id, opts = {})
+          [
+            {
+              name: 'clean',
+              quiesced: false,
+              description: '',
+              create_time: Time.now.utc,
+              power_state: 'poweredOn',
+              ref: 'snapshot-0101',
+              mo_ref: nil,
+              tree_node: nil,
+              snapshot_name_chain: '123/clean',
+              ref_chain: "#{vm_id}/snapshot-0101"
+            },
+            {
+              name: 'dirty',
+              quiesced: false,
+              description: '',
+              create_time: Time.now.utc,
+              power_state: 'poweredOn',
+              ref: 'snapshot-0102',
+              mo_ref: nil,
+              tree_node: nil,
+              snapshot_name_chain: '123/dirty',
+              ref_chain: "#{vm_id}/snapshot-0102"
+            }
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/revert_to_snapshot.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def revert_to_snapshot(snapshot)
+          unless Snapshot === snapshot
+            fail ArgumentError, 'snapshot is a required parameter'
+          end
+
+          task = snapshot.mo_ref.RevertToSnapshot_Task
+          task.wait_for_completion
+
+          {
+            'state' => task.info.state
+          }
+        end
+      end
+
+      class Mock
+        def revert_to_snapshot(snapshot)
+          fail ArgumentError, 'snapshot is a required parameter' if snapshot.nil?
+
+          {
+            'state' => 'success'
+          }
+        end
+      end
+    end
+  end
+end