fog 1.7.0 → 1.8.0

data/lib/fog/vsphere/models/compute/template.rb

@@ -0,0 +1,13 @@
+module Fog
+  module Compute
+    class Vsphere
+
+      class Template < Fog::Model
+
+        identity :id
+
+      end
+
+    end
+  end
+end

data/lib/fog/vsphere/models/compute/templates.rb

@@ -0,0 +1,23 @@
+require 'fog/core/collection'
+require 'fog/vsphere/models/compute/template'
+
+module Fog
+  module Compute
+    class Vsphere
+
+      class Templates < Fog::Collection
+
+        model Fog::Compute::Vsphere::Template
+
+        def all(filters = {})
+          load connection.list_templates(filters)
+        end
+
+        def get(id)
+          new connection.get_template(id)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/vsphere/models/compute/volume.rb

@@ -0,0 +1,45 @@
+module Fog
+  module Compute
+    class Vsphere
+
+      class Volume < Fog::Model
+        DISK_SIZE_TO_GB = 1048576
+        identity :id
+
+        attribute :datastore
+        attribute :mode
+        attribute :size
+        attribute :thin
+        attribute :name
+        attribute :filename
+        attribute :size_gb
+
+        def initialize(attributes={} )
+          super defaults.merge(attributes)
+        end
+
+        def size_gb
+          attributes[:size_gb] ||= attributes[:size].to_i / DISK_SIZE_TO_GB if attributes[:size]
+        end
+
+        def size_gb= s
+          attributes[:size] = s.to_i * DISK_SIZE_TO_GB if s
+        end
+
+        def to_s
+          name
+        end
+
+         private
+
+        def defaults
+          {
+            :thin=>true,
+            :name=>"Hard disk",
+            :mode=>"persistent"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/models/compute/volumes.rb

@@ -0,0 +1,33 @@
+require 'fog/core/collection'
+require 'fog/vsphere/models/compute/volume'
+
+module Fog
+  module Compute
+    class Vsphere
+
+      class Volumes < Fog::Collection
+
+        model Fog::Compute::Vsphere::Volume
+
+        attr_accessor :vm
+
+        def all(filters = {})
+          requires :vm
+          case vm
+            when Fog::Compute::Vsphere::Server
+              load connection.list_vm_volumes(vm.id)
+            when Fog::Compute::Vsphere::Template
+              load connection.list_template_volumes(vm.id)
+            else
+              raise 'volumes should have vm or template'
+          end
+        end
+
+        def get(id)
+          new connection.get_volume(id)
+        end
+
+     end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def create_vm attributes = { }
+          # build up vm configuration
+
+          vm_cfg        = {
+            :name         => attributes[:name],
+            :guestId      => attributes[:guest_id],
+            :files        => { :vmPathName => vm_path_name(attributes) },
+            :numCPUs      => attributes[:cpus],
+            :memoryMB     => attributes[:memory_mb],
+            :deviceChange => device_change(attributes),
+            :extraConfig  => extra_config(attributes),
+          }
+          resource_pool = if attributes[:resource_pool]
+                            get_raw_resource_pool(attributes[:resource_pool], attributes[:cluster], attributes[:datacenter])
+                          else
+                            get_raw_cluster(attributes[:cluster], attributes[:datacenter]).resourcePool
+                          end
+          vmFolder      = get_raw_vmfolder(attributes[:path], attributes[:datacenter])
+          vm            = vmFolder.CreateVM_Task(:config => vm_cfg, :pool => resource_pool).wait_for_completion
+          vm.config.instanceUuid
+        rescue => e
+          raise e, "failed to create vm: #{e}"
+        end
+
+        private
+
+        # this methods defines where the vm config files would be located,
+        # by default we prefer to keep it at the same place the (first) vmdk is located
+        def vm_path_name attributes
+          datastore = attributes[:volumes].first.datastore unless attributes[:volumes].empty?
+          datastore ||= 'datastore1'
+          "[#{datastore}]"
+        end
+
+        def device_change attributes
+          devices = []
+          if (nics = attributes[:interfaces])
+            devices << nics.map { |nic| create_interface(nic, nics.index(nic)) }
+          end
+
+          if (disks = attributes[:volumes])
+            devices << create_controller
+            devices << disks.map { |disk| create_disk(disk, disks.index(disk)) }
+          end
+          devices.flatten
+        end
+
+        def create_interface nic, index = 0, operation = :add
+          {
+            :operation => operation,
+            :device    => nic.type.new(
+              :key         => index,
+              :deviceInfo  =>
+                {
+                  :label   => nic.name,
+                  :summary => nic.summary,
+                },
+              :backing     => RbVmomi::VIM.VirtualEthernetCardNetworkBackingInfo(:deviceName => nic.network),
+              :addressType => 'generated')
+          }
+        end
+
+        def create_controller operation = :add, controller_key = 1000, bus_id = 0
+          {
+            :operation => operation,
+            :device    => RbVmomi::VIM.VirtualLsiLogicController(
+              :key       => controller_key,
+              :busNumber => bus_id,
+              :sharedBus => :noSharing
+            )
+          }
+        end
+
+        def create_disk disk, index = 0, operation = :add, controller_key = 1000, unit_id = 0
+          {
+            :operation     => operation,
+            :fileOperation => :create,
+            :device        => RbVmomi::VIM.VirtualDisk(
+              :key           => index,
+              :backing       => RbVmomi::VIM.VirtualDiskFlatVer2BackingInfo(
+                :fileName        => "[#{disk.datastore}]",
+                :diskMode        => disk.mode.to_sym,
+                :thinProvisioned => disk.thin
+              ),
+              :controllerKey => controller_key,
+              :unitNumber    => unit_id,
+              :capacityInKB  => disk.size
+            )
+          }
+        end
+
+        def extra_config attributes
+          [
+            {
+              :key   => 'bios.bootOrder',
+              :value => 'ethernet0'
+            }
+          ]
+        end
+
+      end
+
+      class Mock
+        def create_vm attributes = { }
+        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_datacenter.rb

@@ -0,0 +1,29 @@
+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}
+        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
+          {:name => "Solutions", :status => "grey"}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+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)
+          dc.datastoreFolder.find(name)
+        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,73 @@
+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
+          paths          = path.sub(/^\/?Datacenters\/#{datacenter_name}\/vm\/?/, '').split('/')
+          dc             = find_raw_datacenter(datacenter_name)
+          dc_root_folder = dc.vmFolder
+
+          return dc_root_folder if paths.empty?
+          # Walk the tree resetting the folder pointer as we go
+          paths.inject(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_network.rb

@@ -0,0 +1,25 @@
+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)
+          dc = find_raw_datacenter(datacenter_name)
+          dc.networkFolder.find(name)
+        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      = get_raw_datacenter(datacenter_name)
+          cluster = dc.find_compute_resource(cluster_name)
+          cluster.resourcePool.find 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_virtual_machine.rb

@@ -0,0 +1,62 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_virtual_machine(id, datacenter_name = nil)
+          convert_vm_mob_ref_to_attr_hash(get_vm_ref(id, datacenter_name))
+        end
+
+        protected
+
+        def get_vm_ref(id, dc = nil)
+          vm = case id
+                 # UUID based
+                 when /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+                   @connection.searchIndex.FindByUuid :uuid => id, :vmSearch => true, :instanceUuid => true, :datacenter => dc
+                 else
+                   # try to find based on VM name
+                   if dc
+                     get_datacenter(dc).find_vm(id)
+                   else
+                     raw_datacenters.map { |d| d.find_vm(id) }.compact.first
+                   end
+               end
+          vm ? vm : raise(Fog::Compute::Vsphere::NotFound, "#{id} was not found")
+        end
+      end
+
+      class Mock
+        def get_virtual_machine(id, datacenter_name = nil)
+          case id
+          when "5032c8a5-9c5e-ba7a-3804-832a03e16381", 'vm-715'
+            { :resource_pool    => "Resources",
+              :memory_mb        => 2196,
+              :power_state      => "poweredOn",
+              :mac_addresses    => { "Network adapter 1" => "00:50:56:b2:00:af" },
+              :hostname         => "centos56gm.localdomain",
+              :cpus             => 1,
+              :connection_state => "connected",
+              :mo_ref           => "vm-715",
+              :overall_status   => "green",
+              :datacenter       => "Solutions",
+              :instance_uuid    => "5029c440-85ee-c2a1-e9dd-b63e39364603",
+              :hypervisor       => "gunab.puppetlabs.lan",
+              :guest_id         => "rhel6_64Guest",
+              :cluster          => "virtlabcluster",
+              :tools_state      => "toolsOk",
+              :name             => "jefftest",
+              :operatingsystem  => "Red Hat Enterprise Linux 6 (64-bit)",
+              :path             => "/",
+              :tools_version    => "guestToolsUnmanaged",
+              :ipaddress        => "192.168.100.187",
+              :id               => "5032c8a5-9c5e-ba7a-3804-832a03e16381",
+              :uuid             => "42329da7-e8ab-29ec-1892-d6a4a964912a"
+            }
+          end
+        end
+
+      end
+
+    end
+  end
+end