fog 1.31.0 → 1.37.0

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

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

@@ -1,21 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Real
-        def list_customfields()
-          @connection.serviceContent.customFieldsManager.field.map do |customfield|
-            {
-              :key   => customfield.key.to_i,
-              :name  => customfield.name,
-              :type  => customfield.type
-            }
-          end
-        end
-      end
-      class Mock
-        def list_vm_customfields()
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Real
-        def list_datacenters filters = {}
-          raw_datacenters.map do |dc|
-            {
-              :id => managed_obj_id(dc),
-              :name => dc.name,
-              :path => raw_getpathmo(dc),
-              :status => dc.overallStatus
-            }
-          end
-        end
-
-        protected
-
-        def raw_getpathmo mo
-          if mo.parent == nil or mo.parent.name == @connection.rootFolder.name then
-            [ mo.name ]
-          else
-            [ raw_getpathmo(mo.parent), mo.name ].flatten
-          end
-        end
-
-        def raw_datacenters folder=nil
-          folder ||= @connection.rootFolder
-          @raw_datacenters ||= get_raw_datacenters_from_folder folder
-        end
-
-        def get_raw_datacenters_from_folder folder=nil
-          folder.childEntity.map do | childE |
-            if childE.is_a? RbVmomi::VIM::Datacenter
-               childE
-            elsif childE.is_a? RbVmomi::VIM::Folder
-               get_raw_datacenters_from_folder childE
-            end
-          end.flatten
-        end
-
-        def find_datacenters name=nil
-          name ? [find_raw_datacenter(name)] : raw_datacenters
-        end
-      end
-
-      class Mock
-        def list_datacenters filters = {}
-          [ {:name => "Solutions", :status => "grey"}, {:name => "Solutions2", :status => "green" }]
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Real
-        def list_datastores(filters = { })
-          datacenter_name = filters[:datacenter]
-          # default to show all datastores
-          only_active = filters[:accessible] || false
-          raw_datastores(datacenter_name).map do |datastore|
-            next if only_active and !datastore.summary.accessible
-            datastore_attributes(datastore, datacenter_name)
-          end.compact
-        end
-
-        def raw_datastores(datacenter_name)
-          find_raw_datacenter(datacenter_name).datastore
-        end
-        protected
-
-        def datastore_attributes datastore, datacenter
-          {
-            :id          => managed_obj_id(datastore),
-            :name        => datastore.name,
-            :accessible  => datastore.summary.accessible,
-            :type        => datastore.summary.type,
-            :freespace   => datastore.summary.freeSpace,
-            :capacity    => datastore.summary.capacity,
-            :uncommitted => datastore.summary.uncommitted,
-            :datacenter  => datacenter,
-          }
-        end
-      end
-      class Mock
-        def list_datastores(datacenter_name)
-          []
-        end
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Real
-        # Grabs all sub folders within a given path folder.
-        #
-        # ==== Parameters
-        # * filters<~Hash>:
-        #   * :datacenter<~String> - *REQUIRED* Your datacenter where you're
-        #     looking for folders. Example: 'my-datacenter-name' (passed if you
-        #     are using the models/collections)
-        #       eg: vspconn.datacenters.first.vm_folders('mypath')
-        #   * :path<~String> - Your path where you're looking for
-        #     more folders, if return = none you will get an error. If you don't
-        #     define it will look in the main datacenter folder for any folders
-        #     in that datacenter.
-        #
-        # Example Usage Testing Only:
-        #  vspconn = Fog::Compute[:vsphere]
-        #  mydc = vspconn.datacenters.first
-        #  folders = mydc.vm_folders
-        #
-        def list_folders(filters = { })
-          path            = filters[:path] || filters['path'] || ''
-          datacenter_name = filters[:datacenter]
-          get_raw_vmfolders(path, datacenter_name).map do |folder|
-            folder_attributes(folder, datacenter_name)
-          end
-        end
-
-        protected
-
-        def get_raw_vmfolders(path, datacenter_name)
-          folder = get_raw_vmfolder(path, datacenter_name)
-          child_folders(folder).flatten.compact
-        end
-
-        def child_folders folder
-          [folder, folder.childEntity.grep(RbVmomi::VIM::Folder).map(&method(:child_folders)).flatten]
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Real
-        def list_interface_types(filters={})
-          datacenter_name = filters[:datacenter]
-          servertype_name = filters[:servertype]
-          get_raw_server_type(servertype_name, datacenter_name)[:supportedEthernetCard].map do | nictype |
-            next if filters.key?(:id) and filters[:id] != nictype
-            interface_type_attributes(nictype, servertype_name, datacenter_name)
-          end.compact
-        end
-
-        def interface_type_attributes(nic, servertype, datacenter)
-          {
-            :id => nic,
-            :name => nic,
-            :datacenter => datacenter,
-            :servertype => servertype
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Real
-        def list_networks(filters = { })
-          datacenter_name = filters[:datacenter]
-          # default to show all networks
-          only_active = filters[:accessible] || false
-          raw_networks(datacenter_name).map do |network|
-            next if only_active and !network.summary.accessible
-            network_attributes(network, datacenter_name)
-          end.compact
-        end
-
-        def raw_networks(datacenter_name)
-          find_raw_datacenter(datacenter_name).network
-        end
-
-        protected
-
-        def network_attributes network, datacenter
-          {
-            :id         => managed_obj_id(network),
-            :name       => network.name,
-            :accessible => network.summary.accessible,
-            :datacenter => datacenter,
-          }
-        end
-      end
-      class Mock
-        def list_networks(datacenter_name)
-          []
-        end
-      end
-    end
-  end
-end

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

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

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

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

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

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