fog 1.8.0 → 1.9.0

data/lib/fog/virtual_box/models/compute/network_adapter.rb

@@ -41,7 +41,7 @@ module Fog
         undef_method :nat_driver
         def nat_driver
           Fog::Compute::VirtualBox::NATEngine.new(
-            :connection       => connection,
+            :service       => service,
             :machine          => machine,
             :network_adapter  => self,
             :raw              => raw.nat_driver

data/lib/fog/virtual_box/models/compute/network_adapters.rb

@@ -15,7 +15,7 @@ module Fog
           requires :machine
           data = []
           raw_machine = machine.instance_variable_get(:@raw)
-          connection.system_properties.network_adapter_count.times do |index|
+          service.system_properties.network_adapter_count.times do |index|
             data << {
               :raw  => raw_machine.get_network_adapter(index)
             }

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

@@ -83,7 +83,7 @@ module Fog
             wait_for { raw.session_state == :closed }
           end
           raw.unregister(:full)
-          config_file = connection.compose_machine_filename(name)
+          config_file = service.compose_machine_filename(name)
           config_directory = config_file.split(File::SEPARATOR)[0...-1].join(File::SEPARATOR)
           FileUtils.rm_rf(config_directory)
           true
@@ -91,7 +91,7 @@ module Fog
 
         def network_adapters
           Fog::Compute::VirtualBox::NetworkAdapters.new(
-            :connection => connection,
+            :service => service,
             :machine => self
           )
         end
@@ -117,8 +117,8 @@ module Fog
         def save
           unless identity
             requires :name, :os
-            self.raw = connection.create_machine(nil, name, os)
-            connection.register_machine(raw)
+            self.raw = service.create_machine(nil, name, os)
+            service.register_machine(raw)
             with_session do |session|
               for attribute in [:description, :memory_size, :rtc_use_utc, :vram_size]
                 session.machine.send(:"#{attribute}=", attributes[attribute])
@@ -161,7 +161,7 @@ module Fog
 
         def storage_controllers
           Fog::Compute::VirtualBox::StorageControllers.new(
-            :connection => connection,
+            :service => service,
             :machine    => self
           )
         end

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

@@ -10,7 +10,7 @@ module Fog
         model Fog::Compute::VirtualBox::Server
 
         def all
-          data = connection.machines.map do |machine|
+          data = service.machines.map do |machine|
             {
               :raw => machine
             }
@@ -28,7 +28,7 @@ module Fog
         end
 
         def get(server_id)
-          machine = connection.find_machine(server_id)
+          machine = service.find_machine(server_id)
           new(:raw => machine)
         rescue ::VirtualBox::Exceptions::ObjectNotFoundException
           nil

data/lib/fog/vmfusion/compute.rb

@@ -20,7 +20,12 @@ module Fog
       class Real
 
         def initialize(options={})
-          require 'fission'
+          begin
+            require 'fission'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
         end
 
       end

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

@@ -27,7 +27,7 @@ module Fog
           requires :raw
 
           ::Fission::VM.clone(@raw[:fission].name,name)
-          return connection.servers.get(name)
+          return service.servers.get(name)
         end
 
         # Destroy, deletes the VM from the local disk but only hard stops the VM

data/lib/fog/voxel/models/compute/images.rb

@@ -10,12 +10,12 @@ module Fog
         model Fog::Compute::Voxel::Image
 
         def all
-          data = connection.images_list.body['images']
+          data = service.images_list.body['images']
           load(data)
         end
 
         def get(image_id)
-          data = connection.images_list(image_id).body['images']
+          data = service.images_list(image_id).body['images']
 
           if data.empty?
             nil

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

@@ -22,13 +22,13 @@ module Fog
 
         def destroy
           requires :id
-          connection.voxcloud_delete(id)
+          service.voxcloud_delete(id)
           true
         end
 
         def image
           requires :image_id
-          connection.images.get(image_id)
+          service.images.get(image_id)
         end
 
         def ready?
@@ -45,19 +45,19 @@ module Fog
 
         def reboot
           requires :id
-          connection.devices_power(id, :reboot)
+          service.devices_power(id, :reboot)
           true
         end
 
         def state
-          @state ||= connection.voxcloud_status(id).body['devices'].first['status']
+          @state ||= service.voxcloud_status(id).body['devices'].first['status']
         end
 
         def save
-          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
           requires :name, :image_id, :processing_cores, :facility, :disk_size
 
-          data = connection.voxcloud_create({
+          data = service.voxcloud_create({
             :disk_size => disk_size,
             :facility => facility,
             :hostname => name,

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

@@ -9,12 +9,12 @@ module Fog
         model Fog::Compute::Voxel::Server
 
         def all
-          data = connection.devices_list.body['devices'].select {|device| device['type']['id'] == '3'}
+          data = service.devices_list.body['devices'].select {|device| device['type']['id'] == '3'}
           load(data)
         end
 
         def get(device_id)
-          if device_id && server = connection.devices_list(device_id).body['devices']
+          if device_id && server = service.devices_list(device_id).body['devices']
             new(server.first)
           end
         rescue Fog::Service::Error => error

data/lib/fog/vsphere/compute.rb

@@ -59,6 +59,7 @@ module Fog
       request :vm_reconfig_memory
       request :vm_reconfig_cpus
       request :vm_config_vnc
+      request :create_folder
 
       module Shared
 
@@ -123,7 +124,9 @@ module Fog
             # This inline rescue catches any standard error.  While a VM is
             # cloning, a call to the macs method will throw and NoMethodError
             attrs['mac_addresses'] = vm_mob_ref.macs rescue nil
-            attrs['path'] = get_folder_path(vm_mob_ref.parent)
+            # Rescue nil to catch testing while vm_mob_ref isn't reaL?? 
+            attrs['path'] = "/"+vm_mob_ref.parent.path.map(&:last).join('/') rescue nil
+            attrs['relative_path'] = (attrs['path'].split('/').reject {|e| e.empty?} - ["Datacenters", attrs['datacenter'], "vm"]).join("/") rescue nil
           end
         end
 

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

@@ -13,8 +13,8 @@ module Fog
         attribute :overall_status
 
         def resource_pools(filters = { })
-          self.attributes[:resource_pools] ||= id.nil? ? [] : connection.resource_pools({
-                                                                                          :connection => connection,
+          self.attributes[:resource_pools] ||= id.nil? ? [] : service.resource_pools({
+                                                                                          :service => service,
                                                                                           :cluster    => name,
                                                                                           :datacenter => datacenter
                                                                                         }.merge(filters))

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

@@ -12,12 +12,12 @@ module Fog
 
         def all(filters = {})
           requires :datacenter
-          load connection.list_clusters(filters.merge(:datacenter => datacenter))
+          load service.list_clusters(filters.merge(:datacenter => datacenter))
         end
 
         def get(id)
           requires :datacenter
-          new connection.get_cluster(id, datacenter)
+          new service.get_cluster(id, datacenter)
         end
 
       end

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

@@ -9,19 +9,23 @@ module Fog
         attribute :status
 
         def clusters filters = { }
-          connection.clusters({ :datacenter => name }.merge(filters))
+          service.clusters({ :datacenter => name }.merge(filters))
         end
 
         def networks filters = { }
-          connection.networks({ :datacenter => name }.merge(filters))
+          service.networks({ :datacenter => name }.merge(filters))
         end
 
         def datastores filters = { }
-          connection.datastores({ :datacenter => name }.merge(filters))
+          service.datastores({ :datacenter => name }.merge(filters))
         end
 
         def vm_folders filters = { }
-          connection.folders({ :datacenter => name, :type => :vm }.merge(filters))
+          service.folders({ :datacenter => name, :type => :vm }.merge(filters))
+        end
+
+        def virtual_machines filters = {}
+          service.servers({ :datacenter => name }.merge(filters))
         end
 
         def to_s

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

@@ -10,14 +10,14 @@ module Fog
         model Fog::Compute::Vsphere::Datacenter
 
         def all(filters = {})
-          load connection.list_datacenters(filters)
+          load service.list_datacenters(filters)
         end
 
         def get(name)
-          new connection.get_datacenter(name)
+          new service.get_datacenter(name)
         end
 
       end
     end
   end
-end
+end

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

@@ -11,12 +11,12 @@ module Fog
         attr_accessor :datacenter
 
         def all(filters = {})
-          load connection.list_datastores(filters.merge(:datacenter => datacenter))
+          load service.list_datastores(filters.merge(:datacenter => datacenter))
         end
 
         def get(id)
           requires :datacenter
-          new connection.get_datastore(id, datacenter)
+          new service.get_datastore(id, datacenter)
         end
 
       end

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

@@ -14,7 +14,7 @@ module Fog
 
         def vms
           return [] if type.to_s != 'vm'
-          connection.servers(:folder => path, :datacenter => datacenter)
+          service.servers(:folder => path, :datacenter => datacenter)
         end
 
         def to_s

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

@@ -13,12 +13,12 @@ module Fog
         def all(filters = { })
           requires :datacenter
           requires :type
-          load connection.list_folders(filters.merge(:datacenter => datacenter, :type => type, :path => path))
+          load service.list_folders(filters.merge(:datacenter => datacenter, :type => type, :path => path))
         end
 
         def get(id)
           requires :datacenter
-          new connection.get_folder(id, datacenter, type)
+          new service.get_folder(id, datacenter, type)
         end
 
       end

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

@@ -15,16 +15,16 @@ module Fog
           requires :vm
           case vm
             when Fog::Compute::Vsphere::Server
-              load connection.list_vm_interfaces(vm.id)
+              load service.list_vm_interfaces(vm.id)
             when Fog::Compute::Vsphere::Template
-              load connection.list_template_interfaces(vm.id)
+              load service.list_template_interfaces(vm.id)
             else
             raise 'interfaces should have vm or template'
           end
         end
 
         def get(id)
-          new connection.get_interface(id)
+          new service.get_interface(id)
         end
 
      end

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

@@ -11,12 +11,12 @@ module Fog
         attr_accessor :datacenter
 
         def all(filters = {})
-          load connection.list_networks(filters.merge(:datacenter => datacenter))
+          load service.list_networks(filters.merge(:datacenter => datacenter))
         end
 
         def get(id)
           requires :datacenter
-          new connection.get_network(id, datacenter)
+          new service.get_network(id, datacenter)
         end
 
       end

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

@@ -11,16 +11,16 @@ module Fog
         attr_accessor :datacenter, :cluster
 
         def all(filters = {})
-          load connection.list_resource_pools(filters.merge(:datacenter => datacenter, :cluster => cluster))
+          load service.list_resource_pools(filters.merge(:datacenter => datacenter, :cluster => cluster))
         end
 
         def get(id)
           requires :datacenter
           requires :cluster
-          new connection.get_resource_pool(id, cluster, datacenter)
+          new service.get_resource_pool(id, cluster, datacenter)
         end
 
       end
     end
   end
-end
+end

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

@@ -5,6 +5,8 @@ module Fog
     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.
@@ -22,7 +24,7 @@ module Fog
         attribute :uuid
         attribute :hostname
         attribute :operatingsystem
-        attribute :ipaddress,     :aliases => 'public_ip_address'
+        attribute :public_ip_address, :aliases => 'ipaddress'
         attribute :power_state,   :aliases => 'power'
         attribute :tools_state,   :aliases => 'tools'
         attribute :tools_version
@@ -31,6 +33,7 @@ module Fog
         attribute :connection_state
         attribute :mo_ref
         attribute :path
+        attribute :relative_path
         attribute :memory_mb
         attribute :cpus
         attribute :interfaces
@@ -51,62 +54,70 @@ module Fog
 
         def vm_reconfig_memory(options = {})
           requires :instance_uuid, :memory
-          connection.vm_reconfig_memory('instance_uuid' => instance_uuid, 'memory' => memory)
+          service.vm_reconfig_memory('instance_uuid' => instance_uuid, 'memory' => memory)
         end
 
         def vm_reconfig_cpus(options = {})
           requires :instance_uuid, :cpus
-          connection.vm_reconfig_cpus('instance_uuid' => instance_uuid, 'cpus' => cpus)
+          service.vm_reconfig_cpus('instance_uuid' => instance_uuid, 'cpus' => cpus)
         end
 
         def vm_reconfig_hardware(options = {})
           requires :instance_uuid, :hardware_spec
-          connection.vm_reconfig_hardware('instance_uuid' => instance_uuid, 'hardware_spec' => hardware_spec)
+          service.vm_reconfig_hardware('instance_uuid' => instance_uuid, 'hardware_spec' => hardware_spec)
         end
 
         def start(options = {})
           requires :instance_uuid
-          connection.vm_power_on('instance_uuid' => instance_uuid)
+          service.vm_power_on('instance_uuid' => instance_uuid)
         end
 
         def stop(options = {})
           options = { :force => !tools_installed? }.merge(options)
           requires :instance_uuid
-          connection.vm_power_off('instance_uuid' => instance_uuid, 'force' => options[:force])
+          service.vm_power_off('instance_uuid' => instance_uuid, 'force' => options[:force])
         end
 
         def reboot(options = {})
           options = { :force => false }.merge(options)
           requires :instance_uuid
-          connection.vm_reboot('instance_uuid' => instance_uuid, 'force' => options[:force])
+          service.vm_reboot('instance_uuid' => instance_uuid, 'force' => options[:force])
         end
 
         def destroy(options = {})
           requires :instance_uuid
           stop if ready? # need to turn it off before destroying
-          connection.vm_destroy('instance_uuid' => instance_uuid)
+          service.vm_destroy('instance_uuid' => instance_uuid)
         end
 
         def migrate(options = {})
           options = { :priority => 'defaultPriority' }.merge(options)
           requires :instance_uuid
-          connection.vm_migrate('instance_uuid' => instance_uuid, 'priority' => options[:priority])
+          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
+          requires :name, :datacenter, :relative_path
           # Convert symbols to strings
           req_options = options.inject({}) { |hsh, (k,v)| hsh[k.to_s] = v; hsh }
           # Give our path to the request
-          req_options['path'] ="#{path}/#{name}"
+          req_options['template_path'] ="#{relative_path}/#{name}"
+          req_options['datacenter'] = "#{datacenter}"
           # Perform the actual clone
-          clone_results = connection.vm_clone(req_options)
-          # Create the new VM model.
-          new_vm = self.class.new(clone_results['vm_attributes'])
+          clone_results = service.vm_clone(req_options)
+          # Create the new VM model. TODO This only works when "wait=true"
+          new_vm = self.class.new(clone_results['new_vm'])
           # We need to assign the collection and the connection otherwise we
           # cannot reload the model.
           new_vm.collection = self.collection
-          new_vm.connection = self.connection
+          new_vm.service = service
           # Return the new VM model.
           new_vm
         end
@@ -122,13 +133,13 @@ module Fog
         # defines VNC attributes on the hypervisor
         def config_vnc(options = {})
           requires :instance_uuid
-          connection.vm_config_vnc(options.merge('instance_uuid' => instance_uuid))
+          service.vm_config_vnc(options.merge('instance_uuid' => instance_uuid))
         end
 
-        # returns a hash of VNC attributes required for connection
+        # returns a hash of VNC attributes required for service
         def vnc
           requires :instance_uuid
-          connection.vm_get_vnc(instance_uuid)
+          service.vm_get_vnc(instance_uuid)
         end
 
         def memory
@@ -140,25 +151,25 @@ module Fog
         end
 
         def interfaces
-          attributes[:interfaces] ||= id.nil? ? [] : connection.interfaces( :vm => self )
+          attributes[:interfaces] ||= id.nil? ? [] : service.interfaces( :vm => self )
         end
 
         def volumes
-          attributes[:volumes] ||= id.nil? ? [] : connection.volumes( :vm => self )
+          attributes[:volumes] ||= id.nil? ? [] : service.volumes( :vm => self )
         end
 
         def folder
           return nil unless datacenter and path
-          attributes[:folder] ||= connection.folders(:datacenter => datacenter, :type => :vm).get(path)
+          attributes[:folder] ||= service.folders(:datacenter => datacenter, :type => :vm).get(path)
         end
 
         def save
           requires :name, :cluster, :datacenter
-          if identity
+          if persisted?
             raise "update is not supported yet"
-           # connection.update_vm(attributes)
+           # service.update_vm(attributes)
           else
-            self.id = connection.create_vm(attributes)
+            self.id = service.create_vm(attributes)
           end
           reload
         end
@@ -188,13 +199,13 @@ module Fog
 
         def initialize_interfaces
           if attributes[:interfaces] and attributes[:interfaces].is_a?(Array)
-            self.attributes[:interfaces].map! { |nic| nic.is_a?(Hash) ? connection.interfaces.new(nic) : nic }
+            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) ? connection.volumes.new(vol) : vol }
+            self.attributes[:volumes].map! { |vol| vol.is_a?(Hash) ? service.volumes.new(vol) : vol }
           end
         end
       end