fog-vsphere 0.1.0

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

@@ -0,0 +1,36 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Servers < Fog::Collection
+        autoload :Server, File.expand_path('../server', __FILE__)
+
+        model Fog::Compute::Vsphere::Server
+        attr_accessor :datacenter
+        attr_accessor :network
+        attr_accessor :cluster
+        attr_accessor :resource_pool
+        attr_accessor :folder
+
+        # 'folder' => '/Datacenters/vm/Jeff/Templates' will be MUCH faster.
+        # than simply listing everything.
+        def all(filters = { })
+          f = {
+            :datacenter    => datacenter,
+            :cluster       => cluster,
+            :network       => network,
+            :resource_pool => resource_pool,
+            :folder        => folder
+          }.merge(filters)
+
+          load service.list_virtual_machines(f)
+        end
+
+        def get(id, datacenter = nil)
+          new service.get_virtual_machine id, datacenter
+        rescue Fog::Compute::Vsphere::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Servertype < Fog::Model
+        identity :id
+
+        attribute :family
+        attribute :fullname
+        attribute :datacenter
+        attribute :interfacetypes
+
+        def initialize(attributes={} )
+          super defaults.merge(attributes)
+        end
+
+        def to_s
+          id
+        end
+
+        def interfacetypes filters={}
+          attributes[:interfacetypes] ||= service.interfacetypes({ :datacenter => datacenter, :servertype => self }.merge(filters))
+        end
+
+        private
+
+        def defaults
+          {
+            :id=>"otherGuest64",
+            :family=>"otherGuestFamily",
+            :interfacetypes => nil,
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Servertypes < Fog::Collection
+        autoload :Servertype, File.expand_path('../servertype', __FILE__)
+
+        model Fog::Compute::Vsphere::Servertype
+        attr_accessor :datacenter, :id, :fullname
+
+        def all(filters = { })
+          load service.list_server_types(filters.merge({:datacenter => datacenter}))
+        end
+
+        def get(id)
+          requires :datacenter
+          new service.get_server_type(id, datacenter)
+        rescue Fog::Compute::Vsphere::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Compute
+    class Vsphere
+      class Snapshot < Fog::Model
+
+        identity  :ref
+        attribute :server_id
+
+        attribute :name
+        attribute :quiescedi, :default => false
+        attribute :description, :default => ''
+        attribute :create_time
+        attribute :power_state, :default => 'none'
+        attribute :ref
+        attribute :mo_ref
+        attribute :tree_node
+        attribute :snapshot_name_chain
+        attribute :ref_chain
+
+        def child_snapshots(filters = {})
+          service.snapshots(
+            { :server_id => server_id, :parent_snapshot => self }.update(filters)
+          )
+        end
+
+        def get_child(snapshot_ref)
+          return self if ref == snapshot_ref
+          child_snapshots().get(snapshot_ref)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/vsphere/models/compute/snapshot'
+
+module Fog
+  module Compute
+    class Vsphere
+      class Snapshots < Fog::Collection
+        attribute :server_id, :alias => :instance_uuid
+        attribute :parent_snapshot
+        model Fog::Compute::Vsphere::Snapshot
+
+        def all(filters = {})
+          if parent_snapshot
+            load service.list_child_snapshots(parent_snapshot, filters)
+          else
+            requires :server_id
+            load service.list_vm_snapshots(server_id, filters)
+          end
+        end
+
+        def get(snapshot_ref)
+          all.find { |snapshot| snapshot.get_child(snapshot_ref) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Template < Fog::Model
+        identity :id
+        attribute :name
+        attribute :uuid
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Templates < Fog::Collection
+        autoload :Template, File.expand_path('../template', __FILE__)
+
+        model Fog::Compute::Vsphere::Template
+
+        def all(filters = {})
+          load service.list_templates(filters)
+        end
+
+        def get(id)
+          new service.get_template(id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+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 :eager_zero
+        attribute :name
+        attribute :filename
+        attribute :size_gb
+        attribute :key
+        attribute :unit_number
+        attribute :server_id
+
+        def initialize(attributes={} )
+          # Assign server first to prevent race condition with persisted?
+          self.server_id = attributes.delete(:server_id)
+
+          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
+
+        def destroy
+          requires :server_id, :key, :unit_number
+
+          service.destroy_vm_volume(self)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :server_id, :size, :datastore
+
+          if unit_number.nil?
+            used_unit_numbers = server.volumes.map { |volume| volume.unit_number }
+            max_unit_number = used_unit_numbers.max
+
+            if max_unit_number > server.volumes.size
+              # If the max ID exceeds the number of volumes, there must be a hole in the range. Find a hole and use it.
+              self.unit_number = max_unit_number.times.to_a.find { |i| used_unit_numbers.exclude?(i) }
+            else
+              self.unit_number = max_unit_number + 1
+            end
+          else
+            if server.volumes.any? { |volume| volume.unit_number == self.unit_number && volume.id != self.id }
+              raise "A volume already exists with that unit_number, so we can't save the new volume"
+            end
+          end
+
+          data = service.add_vm_volume(self)
+
+          if data['task_state'] == 'success'
+            # We have to query vSphere to get the volume attributes since the task handle doesn't include that info.
+            created = server.volumes.all.find { |volume| volume.unit_number == self.unit_number }
+
+            self.id = created.id
+            self.key = created.key
+            self.filename = created.filename
+
+            true
+          else
+            false
+          end
+        end
+
+        def server
+          requires :server_id
+          service.servers.get(server_id)
+        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,53 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Volumes < Fog::Collection
+        autoload :Volume, File.expand_path('../volume', __FILE__)
+
+        attribute :server_id
+
+        model Fog::Compute::Vsphere::Volume
+
+        def all(filters = {})
+          requires :server_id
+
+          case server
+            when Fog::Compute::Vsphere::Server
+              load service.list_vm_volumes(server.id)
+            when Fog::Compute::Vsphere::Template
+              load service.list_template_volumes(server.id)
+            else
+              raise 'volumes should have vm or template'
+            end
+
+          self.each { |volume| volume.server_id = server.id }
+          self
+        end
+
+        def get(id)
+          new service.get_volume(id)
+        end
+
+        def new(attributes = {})
+          if server_id
+            # Default to the root volume datastore if one is not configured.
+            datastore = ! attributes.key?(:datastore) && self.any? ? self.first.datastore : nil
+
+            super({ :server_id => server_id, :datastore => datastore }.merge!(attributes))
+          else
+            super
+          end
+        end
+
+        def server
+          return nil if server_id.nil?
+          service.servers.get(server_id)
+        end
+
+        def server=(new_server)
+          server_id = new_server.id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def cloudinit_to_customspec(user_data)
+          raise ArgumentError, "user_data can't be nil" if user_data.nil?
+          custom_spec = { 'customization_spec' => Hash.new }
+          user_data = YAML.load(user_data)
+          # https://pubs.vmware.com/vsphere-55/index.jsp#com.vmware.wssdk.apiref.doc/vim.vm.customization.Specification.html
+          # encryptionKey expects an array
+          # globalIPSettings expects a hash, REQUIRED
+          # identity expects an hash, REQUIRED
+          # nicSettingMap expects an array
+          # options expects an hash
+
+          custom_spec['encryptionKey']    = user_data['encryptionKey'] if user_data.key?('encryptionKey')
+          custom_spec['globalIPSettings'] = user_data['globalIPSettings'] if user_data.key?('globalIPSettings')
+          custom_spec['identity']         = user_data['identity'] if user_data.key?('identity')
+          custom_spec['nicSettingMap']    = user_data['nicSettingMap'] if user_data.key?('nicSettingMap')
+          custom_spec['options']          = user_data['options'] if user_data.key?('options')
+          
+          # for backwards compatability
+          # hostname expects a string, REQUIRED
+          # netmask expects a string
+          # dns expects an array
+          # gateway expects an array
+          # domain expects a string, REQUIRED
+          # domainsuffixlist expects an array, REQUIRED
+          # timezone expects a string, for example Europe/Copenhagen, REQUIRED
+          custom_spec['hostname']                    =  user_data['hostname'] if user_data.key?('hostname')
+          custom_spec['ipsettings']                  =  { 'ip' => user_data['ip'] } if user_data.key?('ip')
+          custom_spec['ipsettings']['subnetMask']    =  user_data['netmask'] if user_data.key?('netmask')
+          custom_spec['ipsettings']['dnsServerList'] =  user_data['dns'] if user_data.key?('dns')
+          custom_spec['ipsettings']['gateway']       =  user_data['gateway'] if user_data.key?('gateway')
+          custom_spec['domain']                      =  user_data['domain'] if user_data.key?('domain')
+          custom_spec['dnsSuffixList']               =  user_data['domainsuffixlist'] if user_data.key?('domainsuffixlist')
+          custom_spec['time_zone']                   =  user_data['timezone'] if user_data.key?('timezone')
+          custom_spec  
+        end
+      end
+
+      class Mock
+        def cloudinit_to_customspec(user_data)
+          raise ArgumentError, "user_data can't be nil" if user_data.nil?
+          custom_spec = { 'customization_spec' => Hash.new }
+          user_data = YAML.load(user_data)
+          custom_spec['encryptionKey']                = user_data['encryptionKey'] if user_data.key?('encryptionKey')
+          custom_spec['globalIPSettings']             = user_data['globalIPSettings'] if user_data.key?('globalIPSettings')
+          custom_spec['identity']                     = user_data['identity'] if user_data.key?('identity')
+          custom_spec['nicSettingMap']                = user_data['nicSettingMap'] if user_data.key?('nicSettingMap')
+          custom_spec['options']                      = user_data['options'] if user_data.key?('options')
+          custom_spec['hostname']                     =  user_data['hostname'] if user_data.key?('hostname')
+          custom_spec['ipsettings']                   =  { 'ip' => user_data['ip'] } if user_data.key?('ip')
+          custom_spec['ipsettings']['subnetMask']     =  user_data['netmask'] if user_data.key?('netmask')
+          custom_spec['ipsettings']['dnsServerList']  =  user_data['dns'] if user_data.key?('dns')
+          custom_spec['ipsettings']['gateway']        =  user_data['gateway'] if user_data.key?('gateway')
+          custom_spec['domain']                       =  user_data['domain'] if user_data.key?('domain')
+          custom_spec['dnsSuffixList']                =  user_data['domainsuffixlist'] if user_data.key?('domainsuffixlist')
+          custom_spec['time_zone']                    =  user_data['timezone'] if user_data.key?('timezone')
+          custom_spec  
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def create_folder(datacenter, path, name)
+          #Path cannot be nil but it can be an empty string
+          raise ArgumentError, "Path cannot be nil" if path.nil?
+
+          parent_folder = get_raw_vmfolder(path, datacenter)
+          begin
+            new_folder = parent_folder.CreateFolder(:name => name)
+            # output is cleaned up to return the new path
+            # new path will be path/name, example: "Production/Pool1"
+            new_folder.path.reject { |a| a.first.class == "Folder" }.map { |a| a.first.name }.join("/").sub(/^\/?Datacenters\/#{datacenter}\/vm\/?/, '')
+          rescue => e
+            raise e, "failed to create folder: #{e}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+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],
+            :version      => attributes[:hardware_version],
+            :files        => { :vmPathName => vm_path_name(attributes) },
+            :numCPUs      => attributes[:cpus],
+            :numCoresPerSocket => attributes[:corespersocket],
+            :memoryMB     => attributes[:memory_mb],
+            :deviceChange => device_change(attributes),
+            :extraConfig  => extra_config(attributes),
+          }
+          vm_cfg[:cpuHotAddEnabled] = attributes[:cpuHotAddEnabled] if attributes.key?(:cpuHotAddEnabled)
+          vm_cfg[:memoryHotAddEnabled] = attributes[:memoryHotAddEnabled] if attributes.key?(:memoryHotAddEnabled)
+          vm_cfg[:firmware] = attributes[:firmware] if attributes.key?(:firmware)
+          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), :add, attributes) }
+          end
+
+          if (disks = attributes[:volumes])
+            devices << create_controller(attributes[:scsi_controller]||attributes["scsi_controller"]||{})
+            devices << disks.map { |disk| create_disk(disk, disks.index(disk)) }
+          end
+          devices.flatten
+        end
+
+        def create_nic_backing nic, attributes
+          raw_network = get_raw_network(nic.network, attributes[:datacenter], if nic.virtualswitch then nic.virtualswitch end)
+
+          if raw_network.kind_of? RbVmomi::VIM::DistributedVirtualPortgroup
+            RbVmomi::VIM.VirtualEthernetCardDistributedVirtualPortBackingInfo(
+              :port => RbVmomi::VIM.DistributedVirtualSwitchPortConnection(
+                :portgroupKey => raw_network.key,
+                :switchUuid   => raw_network.config.distributedVirtualSwitch.uuid
+              )
+            )
+          else
+            RbVmomi::VIM.VirtualEthernetCardNetworkBackingInfo(:deviceName => nic.network)
+          end
+        end
+
+        def create_interface nic, index = 0, operation = :add, attributes = {}
+          {
+            :operation => operation,
+            :device    => nic.type.new(
+              :key         => index,
+              :deviceInfo  =>
+                {
+                  :label   => nic.name,
+                  :summary => nic.summary,
+                },
+              :backing     => create_nic_backing(nic, attributes),
+              :addressType => 'generated')
+          }
+        end
+
+        def create_controller options=nil
+          options=if options
+                    controller_default_options.merge(Hash[options.map{|k,v| [k.to_sym,v] }])
+                  else
+                    controller_default_options
+                  end
+          controller_class=if options[:type].is_a? String then
+                             Fog::Vsphere.class_from_string options[:type], "RbVmomi::VIM"
+                           else
+                             options[:type]
+                           end
+          {
+            :operation => options[:operation],
+            :device    => controller_class.new({
+              :key       => options[:key],
+              :busNumber => options[:bus_id],
+              :sharedBus => controller_get_shared_from_options(options),
+            })
+          }
+        end
+
+        def controller_default_options
+          {:operation => "add", :type => RbVmomi::VIM.VirtualLsiLogicController.class, :key => 1000, :bus_id => 0, :shared => false }
+        end
+
+        def controller_get_shared_from_options options
+          if (options.key? :shared and options[:shared]==false) or not options.key? :shared then
+            :noSharing
+          elsif options[:shared]==true then
+            :virtualSharing
+          elsif options[:shared].is_a? String
+            options[:shared]
+          else
+            :noSharing
+          end
+        end
+
+        def create_disk disk, index = 0, operation = :add, controller_key = 1000
+          if (index > 6) then
+            _index = index + 1
+          else
+            _index = index
+          end
+          payload = {
+            :operation     => operation,
+            :fileOperation => operation == :add ? :create : :destroy,
+            :device        => RbVmomi::VIM.VirtualDisk(
+              :key           => disk.key || _index,
+              :backing       => RbVmomi::VIM.VirtualDiskFlatVer2BackingInfo(
+                :fileName        => "[#{disk.datastore}]",
+                :diskMode        => disk.mode.to_sym,
+                :thinProvisioned => disk.thin
+              ),
+              :controllerKey => controller_key,
+              :unitNumber    => _index,
+              :capacityInKB  => disk.size
+            )
+          }
+
+          if operation == :add && disk.thin == 'false' && disk.eager_zero == 'true'
+            payload[:device][:backing][:eagerlyScrub] = disk.eager_zero
+          end
+
+          payload
+        end
+
+        def extra_config attributes
+          [
+            {
+              :key   => 'bios.bootOrder',
+              :value => 'ethernet0'
+            }
+          ]
+        end
+      end
+
+      class Mock
+        def create_vm attributes = { }
+        end
+      end
+    end
+  end
+end