fog-vsphere 0.1.0

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

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

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

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

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

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

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

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

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

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