fog-vsphere 0.1.0

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

@@ -0,0 +1,40 @@
+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_resource_pools.rb

@@ -0,0 +1,38 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_resource_pools(filters = { })
+          datacenter_name = filters[:datacenter]
+          cluster_name    = filters[:cluster]
+          cluster         = get_raw_cluster(cluster_name, datacenter_name)
+          list_raw_resource_pools(cluster).map do |resource_pool|
+            resource_pool_attributes(resource_pool, cluster_name, datacenter_name)
+          end
+        end
+
+        protected
+
+        # root ResourcePool + Children if they exists
+        def list_raw_resource_pools(cluster)
+          [cluster.resourcePool, cluster.resourcePool.resourcePool].flatten
+        end
+
+        def resource_pool_attributes resource_pool, cluster, datacenter
+          {
+            :id                   => managed_obj_id(resource_pool),
+            :name                 => resource_pool.name,
+            :configured_memory_mb => resource_pool.summary.configuredMemoryMB,
+            :overall_status       => resource_pool.overallStatus,
+            :cluster              => cluster,
+            :datacenter           => datacenter
+          }
+        end
+      end
+      class Mock
+        def list_resource_pools(filters = { })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_server_types(filters={})
+          datacenter_name = filters[:datacenter]
+          servertypes=raw_server_types(datacenter_name)
+          if servertypes
+            servertypes.map do | servertype |
+               server_type_attributes(servertype, datacenter_name)
+            end.compact
+          else
+            nil
+          end
+          #select{ | guestdesc | guestdesc.select{ | k, v | filter.has_key?(k) and filter[k] == v }==filter }
+        end
+
+        def raw_server_types(datacenter_name, filter={})
+          datacenter=find_raw_datacenter(datacenter_name)
+          environmentBrowser=datacenter.hostFolder.childEntity.grep(RbVmomi::VIM::ComputeResource).first.environmentBrowser
+          if environmentBrowser
+            environmentBrowser.QueryConfigOption[:guestOSDescriptor]
+          end
+        end
+
+        protected
+
+        def server_type_attributes(servertype, datacenter)
+          {
+            :id         => servertype.id,
+            :name       => servertype.id,
+            :family     => servertype.family,
+            :fullname   => servertype.fullName,
+            :datacenter => datacenter,
+          }
+        end
+      end
+      class Mock
+        def list_server_types(datacenter_name)
+          [{:id=>"rhel6Guest",
+            :name=>"rhel6Guest",
+            :family=>"linuxGuest",
+            :fullname=>"Red Hat Enterprise Linux 6 (32-Bit)",
+            :datacenter=>"Solutions"},
+           {:id=>"rhel5_64Guest",
+            :name=>"rhel5_64Guest",
+            :family=>"linuxGuest",
+            :fullname=>"Red Hat Enterprise Linux 5 (64-Bit)",
+            :datacenter=>"Solutions"}]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_templates(options = { })
+          options[:folder] ||= options['folder']
+          if options[:folder] then
+            list_all_templates_in_folder(options[:folder], options[:datacenter])
+          else
+            list_all_templates(options)
+          end
+        end
+
+        private
+
+        def list_all_templates_in_folder(path, datacenter_name)
+          folder = get_raw_vmfolder(path, datacenter_name)
+
+          vms = folder.children.grep(RbVmomi::VIM::VirtualMachine)
+          # remove all virtual machines that are not template
+          vms.delete_if { |v| v.config.nil? or not v.config.template }
+
+          vms.map(&method(:convert_vm_mob_ref_to_attr_hash))
+        end
+
+        def list_all_templates(options = {})
+          datacenters = find_datacenters(options[:datacenter])
+
+          vms = datacenters.map do |dc|
+            @connection.serviceContent.viewManager.CreateContainerView({
+              :container  => dc.vmFolder,
+              :type       =>  ["VirtualMachine"],
+              :recursive  => true
+            }).view
+          end.flatten
+          # remove all virtual machines that are not templates
+          vms.delete_if { |v| v.config.nil? or not v.config.template }
+
+          vms.map(&method(:convert_vm_mob_ref_to_attr_hash))
+        end
+      end
+      class Mock
+        def list_templates(filters = { })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_virtual_machines(options = { })
+          # Listing all VM's can be quite slow and expensive.  Try and optimize
+          # based on the available options we have.  These conditions are in
+          # ascending order of time to complete for large deployments.
+
+          options[:folder] ||= options['folder']
+          if options['instance_uuid'] then
+            [get_virtual_machine(options['instance_uuid'])]
+          elsif options[:folder] && options[:datacenter] then
+            list_all_virtual_machines_in_folder(options[:folder], options[:datacenter])
+          else
+            list_all_virtual_machines(options)
+          end
+        end
+
+
+        private
+
+        def list_all_virtual_machines_in_folder(path, datacenter_name)
+          folder = get_raw_vmfolder(path, datacenter_name)
+
+          vms = folder.children.grep(RbVmomi::VIM::VirtualMachine)
+          # remove all template based virtual machines
+          vms.delete_if { |v| v.config.nil? or v.config.template }
+          vms.map(&method(:convert_vm_mob_ref_to_attr_hash))
+        end
+
+        def list_all_virtual_machines(options = { })
+          raw_vms = raw_list_all_virtual_machines(options[:datacenter])
+          vms = convert_vm_view_to_attr_hash(raw_vms)
+
+          # remove all template based virtual machines
+          vms.delete_if { |v| v['template'] }
+          vms
+        end
+
+        def raw_list_all_virtual_machines(datacenter_name = nil)
+          ## Moved this to its own function since trying to get a list of all virtual machines
+          ## to parse for a find function took way too long. The raw list returned will make it
+          ## much faster to interact for some functions.
+          datacenters = find_datacenters(datacenter_name)
+          datacenters.map do |dc|
+            @connection.serviceContent.viewManager.CreateContainerView({
+                                                                           :container  => dc.vmFolder,
+                                                                           :type       =>  ["VirtualMachine"],
+                                                                           :recursive  => true
+                                                                       }).view
+          end.flatten
+        end
+        def get_folder_path(folder, root = nil)
+          if (not folder.methods.include?('parent')) or (folder == root)
+            return
+          end
+          "#{get_folder_path(folder.parent)}/#{folder.name}"
+        end
+      end
+
+      class Mock
+        def get_folder_path(folder, root = nil)
+          nil
+        end
+
+        def list_virtual_machines(options = { })
+          if options['instance_uuid'].nil? and options['mo_ref'].nil?
+            self.data[:servers].values
+          elsif !options['instance_uuid'].nil?
+            server = self.data[:servers][options['instance_uuid']]
+            server.nil? ? [] : [server]
+          else
+            self.data[:servers].values.select{|vm| vm['mo_ref'] == options['mo_ref']}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_vm_customvalues(vm_id)
+          get_vm_ref(vm_id).summary.customValue.map do |customvalue|
+            {
+              :key    => customvalue.key.to_i,
+              :value  => customvalue.value,
+            }
+          end
+        end
+      end
+      class Mock
+        def list_vm_customfields(vm_id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+  # => VirtualE1000(
+  #addressType: "assigned",
+  #backing: VirtualEthernetCardNetworkBackingInfo(
+  #  deviceName: "VM Network",
+  #  dynamicProperty: [],
+  #  network: Network("network-163"),
+  #  useAutoDetect: false
+  #),
+  #connectable: VirtualDeviceConnectInfo(
+  #  allowGuestControl: true,
+  #  connected: true,
+  #  dynamicProperty: [],
+  #  startConnected: true,
+  #  status: "ok"
+  #),
+  #controllerKey: 100,
+  #deviceInfo: Description(
+  #  dynamicProperty: [],
+  #  label: "Network adapter 1",
+  #  summary: "VM Network"
+  #),
+  #dynamicProperty: [],
+  #key: 4000,
+  #macAddress: "00:50:56:a9:00:28",
+  #unitNumber: 7,
+  #
+        def list_vm_interfaces(vm_id, datacenter = nil)
+          get_vm_ref(vm_id, datacenter).config.hardware.device.grep(RbVmomi::VIM::VirtualEthernetCard).map do |nic|
+            {
+              :name    => nic.deviceInfo.label,
+              :mac     => nic.macAddress,
+              :network => nic.backing.respond_to?("network") ? nic.backing.network.name : nic.backing.port.portgroupKey,
+              :status  => nic.connectable.status,
+              :summary => nic.deviceInfo.summary,
+              :type    => nic.class,
+              :key     => nic.key,
+            }
+          end
+        end
+
+        def get_vm_interface(vm_id, options={})
+          raise ArgumentError, "instance id is a required parameter" unless vm_id
+          if options.is_a? Fog::Compute::Vsphere::Interface
+            options
+          else
+            raise ArgumentError, "Either key or name is a required parameter. options: #{options}" unless options.key? :key or options.key? :mac or options.key? :name
+            list_vm_interfaces(vm_id).find do | nic |
+              (options.key? :key and nic[:key]==options[:key].to_i) or (options.key? :mac and nic[:mac]==options[:mac]) or (options.key? :name and nic[:name]==options[:name])
+            end
+          end
+        end
+      end
+      class Mock
+        def list_vm_interfaces(vm_id)
+        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/list_vm_volumes.rb

@@ -0,0 +1,52 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+ # [VirtualDisk(
+ #  backing: VirtualDiskFlatVer2BackingInfo(
+ #    contentId: "a172d19487e878e17d6b16ff2505d7eb",
+ #    datastore: Datastore("datastore-162"),
+ #    diskMode: "persistent",
+ #    dynamicProperty: [],
+ #    fileName: "[Storage1] rhel6-mfojtik/rhel6-mfojtik.vmdk",
+ #    split: false,
+ #    thinProvisioned: true,
+ #    uuid: "6000C29c-a47d-4cd9-5249-c371de775f06",
+ #    writeThrough: false
+ #  ),
+ #  capacityInKB: 8388608,
+ #  controllerKey: 1000,
+ #  deviceInfo: Description(
+ #    dynamicProperty: [],
+ #    label: "Hard disk 1",
+ #    summary: "8,388,608 KB"
+ #  ),
+ #  dynamicProperty: [],
+ #  key: 2001,
+ #  shares: SharesInfo( dynamicProperty: [], level: "normal", shares: 1000 ),
+ #  unitNumber: 1
+ #)]
+
+        def list_vm_volumes(vm_id)
+          get_vm_ref(vm_id).disks.map do |vol|
+            {
+              :id => vol.backing.uuid,
+              :thin => (vol.backing.thinProvisioned rescue(nil)),
+              :mode => vol.backing.diskMode,
+              :filename => vol.backing.fileName,
+              :datastore => (vol.backing.datastore.name rescue(nil)),
+              :size => vol.capacityInKB,
+              :name => vol.deviceInfo.label,
+              :key => vol.key,
+              :unit_number => vol.unitNumber
+            }
+          end
+        end
+      end
+      class Mock
+        def list_vm_volumes(vm_id)
+        end
+      end
+    end
+  end
+end