fog 1.36.0 → 1.37.0

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

@@ -1,15 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,26 +0,0 @@
-
-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

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

@@ -1,71 +0,0 @@
-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_clusters.rb

@@ -1,72 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Real
-        def list_clusters(filters = { })
-          datacenter_name = filters[:datacenter]
-
-          raw_clusters(datacenter_name).map do |cluster|
-            cluster_attributes(cluster, datacenter_name)
-          end
-        end
-
-        def raw_clusters(datacenter)
-          folder ||= find_raw_datacenter(datacenter).hostFolder
-          @raw_clusters = get_raw_clusters_from_folder(folder)
-        end
-
-        protected
-
-        def get_raw_clusters_from_folder(folder)
-          folder.childEntity.map do |child_entity|
-            if child_entity.is_a? RbVmomi::VIM::ComputeResource
-              child_entity
-            elsif child_entity.is_a? RbVmomi::VIM::Folder
-              get_raw_clusters_from_folder(child_entity)
-            end
-          end.flatten
-        end
-
-        def cluster_attributes cluster, datacenter_name
-          {
-            :id             => managed_obj_id(cluster),
-            :name           => cluster.name,
-            :full_path      => cluster_path(cluster, datacenter_name),
-            :num_host       => cluster.summary.numHosts,
-            :num_cpu_cores  => cluster.summary.numCpuCores,
-            :overall_status => cluster.summary.overallStatus,
-            :datacenter     => datacenter_name || parent_attribute(cluster.path, :datacenter)[1],
-          }
-        end
-
-        def cluster_path(cluster, datacenter_name)
-          datacenter = find_raw_datacenter(datacenter_name)
-          cluster.pretty_path.gsub(/(#{datacenter_name}|#{datacenter.hostFolder.name})\//,'')
-        end
-      end
-
-      class Mock
-        def list_clusters(filters = { })
-          raw_clusters.map do |cluster|
-            cluster
-          end
-        end
-
-        def raw_clusters
-          folder = self.data[:clusters]
-          @raw_clusters = get_raw_clusters_from_folder(folder)
-        end
-
-        def get_raw_clusters_from_folder(folder)
-          folder.map do |child|
-            if child[:klass] == "RbVmomi::VIM::ComputeResource"
-               child
-            elsif child[:klass] == "RbVmomi::VIM::Folder"
-              get_raw_clusters_from_folder(child[:clusters])
-            end
-          end.flatten
-        end
-      end
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Real
-        def list_compute_resources(filters = { })
-          datacenter_name = filters[:datacenter]
-          # default to show all compute_resources
-          only_active = filters[:effective] || false
-          compute_resources = raw_compute_resources datacenter_name
-          
-          compute_resources.map do |compute_resource|
-            summary = compute_resource.summary
-            next if only_active and summary.numEffectiveHosts == 0
-            compute_resource_attributes(compute_resource, datacenter_name)
-          end.compact
-        end
-        
-        def raw_compute_resources(datacenter_name)
-          find_raw_datacenter(datacenter_name).find_compute_resource('').children
-        end
-
-        protected
-
-        def compute_resource_attributes compute_resource, datacenter
-          overall_usage = compute_resource.host.inject({:overallCpuUsage=>0, :overallMemoryUsage=>0}) do |sum, host|
-            {
-              :overallCpuUsage => sum[:overallCpuUsage]+(host.summary.quickStats.overallCpuUsage || 0), 
-              :overallMemoryUsage=> sum[:overallMemoryUsage]+(host.summary.quickStats.overallMemoryUsage || 0)
-            }
-          end
-          {
-            :id                 =>   managed_obj_id(compute_resource),
-            :name               =>   compute_resource.name,
-            :totalCpu           =>   compute_resource.summary.totalCpu, 
-            :totalMemory        =>   compute_resource.summary.totalMemory,
-            :numCpuCores        =>   compute_resource.summary.numCpuCores, 
-            :numCpuThreads      =>   compute_resource.summary.numCpuThreads,
-            :effectiveCpu       =>   compute_resource.summary.effectiveCpu,
-            :effectiveMemory    =>   compute_resource.summary.effectiveMemory,
-            :numHosts           =>   compute_resource.summary.numHosts,
-            :numEffectiveHosts  =>   compute_resource.summary.numEffectiveHosts,
-            :overallStatus      =>   compute_resource.summary.overallStatus,
-            :overallCpuUsage    =>   overall_usage[:overallCpuUsage],
-            :overallMemoryUsage =>   overall_usage[:overallMemoryUsage],
-            :effective          =>   compute_resource.summary.numEffectiveHosts > 0,
-            :isSingleHost       =>   compute_resource.summary.numHosts == 1
-          }
-        end
-
-      end
-      class Mock
-        def list_compute_resources(filters = { })
-          [
-            {
-              :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
-            }, {
-              :id=>"domain-s74", 
-              :name=>"fake-cluster", 
-              :totalCpu=>41484, 
-              :totalMemory=>51525996544, 
-              :numCpuCores=>12, 
-              :numCpuThreads=>24, 
-              :effectiveCpu=>37796, 
-              :effectiveMemory=>45115, 
-              :numHosts=>2, 
-              :numEffectiveHosts=>2, 
-              :overallStatus=>"gray", 
-              :overallCpuUsage=>584, 
-              :overallMemoryUsage=>26422, 
-              :effective=>true, 
-              :isSingleHost=>false
-            }
-          ]
-        end
-      end
-    end
-  end
-end