fog 1.1.2 → 1.2.0

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

@@ -9,18 +9,22 @@ module Fog
 
         model Fog::Compute::Vmfusion::Server
 
-        def all(filter=nil)
+        def all(filter = nil)
 
-          data=[]
+          data = []
 
-          filter={} if filter.nil?
+          states = ::Fission::VM.all_with_status.data
+
+          filter = {} if filter.nil?
           unless filter.has_key?(:name)
-            vms=::Fission::VM.all
+            vms=::Fission::VM.all.data
             vms.each do |vm|
-              data << { :raw => vm}
+              data << { :raw =>  { :fission => vm,
+                                   :state   => states[vm.name] } }
             end
           else
-            data << { :raw => ::Fission::VM.new(filter[:name])}
+            data << { :raw => { :fission => ::Fission::VM.new(filter[:name]),
+                                :state   => states[filter[:name]] } }
           end
 
           load(data)
@@ -28,7 +32,7 @@ module Fog
         end
 
         def get(name)
-          self.all(:name =>name).first
+          self.all(:name => name).first
         end
 
       end

data/lib/fog/voxel/compute.rb

@@ -85,7 +85,7 @@ module Fog
           @scheme             = options[:scheme]  || 'https'
           @persistent         = options[:persistent] || false
 
-          Excon.ssl_verify_peer = false
+          @connection_options[:ssl_verify_peer] = false
 
           @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
         end

data/lib/fog/vsphere/compute.rb

@@ -20,8 +20,13 @@ module Fog
       request :vm_power_on
       request :vm_reboot
       request :vm_clone
+      request :vm_create
       request :vm_destroy
+      request :vm_migrate
       request :datacenters
+      request :vm_reconfig_hardware
+      request :vm_reconfig_memory
+      request :vm_reconfig_cpus
 
       module Shared
 

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

@@ -35,6 +35,18 @@ module Fog
         attribute :mo_ref
         attribute :path
 
+        def vm_reconfig_memory(options = {})
+          requires :instance_uuid, :memory
+          connection.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)
+        end
+        def vm_reconfig_hardware(options = {})
+          requires :instance_uuid, :hardware_spec
+          connection.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)
@@ -57,6 +69,19 @@ module Fog
           connection.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])
+        end
+
+        def create(options ={})
+          requires :name, :path
+          new_vm = self.class.new(create_results['vm_attributes'])
+          new_vm.collection = self.collection
+          new_vm.connection = self.connection
+          new_vm
+        end
         def clone(options = {})
           requires :name, :path
           # Convert symbols to strings

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

@@ -26,7 +26,7 @@ module Fog
           # If the first path element contains "vm" this denotes the vmFolder
           # and needs to be shifted out since each DC contains only one
           # vmFolder
-          path_elements.shift if path_elements[0] = 'vm'
+          path_elements.shift if path_elements[0] == 'vm'
           # Make sure @datacenters is populated (the keys are DataCenter instances)
           self.datacenters.include? dc_name or raise ArgumentError, "Could not find a Datacenter named #{dc_name}"
           # Get the datacenter managed object

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

@@ -5,7 +5,11 @@ module Fog
       module Shared
         private
         def vm_clone_check_options(options)
-          options = { 'force' => false }.merge(options)
+          default_options = {
+            'force'        => false,
+            'linked_clone' => false,
+          }
+          options = default_options.merge(options)
           required_options = %w{ path name }
           required_options.each do |param|
             raise ArgumentError, "#{required_options.join(', ')} are required" unless options.has_key? param
@@ -41,7 +45,7 @@ module Fog
           template_dc = path_elements.shift
           # If the first path element contains "vm" this denotes the vmFolder
           # and needs to be shifted out
-          path_elements.shift if path_elements[0] = 'vm'
+          path_elements.shift if path_elements[0] == 'vm'
           # The template name.  The remaining elements are the folders in the
           # datacenter.
           template_name = path_elements.pop
@@ -70,16 +74,47 @@ module Fog
           esx_host = vm_mob_ref.collect!('runtime.host')['runtime.host']
           # The parent of the ESX host itself is a ComputeResource which has a resourcePool
           resource_pool = esx_host.parent.resourcePool
-
-          # Next, create a Relocation Spec instance
-          relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
-                                                                    :transform => options['transform'] || 'sparse')
+          relocation_spec=nil
+          if ( options['linked_clone'] )
+            # cribbed heavily from the rbvmomi clone_vm.rb
+            # this chunk of code reconfigures the disk of the clone source to be read only,
+            # and then creates a delta disk on top of that, this is required by the API in order to create
+            # linked clondes
+            disks = vm_mob_ref.config.hardware.device.select do |vm_device|
+              vm_device.class == RbVmomi::VIM::VirtualDisk
+            end
+            disks.select{|vm_device| vm_device.backing.parent == nil}.each do |disk|
+              disk_spec = {
+                :deviceChange => [
+                  {
+                    :operation => :remove,
+                    :device => disk
+                  },
+                  {
+                    :operation => :add,
+                    :fileOperation => :create,
+                    :device => disk.dup.tap{|disk_backing|
+                      disk_backing.backing = disk_backing.backing.dup;
+                      disk_backing.backing.fileName = "[#{disk.backing.datastore.name}]";
+                      disk_backing.backing.parent = disk.backing
+                    }
+                  },
+                ]
+              }
+              vm_mob_ref.ReconfigVM_Task(:spec => disk_spec).wait_for_completion
+            end
+            # Next, create a Relocation Spec instance
+            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
+                                                                      :diskMoveType => :moveChildMostDiskBacking)
+          else
+            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
+                                                                      :transform => options['transform'] || 'sparse')
+          end
           # And the clone specification
           clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(:location => relocation_spec,
                                                             :powerOn  => options['power_on'] || true,
                                                             :template => false)
           task = vm_mob_ref.CloneVM_Task(:folder => vm_mob_ref.parent, :name => options['name'], :spec => clone_spec)
-
           # Waiting for the VM to complete allows us to get the VirtulMachine
           # object of the new machine when it's done.  It is HIGHLY recommended
           # to set 'wait' => true if your app wants to wait.  Otherwise, you're
@@ -126,7 +161,7 @@ module Fog
           end
           {
             'vm_ref'   => 'vm-123',
-            'task_ref' => 'task-1234'
+            'task_ref' => 'task-1234',
           }
         end
 

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

@@ -0,0 +1,97 @@
+module Fog
+  module Compute
+    class Vsphere
+
+      module Shared
+        private
+        def vm_create_check_options(options)
+          options = { 'force' => false }.merge(options)
+          required_options = %w{ path name cluster }
+          required_options.each do |param|
+            raise ArgumentError, "#{required_options.join(', ')} are required" unless options.has_key? param
+          end
+          # The tap removes the leading empty string
+          path_elements = options['path'].split('/').tap { |o| o.shift }
+          first_folder = path_elements.shift
+          if first_folder != 'Datacenters' then
+            raise ArgumentError, "vm_create path option must start with /Datacenters.  Got: #{options['path']}"
+          end
+          dc_name = path_elements.shift
+          if not self.datacenters.include? dc_name then
+            raise ArgumentError, "Datacenter #{dc_name} does not exist, only datacenters #{self.datacenters.join(",")} are accessible."
+          end
+          options
+        end
+      end
+
+      class Real
+        include Shared
+        def vm_create(options = {})
+          # Option handling
+          options = vm_create_check_options(options)
+          path_elements = options['path'].split('/').tap { |ary| ary.shift 2 }
+          dc_name = path_elements.shift
+          vm_cfg = {
+            :name                => options['name'],
+            :guestId             => options['guest_id'] ? options['guest_id'] : 'otherGuest',
+            :files               => { :vmPathName => "[#{options['datastore']}]" },
+            :numCPUs             => options['num_cpus'] ? options['num_cpus'] : 1 ,
+            :memoryMB            => options['memory'] ? options['memory'] : 512,
+            :memoryHotAddEnabled => options['memory_hot_add_enabled'] ? options['memory_hot_add_enabled'] : 0,
+            :cpuHotAddEnabled    => options['cpu_hot_add_enabled'] ? options['cpu_hot_add_enabled'] : 0,
+            :deviceChange        => options['device_array'].class == Array ? options['device_array'] : nil,
+            :extraConfig         => options['extra_config'].class == Array ? options['extra_config'] : nil,
+          }
+          self.datacenters
+          dc = @datacenters[dc_name]
+          vm_folder = dc.vmFolder
+          folder = path_elements.inject(vm_folder) do |current_folder, sub_folder_name|
+            sub_folder = current_folder.find(sub_folder_name, RbVmomi::VIM::Folder)
+            raise ArgumentError, "Could not descend into #{sub_folder_name}.  Please check your path." unless sub_folder
+            sub_folder
+          end
+          clusters = dc.hostFolder.children
+          build_cluster=''
+          clusters.each { |my_cluster|
+            if "#{my_cluster.name}" == "#{options['cluster']}"
+              build_cluster=my_cluster
+            end
+          }
+          resource_pool = build_cluster.resourcePool
+          task=folder.CreateVM_Task(:config => vm_cfg, :pool => resource_pool)
+          if options['wait'] then
+            new_vm = task.wait_for_completion
+          else
+            tries = 0
+            new_vm = begin
+              folder.find(options['name'], RbVmomi::VIM::VirtualMachine) or raise Fog::Vsphere::Errors::NotFound
+            rescue Fog::Vsphere::Errors::NotFound
+              tries += 1
+              if tries <= 10 then
+                sleep 15
+                retry
+              end
+                nil
+            end
+          end
+          {
+            'vm_ref'        => new_vm ? new_vm._ref : nil,
+            'vm_attributes' => new_vm ? convert_vm_mob_ref_to_attr_hash(new_vm) : {},
+            'task_ref'      => task._ref
+          }
+        end
+      end
+      class Mock
+        include Shared
+        def vm_create(options = {})
+          # Option handling
+          options = vm_create_check_options(options)
+          {
+            'vm_ref'   => 'vm-123',
+            'task_ref' => 'task-1234'
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+
+        def vm_migrate(options = {})
+          #priority is the only required option, and it has a sane default option.
+          priority = options['priority'].nil? ? 'defaultPriority' : options["priority"]
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+
+          # Find the VM Object
+          search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
+          vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first
+
+          unless vm_mob_ref.kind_of? RbVmomi::VIM::VirtualMachine
+            raise Fog::Vsphere::Errors::NotFound,
+              "Could not find VirtualMachine with instance uuid #{options['instance_uuid']}"
+          end
+          task = vm_mob_ref.MigrateVM_Task(:pool => options['pool'], :host => options['host'], :priority => "#{priority}", :state => options['state'] )
+          task.wait_for_completion
+          { 'task_state' => task.info.state }
+        end
+
+      end
+
+      class Mock
+
+        def vm_migrate(options = {})
+          priority = options['priority'].nil? ? 'defaultPriority' : options["priority"]
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          { 'task_state' => 'success' }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_reconfig_cpus(options = {})
+          raise ArgumentError, "cpus is a required parameter" unless options.has_key? 'cpus'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          hardware_spec={'numCPUs' => options['cpus']}
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+        end
+      end
+
+      class Mock
+        def vm_reconfig_cpus(options = {})
+          raise ArgumentError, "cpus is a required parameter" unless options.has_key? 'cpus'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          hardware_spec={'numCPUs' => options['cpus']}
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_reconfig_hardware(options = {})
+          raise ArgumentError, "hardware_spec is a required parameter" unless options.has_key? 'hardware_spec'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
+          vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first
+          task = vm_mob_ref.ReconfigVM_Task(:spec => RbVmomi::VIM.VirtualMachineConfigSpec(options['hardware_spec']))
+          task.wait_for_completion
+           { 'task_state' => task.info.state }
+        end
+      end
+
+      class Mock
+        def vm_reconfig_hardware(options = {})
+          raise ArgumentError, "hardware_spec is a required parameter" unless options.has_key? 'hardware_spec'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          { 'task_state' => 'success' }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_reconfig_memory(options = {})
+          raise ArgumentError, "memory is a required parameter" unless options.has_key? 'memory'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          hardware_spec={'memoryMB' => options['memory']}
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+        end
+      end
+
+      class Mock
+        def vm_reconfig_memory(options = {})
+          raise ArgumentError, "memory is a required parameter" unless options.has_key? 'memory'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          hardware_spec={'memoryMB' => options['memory']}
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+        end
+      end
+    end
+  end
+end

data/lib/fog/zerigo/models/dns/record.rb

@@ -44,19 +44,21 @@ module Fog
           options[:notes]     = description if description
           options[:priority]  = priority if priority
           options[:ttl]       = ttl if ttl
-          data = unless identity
-            connection.create_host(@zone.id, type, value, options)
-          else
+
+          if identity
             options[:host_type] = type
             options[:data]      = value
             connection.update_host(identity, options)
+          else
+            data = connection.create_host(@zone.id, type, value, options)
+            merge_attributes(data.body)
           end
-          merge_attributes(data.body)
+
           true
         end
 
         private
-        
+
         def zone=(new_zone)
           @zone = new_zone
         end

data/lib/fog/zerigo/parsers/dns/create_host.rb

@@ -11,8 +11,10 @@ module Fog
 
           def end_element(name)
             case name
-            when 'id', 'priority', 'ttl', 'zone-id'
+            when 'id', 'zone-id'
               @response[name] = value.to_i
+            when 'priority', 'ttl'
+              @response[name] = value.to_i if value
             when 'data', 'fqdn', 'host-type', 'hostname', 'notes', 'zone-id', 'created-at', 'updated-at'
               @response[name] = value
             end

data/lib/fog/zerigo/parsers/dns/find_hosts.rb

@@ -12,8 +12,10 @@ module Fog
 
           def end_element(name)
             case name
-            when 'id', 'priority', 'ttl', 'zone-id'
+            when 'id', 'zone-id'
               @host[name] = value.to_i
+            when 'priority', 'ttl'
+              @host[name] = value.to_i if value
             when 'data', 'fqdn', 'host-type', 'hostname', 'notes', 'zone-id', 'created-at', 'updated-at'
               @host[name] = value
             when 'host'