fog 1.36.0 → 1.37.0

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,38 +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,
-            :virtualswitch => network.class.name == "DistributedVirtualPortgroup" ? network.config.distributedVirtualSwitch.name : nil
-          }
-        end
-      end
-      class Mock
-        def list_networks(datacenter_name)
-          []
-        end
-      end
-    end
-  end
-end

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

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

@@ -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