fog-vsphere 0.1.0

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

@@ -0,0 +1,18 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def current_time
+          current_time = @connection.serviceInstance.CurrentTime
+          { 'current_time' => current_time }
+        end
+      end
+
+      class Mock
+        def current_time
+          { 'current_time' => Time.now.utc }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_cluster(name, datacenter_name)
+          cluster = get_raw_cluster(name, datacenter_name)
+          raise(Fog::Compute::Vsphere::NotFound) unless cluster
+          cluster_attributes(cluster, datacenter_name)
+        end
+
+        protected
+
+        def get_raw_cluster(name, datacenter_name)
+          dc = find_raw_datacenter(datacenter_name)
+          dc.find_compute_resource(name)
+        end
+      end
+
+      class Mock
+        def get_cluster(id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_compute_resource(name, datacenter_name)
+          compute_resource = get_raw_compute_resource(name, datacenter_name)
+          raise(Fog::Compute::Vsphere::NotFound) unless compute_resource
+          compute_resource_attributes(compute_resource, datacenter_name)
+        end
+
+        protected
+
+        def get_raw_compute_resource(name, datacenter_name)
+          find_raw_datacenter(datacenter_name).find_compute_resource(name)
+        end
+      end
+
+      class Mock
+        def get_compute_resource(name, datacenter_name)
+          {
+            :id=>"domain-s7", 
+            :name=>"fake-host", 
+            :totalCpu=>33504, 
+            :totalMemory=>154604142592, 
+            :numCpuCores=>12, 
+            :numCpuThreads=>24, 
+            :effectiveCpu=>32247, 
+            :effectiveMemory=>135733, 
+            :numHosts=>1, 
+            :numEffectiveHosts=>1, 
+            :overallStatus=>"gray", 
+            :overallCpuUsage=>15682, 
+            :overallMemoryUsage=>132755, 
+            :effective=>true, 
+            :isSingleHost=>true
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_datacenter name
+          dc = find_raw_datacenter(name)
+          raise(Fog::Compute::Vsphere::NotFound) unless dc
+          {:name => dc.name, :status => dc.overallStatus, :path => raw_getpathmo(dc) }
+        end
+
+        protected
+
+        def find_raw_datacenter name
+          raw_datacenters.find {|d| d.name == name} || get_raw_datacenter(name)
+        end
+
+        def get_raw_datacenter name
+          @connection.serviceInstance.find_datacenter(name)
+        end
+      end
+
+      class Mock
+        def get_datacenter name
+          dc = self.data[:datacenters][name]
+          raise(Fog::Compute::Vsphere::NotFound) unless dc
+          dc
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_datastore(name, datacenter_name)
+          datastore = get_raw_datastore(name, datacenter_name)
+          raise(Fog::Compute::Vsphere::NotFound) unless datastore
+          datastore_attributes(datastore, datacenter_name)
+        end
+
+        protected
+
+        def get_raw_datastore(name, datacenter_name)
+          dc = find_raw_datacenter(datacenter_name)
+
+          @connection.serviceContent.viewManager.CreateContainerView({
+            :container  => dc.datastoreFolder,
+            :type       =>  ["Datastore"],
+            :recursive  => true
+          }).view.select{|ds| ds.name == name}.first
+        end
+      end
+
+      class Mock
+        def get_datastore(name, datacenter_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_folder(path, datacenter_name, type = nil)
+          type ||= 'vm'
+
+          # Cycle through all types of folders.
+          case type
+            when 'vm', :vm
+              # if you're a vm then grab the VM.
+              folder = get_raw_vmfolder(path, datacenter_name)
+              raise(Fog::Compute::Vsphere::NotFound) unless folder
+              folder_attributes(folder, datacenter_name)
+            when 'network', :network
+              raise "not implemented"
+            when 'datastore', :datastore
+              raise "not implemented"
+            else
+              raise ArgumentError, "#{type} is unknown"
+          end
+        end
+
+        protected
+
+        def get_raw_vmfolder(path, datacenter_name)
+          # The required path syntax - 'topfolder/subfolder
+
+          # Clean up path to be relative since we're providing datacenter name
+          dc             = find_raw_datacenter(datacenter_name)
+          dc_root_folder = dc.vmFolder
+          # Filter the root path for this datacenter not to be used."
+          dc_root_folder_path=dc_root_folder.path.map { | id, name | name }.join("/")
+          paths          = path.sub(/^\/?#{Regexp.quote(dc_root_folder_path)}\/?/, '').split('/')
+
+          return dc_root_folder if paths.empty?
+          # Walk the tree resetting the folder pointer as we go
+          paths.reduce(dc_root_folder) do |last_returned_folder, sub_folder|
+            # JJM VIM::Folder#find appears to be quite efficient as it uses the
+            # searchIndex It certainly appears to be faster than
+            # VIM::Folder#inventory since that returns _all_ managed objects of
+            # a certain type _and_ their properties.
+            sub = last_returned_folder.find(sub_folder, RbVmomi::VIM::Folder)
+            raise ArgumentError, "Could not descend into #{sub_folder}.  Please check your path. #{path}" unless sub
+            sub
+          end
+        end
+
+        def folder_attributes(folder, datacenter_name)
+          {
+            :id         => managed_obj_id(folder),
+            :name       => folder.name,
+            :parent     => folder.parent.name,
+            :datacenter => datacenter_name,
+            :type       => folder_type(folder),
+            :path       => "/"+folder.path.map(&:last).join('/'),
+          }
+        end
+
+        def folder_type(folder)
+          types = folder.childType
+          return :vm        if types.include?('VirtualMachine')
+          return :network   if types.include?('Network')
+          return :datastore if types.include?('Datastore')
+        end
+      end
+
+      class Mock
+        def get_folder(path, filters = { })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_interface_type(id, servertype, datacenter, filter={})
+           interfacetype=list_interface_types(filters={:id => id,
+             :datacenter => datacenter,
+             :servertype => servertype.id }).first
+           raise(Fog::Compute::Vsphere::NotFound) unless interfacetype
+           interfacetype
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_network(name, datacenter_name)
+          network = get_raw_network(name, datacenter_name)
+          raise(Fog::Compute::Vsphere::NotFound) unless network
+          network_attributes(network, datacenter_name)
+        end
+
+        protected
+
+        def get_raw_network(name, datacenter_name, distributedswitch=nil)
+          finder = choose_finder(name, distributedswitch)
+          networks = get_all_raw_networks(datacenter_name)
+          networks.find { |n| finder.call(n) }
+        end
+      end
+
+      module Shared
+
+        protected
+
+        def get_all_raw_networks(datacenter_name)
+          dc = find_raw_datacenter(datacenter_name)
+          @connection.serviceContent.viewManager.
+            CreateContainerView({
+                                 :container => dc.networkFolder,
+                                 :type =>      ["Network"],
+                                 :recursive => true
+                                }).view
+        end
+
+        def choose_finder(name, distributedswitch)
+          case distributedswitch
+          when String
+            # only the one will do
+            Proc.new { |n| (n.name == name) &&
+                (n.class.to_s == "DistributedVirtualPortgroup") &&
+                (n.config.distributedVirtualSwitch.name == distributedswitch)
+            }
+          when :dvs
+            # the first distributed virtual switch will do - selected by network - gives control to vsphere
+            Proc.new { |n| (n.name == name) && (n.class.to_s == "DistributedVirtualPortgroup") }
+          else
+            # the first matching network will do, seems like the non-distributed networks come first
+            Proc.new { |n| (n.name == name) }
+          end
+        end
+
+      end
+
+      class Mock
+        def get_network(id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_resource_pool(name, cluster_name, datacenter_name)
+          resource_pool = get_raw_resource_pool(name, cluster_name, datacenter_name)
+          raise(Fog::Compute::Vsphere::NotFound) unless resource_pool
+          resource_pool_attributes(resource_pool, cluster_name, datacenter_name)
+        end
+
+        protected
+
+        def get_raw_resource_pool(name, cluster_name, datacenter_name)
+          dc      = find_raw_datacenter(datacenter_name)
+          cluster = dc.find_compute_resource(cluster_name)
+          name.nil? ? cluster.resourcePool : cluster.resourcePool.traverse(name)
+        end
+      end
+
+      class Mock
+        def get_resource_pool(name, cluster_name, datacenter_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_server_type(id, datacenter, filter={})
+          server_type=get_raw_server_type(id, datacenter)
+          raise(Fog::Compute::Vsphere::NotFound) unless server_type
+          server_type_attributes(server_type, datacenter)
+        end
+
+        protected
+
+        def get_raw_server_type(id, datacenter, filter={})
+           types=raw_server_types(datacenter)
+           raise(Fog::Compute::Vsphere::NotFound) unless types
+           types=types.select{ | servertype | servertype.id == id }.first
+           raise(Fog::Compute::Vsphere::NotFound) unless types
+           types
+        end
+      end
+      class Mock
+        def get_server_type(id)
+          {:id=>"rhel6Guest",
+            :name=>"rhel6Guest",
+            :family=>"linuxGuest",
+            :fullname=>"Red Hat Enterprise Linux 6 (32-Bit)",
+            :datacenter=>"Solutions"}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_template(id, datacenter_name = nil)
+          convert_vm_mob_ref_to_attr_hash(get_vm_ref(id, datacenter_name))
+        end
+      end
+
+      class Mock
+        def get_template(id, datacenter_name = nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_virtual_machine(id, datacenter_name = nil)
+          # The larger the VM list the longer it will take if not searching based on UUID.
+          convert_vm_mob_ref_to_attr_hash(get_vm_ref(id, datacenter_name))
+        end
+
+        protected
+
+        def get_vm_ref(id, dc = nil)
+          raw_datacenter = find_raw_datacenter(dc) if dc
+          vm = case is_uuid?(id)
+                 # UUID based
+                 when true
+                   params = {:uuid => id, :vmSearch => true, :instanceUuid => true}
+                   params[:datacenter] = raw_datacenter if dc
+                   @connection.searchIndex.FindByUuid(params)
+                 else
+                   # try to find based on VM name
+                   if dc
+                     get_vm_by_name(id, dc)
+                   else
+                     raw_datacenters.map { |d| get_vm_by_name(id, d["name"])}.compact.first
+                   end
+               end
+          vm ? vm : raise(Fog::Compute::Vsphere::NotFound, "#{id} was not found")
+        end
+
+        def get_vm_by_name(name, dc)
+          vms = raw_list_all_virtual_machines(dc)
+
+         if name.include?('/')
+            folder = File.dirname(name)
+            basename = File.basename(name)
+            vms.keep_if { |v| v["name"] == basename && v.parent.pretty_path.include?(folder) }.first
+          else
+            vms.keep_if { |v| v["name"] == name }.first
+          end
+        end
+      end
+
+      class Mock
+        def get_virtual_machine(id, datacenter_name = nil)
+          if is_uuid?(id)
+            vm = list_virtual_machines({ 'instance_uuid' => id, 'datacenter' => datacenter_name }).first
+          else
+            # try to find based on VM name. May need to handle the path of the VM
+            vm = list_virtual_machines({ 'name' => id, 'datacenter' => datacenter_name }).first
+          end
+          vm ? vm : raise(Fog::Compute::Vsphere::NotFound, "#{id} was not found")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_vm_first_scsi_controller(vm_id)
+          Fog::Compute::Vsphere::SCSIController.new(get_vm_first_scsi_controller_raw(vm_id))
+        end
+
+        def get_vm_first_scsi_controller_raw(vm_id)
+          ctrl=get_vm_ref(vm_id).config.hardware.device.grep(RbVmomi::VIM::VirtualSCSIController).select{ | ctrl | ctrl.key == 1000 }.first
+          {
+            :type    => ctrl.class.to_s,
+            :shared_bus  => ctrl.sharedBus.to_s,
+            :unit_number => ctrl.scsiCtlrUnitNumber,
+            :key => ctrl.key,
+          }
+        end
+      end
+      class Mock
+        def get_vm_first_scsi_controller(vm_id)
+        end
+      end
+    end
+  end
+end