fog 1.31.0 → 1.37.0

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

@@ -1,296 +0,0 @@
-require 'fog/compute/models/server'
-
-module Fog
-  module Compute
-    class Vsphere
-      class Server < Fog::Compute::Server
-        extend Fog::Deprecation
-        deprecate(:ipaddress, :public_ip_address)
-
-        # This will be the instance uuid which is globally unique across
-        # a vSphere deployment.
-        identity  :id
-
-        # JJM REVISIT (Extend the model of a vmware server)
-        # SEE: http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.VirtualMachine.html
-        # (Take note of the See also section.)
-        # In particular:
-        #   GuestInfo: information about the guest operating system
-        #   VirtualMachineConfigInfo: Access to the VMX file and configuration
-
-        attribute :name
-        # UUID may be the same from VM to VM if the user does not select (I copied it)
-        attribute :uuid
-        attribute :hostname
-        attribute :operatingsystem
-        attribute :public_ip_address, :aliases => 'ipaddress'
-        attribute :power_state,   :aliases => 'power'
-        attribute :tools_state,   :aliases => 'tools'
-        attribute :tools_version
-        attribute :mac_addresses, :aliases => 'macs'
-        attribute :hypervisor,    :aliases => 'host'
-        attribute :connection_state
-        attribute :mo_ref
-        attribute :path
-        attribute :memory_mb
-        attribute :cpus
-        attribute :corespersocket
-        attribute :interfaces
-        attribute :volumes
-        attribute :customvalues
-        attribute :overall_status, :aliases => 'status'
-        attribute :cluster
-        attribute :datacenter
-        attribute :resource_pool
-        attribute :instance_uuid # move this --> id
-        attribute :guest_id
-        attribute :hardware_version
-        attribute :scsi_controller # this is the first scsi controller. Right now no more of them can be used.
-        attribute :cpuHotAddEnabled
-        attribute :memoryHotAddEnabled
-        attribute :firmware
-
-        def initialize(attributes={} )
-          super defaults.merge(attributes)
-          self.instance_uuid ||= id # TODO: remvoe instance_uuid as it can be replaced with simple id
-          initialize_interfaces
-          initialize_volumes
-          initialize_customvalues
-          initialize_scsi_controller
-        end
-
-        # Lazy Loaded Attributes
-        [:datacenter, :cluster, :hypervisor, :resource_pool, :mac_addresses].each do |attr|
-          define_method attr do
-            attributes[attr] = attributes[attr].call if attributes[attr].is_a?(Proc)
-            attributes[attr]
-          end
-        end
-        # End Lazy Loaded Attributes
-
-        def vm_reconfig_memory(options = {})
-          requires :instance_uuid, :memory
-          service.vm_reconfig_memory('instance_uuid' => instance_uuid, 'memory' => memory_mb)
-        end
-
-        def vm_reconfig_cpus(options = {})
-          requires :instance_uuid, :cpus, :corespersocket
-          service.vm_reconfig_cpus('instance_uuid' => instance_uuid, 'cpus' => cpus, 'corespersocket' => corespersocket)
-        end
-
-        def vm_reconfig_hardware(hardware_spec, options = {})
-          requires :instance_uuid
-          service.vm_reconfig_hardware('instance_uuid' => instance_uuid, 'hardware_spec' => hardware_spec)
-        end
-
-        def start(options = {})
-          requires :instance_uuid
-          service.vm_power_on('instance_uuid' => instance_uuid)
-        end
-
-        def stop(options = {})
-          options = { :force => !tools_installed? || !tools_running? }.merge(options)
-          requires :instance_uuid
-          service.vm_power_off('instance_uuid' => instance_uuid, 'force' => options[:force])
-        end
-
-        def reboot(options = {})
-          options = { :force => false }.merge(options)
-          requires :instance_uuid
-          service.vm_reboot('instance_uuid' => instance_uuid, 'force' => options[:force])
-        end
-
-        def destroy(options = {})
-          requires :instance_uuid
-          if ready?
-            # need to turn it off before destroying
-            stop(options)
-            wait_for { !ready? }
-          end
-          service.vm_destroy('instance_uuid' => instance_uuid)
-        end
-
-        def migrate(options = {})
-          options = { :priority => 'defaultPriority' }.merge(options)
-          requires :instance_uuid
-          service.vm_migrate('instance_uuid' => instance_uuid, 'priority' => options[:priority])
-        end
-
-        # Clone from a server object
-        #
-        # ==== Parameters
-        # *<~Hash>:
-        #   * 'name'<~String> - *REQUIRED* Name of the _new_ VirtualMachine
-        #   * See more options in vm_clone request/compute/vm_clone.rb
-        #
-        def clone(options = {})
-          requires :name, :datacenter, :path
-
-          # Convert symbols to strings
-          req_options = options.reduce({}) { |hsh, (k,v)| hsh[k.to_s] = v; hsh }
-
-          # Give our path to the request
-          req_options['template_path'] ="#{relative_path}/#{name}"
-          req_options['datacenter'] = "#{datacenter}"
-
-          # Perform the actual clone
-          clone_results = service.vm_clone(req_options)
-
-          # We need to assign the service, otherwise we can't reload the model
-          # Create the new VM model. TODO This only works when "wait=true"
-          new_vm = self.class.new(clone_results['new_vm'].merge(:service => self.service))
-
-          # We need to assign the collection otherwise we
-          # cannot reload the model.
-          new_vm.collection = self.collection
-
-          # Return the new VM model.
-          new_vm
-        end
-
-        def ready?
-          power_state == "poweredOn"
-        end
-
-        def tools_installed?
-          tools_state != "toolsNotInstalled"
-        end
-
-        def tools_running?
-          tools_state == "toolsOk"
-        end
-
-        # defines VNC attributes on the hypervisor
-        def config_vnc(options = {})
-          requires :instance_uuid
-          service.vm_config_vnc(options.merge('instance_uuid' => instance_uuid))
-        end
-
-        # returns a hash of VNC attributes required for service
-        def vnc
-          requires :instance_uuid
-          service.vm_get_vnc(instance_uuid)
-        end
-
-        def memory
-          memory_mb * 1024 * 1024
-        end
-
-        def sockets
-          cpus / corespersocket
-        end
-
-        def mac
-          interfaces.first.mac unless interfaces.empty?
-        end
-
-        def interfaces
-          attributes[:interfaces] ||= id.nil? ? [] : service.interfaces( :server_id => self.id )
-        end
-
-        def interface_ready? attrs
-          (attrs.is_a? Hash and attrs[:blocking]) or attrs.is_a? Fog::Compute::Vsphere::Interface
-        end
-
-        def add_interface attrs
-          Fog::Logger.deprecation("<server>.add_interface is deprecated. Call <server>.interfaces.create instead.")
-
-          interfaces.create(attrs)
-        end
-
-        def update_interface attrs
-          wait_for { not ready? } if interface_ready? attrs
-          service.update_vm_interface(id, attrs)
-        end
-
-        def destroy_interface attrs
-          Fog::Logger.deprecation("<server>.destroy_vm_interface is deprecated. Call <server>.interfaces.get(:key => <nic_key>).destroy instead.")
-
-          interfaces.get(attrs[:key] || attrs['key']).destroy
-        end
-
-        def volumes
-          attributes[:volumes] ||= id.nil? ? [] : service.volumes(:server_id => self.id)
-        end
-
-        def customvalues
-          attributes[:customvalues] ||= id.nil? ? [] : service.customvalues( :vm => self )
-        end
-
-        def scsi_controller
-          self.attributes[:scsi_controller] ||= service.get_vm_first_scsi_controller(id)
-        end
-
-        def folder
-          return nil unless datacenter and path
-          attributes[:folder] ||= service.folders(:datacenter => datacenter, :type => :vm).get(path)
-        end
-
-        def save
-          requires :name, :cluster, :datacenter
-          if persisted?
-            raise "update is not supported yet"
-           # service.update_vm(attributes)
-          else
-            self.id = service.create_vm(attributes)
-          end
-          reload
-        end
-
-        def new?
-          id.nil?
-        end
-
-        def reload
-          # reload does not re-read assoiciated attributes, so we clear it manually
-          [:interfaces, :volumes].each do |attr|
-            self.attributes.delete(attr)
-          end
-          super
-        end
-
-        def relative_path
-          requires :path, :datacenter
-
-          (path.split('/').reject {|e| e.empty?} - ["Datacenters", datacenter, "vm"]).join("/")
-        end
-
-        private
-
-        def defaults
-          {
-            :cpus      => 1,
-#            :corespersocket => 1,
-            :memory_mb => 512,
-            :guest_id  => 'otherGuest',
-            :path      => '/'
-          }
-        end
-
-        def initialize_interfaces
-          if attributes[:interfaces] and attributes[:interfaces].is_a?(Array)
-            self.attributes[:interfaces].map! { |nic| nic.is_a?(Hash) ? service.interfaces.new(nic) : nic }
-          end
-        end
-
-        def initialize_volumes
-          if attributes[:volumes] and attributes[:volumes].is_a?(Array)
-            self.attributes[:volumes].map! { |vol| vol.is_a?(Hash) ? service.volumes.new(vol) : vol }
-          end
-        end
-
-        def initialize_customvalues
-          if attributes[:customvalues] and attributes[:customvalues].is_a?(Array)
-            self.attributes[:customvalues].map { |cfield| cfield.is_a?(Hash) ? service.customvalue.new(cfield) : cfield}
-          end
-        end
-
-        def initialize_scsi_controller
-          if attributes[:scsi_controller] and attributes[:scsi_controller].is_a?(Hash)
-            Fog::Compute::Vsphere::SCSIController.new(self.attributes[:scsi_controller])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-require 'fog/core/collection'
-require 'fog/vsphere/models/compute/server'
-
-module Fog
-  module Compute
-    class Vsphere
-      class Servers < Fog::Collection
-        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

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

@@ -1,24 +0,0 @@
-require 'fog/core/collection'
-require 'fog/vsphere/models/compute/servertype'
-
-module Fog
-  module Compute
-    class Vsphere
-      class Servertypes < Fog::Collection
-        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/template.rb

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

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

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

@@ -1,54 +0,0 @@
-require 'fog/core/collection'
-require 'fog/vsphere/models/compute/volume'
-
-module Fog
-  module Compute
-    class Vsphere
-      class Volumes < Fog::Collection
-        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

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

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