deltacloud-core 0.3.0 → 0.4.0

data/lib/deltacloud/drivers/rimuhosting/rimuhosting_client.rb

@@ -40,14 +40,15 @@ class RimuHostingClient
     if(!@auth.nil?)
       headers["Authorization"] = @auth
     end
+    safely do
     r = @service.send_request(method, @uri.path + resource, data, headers)
          puts r.body
     res = JSON.parse(r.body)
     res = res[res.keys[0]]
 
     if(res['response_type'] == "ERROR" and ( (res['error_info']['error_class'] == "PermissionException") or
-					     (res['error_info']['error_class'] == "LoginRequired") )) 
-      raise Deltacloud::AuthException.new
+					     (res['error_info']['error_class'] == "LoginRequired") ))
+      raise "AuthFailure"
     end
     res
   end

data/lib/deltacloud/drivers/rimuhosting/rimuhosting_driver.rb

@@ -108,13 +108,13 @@ class RimuHostingDriver < Deltacloud::BaseDriver
   end
 
   def create_instance(credentials, image_id, opts)
-     rh = RimuHostingClient.new(credentials)
+    rh = RimuHostingClient.new(credentials)
     # really need to raise an exception here.
     hwp_id = opts[:hwp_id] || 1
-    # really bad, but at least its a fqdn
-    name = Time.now.to_s + '.com'
-    if (opts[:name]) then
-      name = opts[:name]
+    name = opts[:name]
+    if not name
+      # really bad, but at least its a fqdn
+      name = Time.now.to_i.to_s + '.com'
     end
     convert_srv_to_instance(rh.create_server(image_id, hwp_id, name))
 
@@ -149,15 +149,12 @@ class RimuHostingDriver < Deltacloud::BaseDriver
     stopped.to( :finish )         .automatically
   end
 
-  def safely(&block)
-    begin
-      block.call
-    rescue Exception => e
-      raise Deltacloud::BackendError.new(500, e.class.to_s, e.message, e.backtrace)
+  exceptions do
+    on /AuthFailure/ do
+      status 401
     end
   end
 
-
 end
 
     end

data/lib/deltacloud/drivers/sbc/sbc_client.rb

@@ -22,9 +22,9 @@ require 'digest/md5'
 module Deltacloud
   module Drivers
     module SBC
-      
+
 class FixtureNotFound < Exception; end
-  
+
 #
 # Client for the IBM Smart Business Cloud (SBC).
 #
@@ -180,9 +180,9 @@ class SBCClient
   #
   def backend_error!(resp)
     if resp.is_a?(Net::HTTPUnauthorized)
-      raise Deltacloud::AuthException, resp.message
+      raise "AuthFailure"
     else
-      raise Deltacloud::BackendError.new(resp.code, resp.body, resp.message, '')
+      raise "BackendError"
     end
   end
 
@@ -192,7 +192,7 @@ class SBCClient
   def urlencode(hash)
     hash.keys.map { |k| "#{URI.encode(k)}=#{URI.encode(hash[k])}" }.join("&")
   end
-  
+
   #
   # Reads a fake URL from local fixtures
   #
@@ -240,7 +240,7 @@ class SBCClient
       retry
     end
   end
-  
+
 end
     end
   end

data/lib/deltacloud/drivers/sbc/sbc_driver.rb

@@ -88,6 +88,10 @@ class SBCDriver < Deltacloud::BaseDriver
     body['location'] = opts[:realm_id] || @last_image['location']
     body['instanceType'] = opts[:hwp_id].gsub('-', '/') || @last_image['supportedInstanceTypes'][0]['id']
 
+    if not body['name']
+      body['name'] = Time.now.to_i.to_s
+    end
+
     # Submit instance, parse response
     convert_instance(sbc_client.create_instance(body).map[0])
   end
@@ -118,6 +122,18 @@ class SBCDriver < Deltacloud::BaseDriver
     instance(credentials, instance_id)
   end
 
+  exceptions do
+
+    on /AuthFailure/ do
+      status 401
+    end
+
+    on /BackendError/ do
+      status 502
+    end
+
+  end
+
   #
   # --------------------- Private helpers ---------------------
   #

data/lib/deltacloud/drivers/terremark/terremark_driver.rb

@@ -31,7 +31,11 @@ module Deltacloud
 
 class TerremarkDriver < Deltacloud::BaseDriver
 
-  feature :instances, :user_name
+  feature :instances, :user_name do
+    constraint :max_length, 15
+  end
+
+  USER_NAME_MAX = feature(:instances, :user_name).constraints[:max_length]
 
 #--
 # Vapp State Map... for use with convert_instance (get an integer back from terremark)
@@ -128,9 +132,13 @@ VAPP_STATE_MAP = { "0" =>  "PENDING", "1" =>  "PENDING", "2" =>  "STOPPED", "4"
     new_vapp = nil
     vapp_opts = {} #assemble options to pass to Fog::Terremark::Real.instantiate_vapp_template
     terremark_hwp = hardware_profiles(credentials, {:name => 'default'}).first #sanity check values against default
-    name = opts['name'] #name could be nil or length 0 or too long
-    name = "inst#{Time.now.to_i}" if (name.nil? || (name.length == 0))
-    name = name.slice(0..13) #name < 15 chars (says terremark)
+    name = opts[:name]
+    if not name
+      name = "inst#{Time.now.to_i}"
+    end
+    if name.length > USER_NAME_MAX
+      raise "Parameter name must be #{USER_NAME_MAX} characters or less"
+    end
     unless ( (terremark_hwp.include?(:cpu, opts[:hwp_cpu].to_i)) &&
               (terremark_hwp.include?(:memory, opts[:hwp_memory].to_i)) ) then
        raise Deltacloud::Validation::Failure.new(Deltacloud::Validation::Param.new(["cpu"]), "Error with cpu and/or memory values. you said cpu->#{opts[:hwp_cpu]} and mem->#{opts[:hwp_memory]}")
@@ -192,7 +200,7 @@ end
 def valid_credentials?(credentials)
   begin
     new_client(credentials)
-  rescue Deltacloud::AuthException
+  rescue
     return false
   end
   true
@@ -272,20 +280,17 @@ end
       vdc_id = terremark_client.default_vdc_id
     end
     if (vdc_id.nil?)
-       raise DeltaCloud::AuthException.new
+       raise "AuthFailure"
     end
     terremark_client
   end
 
-  def safely(&block)
-    begin
-      block.call
-    rescue Exception => e
-      raise Deltacloud::BackendError.new(500, e.class.to_s, e.message, e.backtrace)
+  exceptions do
+    on /AuthFailure/ do
+      status 401
     end
   end
 
-
 end
 
     end

data/lib/deltacloud/drivers/vsphere/vsphere_client.rb

@@ -0,0 +1,140 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+
+module Deltacloud::Drivers::VSphere
+
+  require 'deltacloud/drivers/vsphere/vsphere_filemanager'
+
+  module Helper
+
+    # Find a VirtualMachine traversing through all Datastores and Datacenters
+    #
+    # This helper will return a Hash: { :datastore => NAME_OF_DS, :instance => VM }
+    # Returning datastore is necesarry for constructing a correct realm for an
+    # instance
+    #
+    def find_vm(credentials, name)
+      vsphere = new_client(credentials)
+      safely do
+        rootFolder = vsphere.serviceInstance.content.rootFolder
+        vm = {}
+        rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).each do |dc|
+          dc.datastoreFolder.childEntity.collect do |datastore|
+            vm[:instance] = datastore.vm.find { |x| x.name == name }
+            if vm[:instance]
+              vm[:datastore] = datastore.name
+              break
+            end
+            stored_tasks(datastore, vsphere) do |task|
+              if task.info.entity.class == RbVmomi::VIM::VirtualMachine and ['queued', 'running'].member? task.info.state
+                vm = { :stored_instance => load_serialized_instance(datastore,task.info.key), :datastore => datastore.name }
+              end
+            end
+          end
+          break if [:datastore]
+        end
+        vm
+      end
+    end
+
+    # Find a ResourcePool[1] object associated by given Datastore
+    # ResourcePool is defined for Datacenter and is used for launching a new
+    # instance
+    #
+    # [1] http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.ResourcePool.html
+    #
+    def find_resource_pool(credentials, name)
+      vsphere = new_client(credentials)
+      safely do
+        rootFolder = vsphere.serviceInstance.content.rootFolder
+        dc = rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).select do |dc|
+          dc.datastoreFolder.childEntity.find { |d| d.name == name }.nil? == false
+        end.flatten.compact.first
+        dc.hostFolder.childEntity.collect.first.resourcePool
+      end
+    end
+
+    # This helper will try to find a Datastore[1] object in all Datacenters.
+    # Datastore is used to place instance on create to correct place
+    #
+    # [1] http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.Datastore.html
+    #
+    def find_datastore(credentials, name)
+      vsphere = new_client(credentials)
+      safely do
+        rootFolder = vsphere.serviceInstance.content.rootFolder
+        rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).collect do |dc|
+          dc.datastoreFolder.childEntity.find { |d| d.name == name }
+        end.flatten.compact.first
+      end
+    end
+
+    # This helper will traverse across all datacenters and datastores and gather
+    # all virtual machines available on vSphere
+    #
+    def list_virtual_machines(credentials)
+      vsphere = new_client(credentials)
+      vms = []
+      rootFolder = vsphere.serviceInstance.content.rootFolder
+      rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).each do |dc|
+        dc.datastoreFolder.childEntity.each do |datastore|
+          vms += datastore.vm.collect { |vm| { :instance => vm, :datastore => datastore.name } unless vm.nil? }
+          stored_tasks(datastore, vsphere) do |task|
+            if task.info.entity.class == RbVmomi::VIM::VirtualMachine
+              vms << { :stored_instance => load_serialized_instance(datastore, task.info.key), :datastore => datastore.name }
+            end
+          end
+        end
+      end
+      vms.flatten.compact
+    end
+
+    # Map given instance to task. Task name is used as a filename.
+    #
+    def map_task_to_instance(datastore, task_key, new_instance)
+      VSphere::FileManager::store_mapping!(datastore, YAML::dump(new_instance).to_s, task_key)
+      new_instance
+    end
+
+    def load_serialized_instance(datastore, task_key)
+      VSphere::FileManager::load_mapping(datastore, task_key)
+    end
+
+    # Yield all tasks if they are included in mapper storage directory.
+    def stored_tasks(datastore, vsphere)
+      tasks = VSphere::FileManager::list_mappings(datastore)
+      return [] if tasks.empty?
+      vsphere.serviceInstance.content.taskManager.recentTask.each do |task|
+        if tasks.include?(task.info.key) and ['queued', 'running'].member?(task.info.state)
+          yield task
+          tasks.delete(task.info.key)
+        end
+      end
+      # Delete old left tasks
+      tasks.select { |f| f =~ /task-(\d+)/ }.each do |task|
+        VSphere::FileManager::delete_mapping!(datastore, task)
+      end
+    end
+
+    def extract_architecture(text)
+      'x86_64' if text.include?('64-bit')
+      'i386' if text.include?('32-bit')
+    end
+
+
+  end
+
+end

data/lib/deltacloud/drivers/vsphere/vsphere_driver.rb

@@ -0,0 +1,405 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+
+require 'deltacloud/base_driver'
+require 'rbvmomi'
+require 'deltacloud/drivers/vsphere/vsphere_client'
+
+module Deltacloud::Drivers::VSphere
+
+  MAPPER_STORAGE_ROOT = File::join("/var/tmp", "deltacloud-vsphere-#{ENV["USER"]}")
+
+  class VSphereDriver < Deltacloud::BaseDriver
+
+    include Deltacloud::Drivers::VSphere::Helper
+    include Deltacloud::Drivers::VSphere::FileManager
+
+    # You can use 'user_iso' feature to set 'user_iso' parameter when creating
+    # a new instance where this parameter can hold gzipped CDROM iso which will
+    # be mounted into created instance after boot
+    feature :instances, :user_iso
+    feature :instances, :user_data
+    feature :instances, :user_name
+
+    # There is just one hardware profile where memory is measured using maximum
+    # memory available on ESX for virtual machines and CPU using maximum free
+    # CPU cores in ESX.
+    def hardware_profiles(credentials, opts={})
+      vsphere = new_client(credentials)
+      safely do
+        service = vsphere.serviceInstance.content
+        max_memory, max_cpu_cores = 0, 0
+        service.rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).each do |dc|
+          max_memory += dc.hostFolder.childEntity.first.summary.effectiveMemory
+          max_cpu_cores += dc.hostFolder.childEntity.first.summary.numCpuCores
+        end
+        [Deltacloud::HardwareProfile::new('default') do
+          cpu (1..max_cpu_cores)
+          memory (128..max_memory)
+          architecture ['x86_64', 'i386']
+        end]
+      end
+    end
+
+    # Configure instance state machine
+    define_instance_states do
+      start.to(:pending)          .on( :create )
+      pending.to(:stopped)        .automatically
+      stopped.to(:running)        .on( :start )
+      running.to(:running)        .on( :reboot )
+      running.to(:shutting_down)  .on( :stop )
+      shutting_down.to(:stopped)  .automatically
+      stopped.to(:finish)         .on( :destroy )
+    end
+
+
+    # Images are virtual machines with 'template' flag set to be true.
+    # Thus we're getting them using find_vm and list_virtual_machines
+    def images(credentials, opts=nil)
+      cloud = new_client(credentials)
+      img_arr = []
+
+      # Skip traversing through all instances in all datacenters when ID
+      # attribute is set
+      safely do
+        if opts[:id]
+          template_vms = [ find_vm(credentials, opts[:id]) ].select { |vm| vm[:instance] }.compact
+        else
+          template_vms = list_virtual_machines(credentials).select { |vm| vm[:instance] && vm[:instance].summary.config[:template] }
+        end
+        img_arr = template_vms.collect do |image_hash|
+          image, realm = image_hash[:instance], image_hash[:datastore]
+          config = image.summary.config
+          instance_state = convert_state(:instance, image.summary.runtime[:powerState])
+          # Preload all properties to save multiple SOAP calls to vSphere
+          properties = {
+            :name => config[:name],
+            :full_name => config[:guestFullName]
+          }
+          image_state = convert_state(:image, image.summary.runtime[:powerState])
+          # This will determine image architecture using image description.
+          # Ussualy description include '64-bit' or '32-bit'. In case you used
+          # some weird template/OS it will fallback to 64 bit
+          image_architecture = extract_architecture(properties[:full_name]) || 'x86_64'
+          Image.new(
+            :id => properties[:name],
+            :name => properties[:name],
+            :architecture => image_architecture,
+            :owner_id => credentials.user,
+            :description => properties[:full_name],
+            :state => image_state
+          )
+        end
+      end
+      img_arr = filter_on( img_arr, :architecture, opts )
+      img_arr.sort_by{|e| [e.owner_id, e.name]}
+    end
+
+    def create_image(credentials, opts={})
+      vsphere = new_client(credentials)
+      safely do
+        find_vm(credentials, opts[:id])[:instance].MarkAsTemplate
+      end
+      images(credentials, :id => opts[:id])
+    end
+
+    # List all datacenters managed by the vSphere or vCenter entrypoint.
+    def realms(credentials, opts=nil)
+      vsphere = new_client(credentials)
+      safely do
+        if opts and opts[:id]
+          datastore = find_datastore(credentials, opts[:id])
+          [convert_realm(datastore)]
+        else
+          rootFolder = vsphere.serviceInstance.content.rootFolder
+          rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).collect do |dc|
+            dc.datastoreFolder.childEntity.collect { |datastore| convert_realm(datastore) }
+          end.flatten
+        end
+      end
+    end
+
+    # List all running instances, across all datacenters. DeltaCloud API does
+    # not yet support filtering instances by realm.
+    def instances(credentials, opts=nil)
+      cloud = new_client(credentials)
+      inst_arr, machine_vms, pending_vms = [], [], []
+      safely do
+        # Using find_vm is a way faster than listing all virtual machines
+        if opts[:id]
+          list_vms = [ find_vm(credentials, opts[:id]) ].compact
+        else
+          list_vms = list_virtual_machines(credentials)
+        end
+        # Split machines to the 'real' one and PENDING one.
+        machine_vms = list_vms.select { |vm| vm[:instance] && !vm[:instance].summary.config[:template] }
+        pending_vms = list_vms.select { |vm| vm[:stored_instance] }.collect { |vm| vm[:stored_instance]}
+      end
+      safely do
+        inst_arr = machine_vms.collect do |vm_hash|
+          # Since all calls to vm are threaten as SOAP calls, reduce them using
+          # local variable.
+          vm, realm_id = vm_hash[:instance], vm_hash[:datastore]
+          config = vm.summary.config
+          next if not config
+          # Template (image_id) is beeing stored as 'extraConfig' parameter in
+          # instance.
+          template_id = vm.config[:extraConfig].select { |k| k.key == 'template_id' }
+          template_id = template_id.first.value unless template_id.empty?
+          properties = {
+            :memory => config[:memorySizeMB],
+            :cpus => config[:numCpu],
+            :storage => vm.summary.storage[:unshared],
+            :name => config[:name],
+            :full_name => config[:guestFullName],
+          }
+          instance_state = convert_state(:instance, vm.summary.runtime[:powerState])
+          instance_profile = InstanceProfile::new('default',
+                                                  :hwp_cpu => properties[:cpus],
+                                                  :hwp_memory => properties[:memory],
+                                                  :hwp_storage => properties[:storage])
+
+          # We're getting IP address from 'vmware guest tools'.
+          # If guest tools are not installed, we return list of MAC addresses
+          # assigned to this instance.
+          instance_address = vm.guest[:net].empty? ? vm.macs.values.first : vm.guest[:net].first[:ipAddress].first
+          Instance.new(
+            :id => properties[:name],
+            :name => properties[:name],
+            :owner_id => credentials.user,
+            :image_id => template_id,
+            :description => properties[:full_name],
+            :realm_id => realm_id,
+            :state => instance_state,
+            :public_addresses => instance_address,
+            :private_addresses => [],
+            :instance_profile => instance_profile,
+            :actions => instance_actions_for( instance_state ),
+            :create_image => true
+          )
+        end
+      end
+      inst_arr.compact!
+      # Append 'temporary' instances to real instances.
+      # 'Temporary' or 'stored' instance are used to speed up instance creation
+      # process by serializing instances to datastore and map instance to task.
+      #
+      inst_arr += pending_vms
+      filter_on( inst_arr, :state, opts )
+    end
+
+
+    def create_instance(credentials, image_id, opts)
+      vsphere = new_client(credentials)
+      safely do
+        rootFolder = vsphere.serviceInstance.content.rootFolder
+        vm = find_vm(credentials, opts[:image_id])
+        # New instance need valid resource pool and datastore to be placed.
+        # For this reason, realm_id **needs** to be set.
+        if opts and opts[:realm_id]
+          resourcePool = find_resource_pool(credentials, opts[:realm_id])
+          datastore = find_datastore(credentials, opts[:realm_id])
+        else
+          resourcePool = find_resource_pool(credentials, vm[:datastore])
+          datastore = find_datastore(credentials, vm[:datastore])
+        end
+        relocate = { :pool => resourcePool, :datastore => datastore }
+        relocateSpec = RbVmomi::VIM.VirtualMachineRelocateSpec(relocate)
+        # Set extra configuration for VM, like template_id
+        machine_config = {
+          :memoryMB => opts[:hwp_memory],
+          :numCPUs => opts[:hwp_cpu],
+          :extraConfig => [
+            { :key => 'template_id', :value => image_id },
+          ]
+        }
+        if (opts[:user_data] and not opts[:user_data].empty?) and (opts[:user_iso] and not opts[:user_iso].empty?)
+          raise "ERROR: You cannot use user_data and user_iso features together"
+        end
+        # If user wants to inject data into instance he need to submit a Base64
+        # encoded gzipped ISO image.
+        # This image will be uplaoded to the Datastore given in 'realm_id'
+        # parameter and them attached to instance.
+        if opts[:user_data] and not opts[:user_data].empty?
+          device = vm[:instance].config.hardware.device.select { |hw| hw.class == RbVmomi::VIM::VirtualCdrom }.first
+          if device
+            VSphere::FileManager::user_data!(datastore, opts[:user_data], "#{opts[:name]}.iso")
+            machine_config[:extraConfig] << {
+              :key => 'user_data_file', :value => "#{opts[:name]}.iso"
+            }
+            device.backing = RbVmomi::VIM.VirtualCdromIsoBackingInfo(:fileName => "[#{opts[:realm_id] || vm[:datastore]}] "+
+                                                                     "/#{VSphere::FileManager::DIRECTORY_PATH}/#{opts[:name]}.iso")
+            machine_config.merge!({
+              :deviceChange => [{
+                :operation => :edit,
+                :device => device
+              }]
+            })
+          else
+            raise "Failed to inject data to device because there is no CD-ROM drive defined in given template"
+          end
+        end
+        if opts[:user_iso] and not opts[:user_iso].empty?
+          device = vm[:instance].config.hardware.device.select { |hw| hw.class == RbVmomi::VIM::VirtualCdrom }.first
+          if device
+            VSphere::FileManager::store_iso!(datastore, opts[:user_iso], "#{opts[:name]}.iso")
+            machine_config[:extraConfig] << {
+              :key => 'user_iso_file', :value => "#{opts[:name]}.iso"
+            }
+            device.backing = RbVmomi::VIM.VirtualCdromIsoBackingInfo(:fileName => "[#{opts[:realm_id] || vm[:datastore]}] "+
+                                                                     "/#{VSphere::FileManager::DIRECTORY_PATH}/#{opts[:name]}.iso")
+            machine_config.merge!({
+              :deviceChange => [{
+                :operation => :edit,
+                :device => device
+              }]
+            })
+          else
+            raise "Failed to inject data to device because there is no CD-ROM drive defined in given template"
+          end
+        end
+        spec = RbVmomi::VIM.VirtualMachineCloneSpec(
+          :location => relocateSpec,
+          :powerOn => true,
+          :template => false,
+          :config => RbVmomi::VIM.VirtualMachineConfigSpec(machine_config)
+        )
+        instance_profile = InstanceProfile::new('default', :hwp_memory => opts[:hwp_memory], :hwp_cpu => opts[:hwp_cpu])
+        task = vm[:instance].CloneVM_Task(:folder => vm[:instance].parent, :name => opts[:name], :spec => spec)
+        new_instance = Instance::new(
+          :id => opts[:name],
+          :name => opts[:name],
+          :description => opts[:name],
+          :owner_id => credentials.user,
+          :image_id => opts[:image_id],
+          :realm_id => opts[:realm_id] || vm[:datastore],
+          :state => 'PENDING',
+          :public_addresses => [],
+          :private_addresses => [],
+          :instance_profile => instance_profile,
+          :actions => instance_actions_for( 'PENDING' ),
+          :create_image => false
+        )
+        # This will 'serialize' instance to YAML file and map it to the task.
+        # Ussualy it takes like 2-3 minutes (depending on storage size) to
+        # complete instance cloning process.
+        map_task_to_instance(datastore, task.info.key, new_instance)
+      end
+    end
+
+    # Reboot an instance, given its id.
+    def reboot_instance(credentials, id)
+      find_vm(credentials, id)[:instance].ResetVM_Task
+    end
+
+    # Start an instance, given its id.
+    def start_instance(credentials, id)
+      find_vm(credentials, id)[:instance].PowerOnVM_Task
+    end
+
+    # Stop an instance, given its id.
+    def stop_instance(credentials, id)
+      find_vm(credentials, id)[:instance].PowerOffVM_Task
+    end
+
+    # Destroy an instance, given its id. Note that this will destroy all
+    # instance data.
+    #
+    # If there is user-data dile asocciated with instance, remove this file as
+    # well.
+    def destroy_instance(credentials, instance_id)
+      vm = find_vm(credentials, instance_id)
+      user_file = vm[:instance].config[:extraConfig].select { |k| k.key == 'user_iso_file' }.first
+      VSphere::FileManager::delete_iso!(vm[:instance].send(:datastore).first, user_file.value) if user_file
+      vm[:instance].Destroy_Task.wait_for_completion
+    end
+
+    alias :destroy_image :destroy_instance
+
+    exceptions do
+
+      on /InvalidLogin/ do
+        status 401
+      end
+
+      on /ERROR/ do
+        status 500
+      end
+
+      on /RbVmomi::Fault/ do
+        status 502
+      end
+
+      on /Failed to inject data/ do
+        status 502
+      end
+
+    end
+
+    def valid_credentials?(credentials)
+      begin
+        RbVmomi::VIM.connect(:host => host_endpoint, :user => credentials.user, :password => credentials.password, :insecure => true)
+        return true
+      rescue
+        return false
+      end
+    end
+
+    #######
+    private
+    #######
+
+    def new_client(credentials)
+      safely do
+        RbVmomi::VIM.connect(:host => host_endpoint, :user => credentials.user, :password => credentials.password, :insecure => true)
+      end
+    end
+
+    def host_endpoint
+      endpoint = api_provider
+      endpoint || Deltacloud::Drivers::driver_config[:vsphere][:entrypoints]['default']['default']
+    end
+
+    def convert_realm(datastore)
+      Realm::new(
+        :id => datastore.name,
+        :name => datastore.name, 
+        :limit => datastore.summary.freeSpace,
+        :state => datastore.summary.accessible ? 'AVAILABLE' : 'UNAVAILABLE'
+      )
+    end
+
+    def convert_state(object, state)
+      new_state = ''
+      if object == :image
+        new_state = case state
+          when 'poweredOff' then 'AVAILABLE'
+          when 'poweredOn' then 'UNAVAILABLE'
+        end
+      end
+      if object == :instance
+        new_state = case state
+          when 'poweredOff' then 'STOPPED'
+          when 'poweredOn' then 'RUNNING'
+          else 'PENDING'
+        end
+      end
+      new_state
+    end
+
+  end
+
+end