deltacloud-core 0.5.0 → 1.0.0

data/lib/deltacloud/drivers/opennebula/opennebula_driver.rb

@@ -15,230 +15,293 @@
 # under the License.
 #
 
-require 'deltacloud/base_driver'
+require 'deltacloud/drivers/opennebula/occi_client'
 
 require 'erb'
+# TBD Nokogiri support
 require 'rexml/document'
 
-path = File.dirname(__FILE__)
-$: << path
-
-require 'occi_client'
-
 module Deltacloud
   module Drivers
     module Opennebula
 
 class OpennebulaDriver < Deltacloud::BaseDriver
 
-  feature :instances, :user_name
+  define_hardware_profile('default')
 
   ######################################################################
   # Hardware profiles
-  ######################################################################
-
-  define_hardware_profile 'small'
-
-  define_hardware_profile 'medium'
+  #####################################################################
+  def hardware_profiles(credentials, opts=nil)
+    occi_client = new_client(credentials)
+    xml = occi_client.get_instance_types
+    if CloudClient.is_error?(xml)
+      # OpenNebula 3.0 support
+      @hardware_profiles = ['small','medium','large'].map {|name|
+        ::Deltacloud::HardwareProfile.new(name)
+      }
+    else
+      # OpenNebula 3.2 support
+      @hardware_profiles = REXML::Document.new(xml).root.elements.map {|d|
+        elem = d.elements
+        ::Deltacloud::HardwareProfile.new(elem['NAME'].text) {
+          cpu          elem['CPU']
+          memory       elem['MEMORY']
+          storage      elem['STORAGE']
+          architecture elem['ARCHITECTURE']
+        }
+      }
+    end
 
-  define_hardware_profile 'large'
+    filter_hardware_profiles(@hardware_profiles, opts)
+  end
 
   ######################################################################
   # Realms
   ######################################################################
 
   (REALMS = [
-	Realm.new( {
-		:id=>'Any id',
-		:name=>'Any name',
-		:limit=>:unlimited,
-		:state=>'Any state',
-	} ),
+  Realm.new( {
+    :id=>'ONE',
+    :name=>'Opennebula',
+    :limit=>:unlimited,
+    :state=>'AVAILABLE',
+  } ),
   ] ) unless defined?( REALMS )
 
 
   def realms(credentials, opts=nil)
-	return REALMS if ( opts.nil? )
-	results = REALMS
-	results = filter_on( results, :id, opts )
-	results
+    return REALMS if ( opts.nil? )
+    results = REALMS
+    results = filter_on( results, :id, opts )
+    results
   end
 
 
   ######################################################################
   # Images
   ######################################################################
-
   def images(credentials, opts=nil)
-	occi_client = new_client(credentials)
-
-	images = []
-	imagesxml = occi_client.get_images
+    occi_client = new_client(credentials)
 
-	storage = REXML::Document.new(imagesxml)
-	storage.root.elements.each do |d|
-		id = d.attributes['href'].split("/").last
+    xml = treat_response(occi_client.get_images)
 
-		diskxml = occi_client.get_image(id)
+    # TBD Add extended info in the pool
+    images = REXML::Document.new(xml).root.elements.map do |d|
+      im_id = d.attributes['href'].split("/").last
+      storage = treat_response(occi_client.get_image(im_id))
+      convert_image(storage, credentials)
+    end
+  end
 
-		images << convert_image(diskxml.to_s(), credentials)
-	end
-	images
+  def image(credentials, opts=nil)
+    occi_client = new_client(credentials)
+    xml = treat_response(occi_client.get_image(opts[:id]))
+    convert_image(xml, credentials)
   end
 
+  def destroy_image(credentials, id)
+    occi_client = new_client(credentials)
+    treat_response(occi_client.delete_image(opts[:id]))
+  end
 
   ######################################################################
   # Instances
   ######################################################################
 
-  define_instance_states do
-	start.to( :pending )			.on( :create )
-
-	pending.to( :running )			.automatically
-
-	running.to( :stopped )			.on( :stop )
+  feature :instances, :user_name
+  # TBD Add Context to the VMs
+
+  OCCI_VM = %q{
+    <COMPUTE>
+      <% if opts[:name] %>
+      <NAME><%=opts[:name]%></NAME>
+      <% end %>
+      <INSTANCE_TYPE><%= opts[:hwp_id] || 'small' %></INSTANCE_TYPE>
+      <DISK>
+        <STORAGE href="<%= storage_href %>" />
+      </DISK>
+    </COMPUTE>
+  }
+
+  OCCI_ACTION = %q{
+    <COMPUTE>
+      <ID><%= id %></ID>
+      <STATE><%= strstate %></STATE>
+    </COMPUTE>
+  }
+
+  VM_STATES = {
+    "INIT"      => "START",
+    "PENDING"   => "PENDING",
+    "HOLD"      => "STOPPED",
+    "ACTIVE"    => "RUNNING",
+    "STOPPED"   => "STOPPED",
+    "SUSPENDED" => "STOPPED",
+    "DONE"      => "FINISHED",
+    "FAILED"    => "FINISHED"
+  }
 
-	stopped.to( :running )			.on( :start )
-	stopped.to( :finish )			.on( :destroy )
+  define_instance_states do
+    start.to(:pending)          .on( :create )
+    pending.to(:running)        .automatically
+    stopped.to(:running)        .on( :start )
+    running.to(:running)        .on( :reboot )
+    running.to(:stopping)       .on( :stop )
+    stopping.to(:stopped)       .automatically
+    running.to(:stopping)       .on( :destroy )
+    stopping.to(:finish)        .automatically
   end
 
-
   def instances(credentials, opts=nil)
-	occi_client = new_client(credentials)
+    occi_client = new_client(credentials)
 
-	instances = []
-	instancesxml = occi_client.get_vms
+    xml = treat_response(occi_client.get_vms)
 
-	computes = REXML::Document.new(instancesxml)
-	computes.root.elements.each do |d|
-		vm_id = d.attributes['href'].split("/").last
-
-		computexml = occi_client.get_vm(vm_id)
+    # TBD Add extended info in the pool
+    instances = REXML::Document.new(xml).root.elements.map do |d|
+      vm_id = d.attributes['href'].split("/").last
+      computexml = treat_response(occi_client.get_vm(vm_id))
+      convert_instance(computexml, credentials)
+    end
 
-		instances << convert_instance(computexml.to_s(), credentials)
-	end
-        instances = filter_on( instances, :id, opts )
-        instances = filter_on( instances, :state, opts )
-	instances
+    instances = filter_on( instances, :state, opts )
   end
 
+  def instance(credentials, opts=nil)
+    occi_client = new_client(credentials)
+    xml = treat_response(occi_client.get_vm(opts[:id]))
+    convert_instance(xml, credentials)
+  end
 
   def create_instance(credentials, image_id, opts=nil)
-	occi_client = new_client(credentials)
+    occi_client = new_client(credentials)
 
-	hwp_id = opts[:hwp_id] || 'small'
+    storage_href = "#{occi_client.endpoint}/storage/#{image_id}"
 
-	if not opts[:name]
-          opts[:name] = "#{Time.now.to_i.to_s}#{rand(9)}"
-        end
+    instancexml  = ERB.new(OCCI_VM).result(binding)
+    instancefile = "|echo '#{instancexml}'"
 
-	instancexml = ERB.new(OCCI_VM).result(binding)
-	instancefile = "|echo '#{instancexml}'"
+    # TBD Specify VNET in the template.
 
-	xmlvm = occi_client.post_vms(instancefile)
+    xmlvm = treat_response(occi_client.post_vms(instancefile))
 
-	convert_instance(xmlvm.to_s(), credentials)
+    convert_instance(xmlvm, credentials)
   end
 
-
   def start_instance(credentials, id)
-	occi_action(credentials, id, 'RESUME')
+    occi_action(credentials, id, 'RESUME')
   end
 
 
   def stop_instance(credentials, id)
-	occi_action(credentials, id, 'STOPPED')
+    occi_action(credentials, id, 'STOPPED')
   end
 
 
   def destroy_instance(credentials, id)
-	occi_action(credentials, id, 'DONE')
+    occi_action(credentials, id, 'DONE')
   end
 
-
+  def reboot_instance(credentials, id)
+    begin
+      occi_action(credentials, id, 'REBOOT')
+    rescue Exception => e
+      # TBD Check exception
+      # OpenNebula 3.0 support
+      raise "Reboot action not supported"
+    end
+  end
 
   private
 
   def new_client(credentials)
-	OCCIClient::Client.new(nil,	credentials.user, credentials.password, false)
+    OCCIClient::Client.new(api_provider, credentials.user, credentials.password, false)
   end
 
 
   def convert_image(diskxml, credentials)
-	disk = REXML::Document.new(diskxml)
-	diskhash = disk.root.elements
-
-	Image.new( {
-		:id=>diskhash['ID'].text,
-		:name=>diskhash['NAME'].text,
-		:description=>diskhash['NAME'].text,
-		:owner_id=>credentials.user,
-		:architecture=>'Any architecture',
-	} )
+    storage = REXML::Document.new(diskxml).root.elements
+
+    # TBD Add Image STATE, OWNER
+    Image.new( {
+      :id=>storage['ID'].text,
+      :name=>storage['NAME'].text,
+      :description=>storage['TYPE'].text,
+      :owner_id=>credentials.user,
+      :state=>"AVAILABLE",
+      :architecture=>storage['ARCH'],
+      :hardware_profiles=>hardware_profiles(credentials)
+    } )
   end
 
 
   def convert_instance(computexml, credentials)
-	compute = REXML::Document.new(computexml)
-	computehash = compute.root.elements
-
-	imageid = computehash['STORAGE/DISK[@type="disk"]'].attributes['href'].split("/").last
+    compute = REXML::Document.new(computexml)
+    computehash = compute.root.elements
 
-	state = (computehash['STATE'].text == "ACTIVE") ? "RUNNING" : "STOPPED"
+    network = []
+    computehash.each('NIC/IP') {|ip| network<<InstanceAddress.new(ip.text, :type => :ipv4)}
 
-	hwp_name = computehash['INSTANCE_TYPE'] || 'small'
-
-	networks = []
-	(computehash['NETWORK'].each do |n|
-		networks << InstanceAddress.new(n.attributes['ip'])
-	end) unless computehash['NETWORK'].nil?
+    image_id = nil
+    if computehash['DISK/STORAGE']
+      image_id = computehash['DISK/STORAGE'].attributes['href'].split("/").last
+    end
 
-	Instance.new( {
-		:id=>computehash['ID'].text,
-		:owner_id=>credentials.user,
-		:name=>computehash['NAME'].text,
-		:image_id=>imageid,
-		:instance_profile=>InstanceProfile.new(hwp_name),
-		:realm_id=>'Any realm',
-		:state=>state,
-		:public_addreses=>networks,
-		:private_addreses=>networks,
-		:actions=> instance_actions_for( state )
-	} )
+    Instance.new( {
+      :id=>computehash['ID'].text,
+      :owner_id=>credentials.user,
+      :name=>computehash['NAME'].text,
+      :image_id=>image_id,
+      :instance_profile=>InstanceProfile.new(computehash['INSTANCE_TYPE'].text||'small'),
+      :realm_id=>'ONE',
+      :state=>VM_STATES[computehash['STATE'].text],
+      :public_addresses=>network,
+      :private_addresses=>[],
+      :actions=> instance_actions_for( VM_STATES[computehash['STATE'].text] )
+    } )
   end
 
 
   def occi_action(credentials, id, strstate)
-	occi_client = new_client(credentials)
+    occi_client = new_client(credentials)
 
-	actionxml = ERB.new(OCCI_ACTION).result(binding)
-	actionfile = "|echo '#{actionxml}'"
+    actionxml = ERB.new(OCCI_ACTION).result(binding)
+    actionfile = "|echo '#{actionxml}'"
 
-	xmlvm = occi_client.put_vm(actionfile)
+    xmlvm = treat_response(occi_client.put_vm(actionfile))
 
-	convert_instance(xmlvm.to_s(), credentials)
+    convert_instance(xmlvm, credentials)
   end
 
 
-  (OCCI_VM = %q{
-	<COMPUTE>
-		<NAME><%=opts[:name]%></NAME>
-		<INSTANCE_TYPE><%= hwp_id %></INSTANCE_TYPE>
-		<STORAGE>
-			<DISK image="<%= image_id %>" dev="sda1" />
-		</STORAGE>
-	</COMPUTE>
-  }.gsub(/^        /, '') ) unless defined?( OCCI_VM )
+  def treat_response(res)
+    safely do
+      if CloudClient.is_error?(res)
+        raise case res.code
+              when "401" then "AuthenticationFailure"
+              when "404" then "ObjectNotFound"
+              else res.message
+              end
+      end
+    end
+    res
+  end
 
+  exceptions do
+    on /AuthenticationFailure/ do
+      status 401
+    end
 
-  (OCCI_ACTION = %q{
-	<COMPUTE>
-		<ID><%= id %></ID>
-		<STATE><%= strstate %></STATE>
-	</COMPUTE>
-  }.gsub(/^        /, '') ) unless defined?( OCCI_ACTION )
+    on /ObjectNotFound/ do
+      status 404
+    end
 
- end
+    on // do
+      status 502
+    end
+  end
+end
 
     end
   end

data/lib/deltacloud/drivers/openstack/openstack_driver.rb

@@ -14,34 +14,453 @@
 # under the License.
 #
 
-require 'deltacloud/drivers/rackspace/rackspace_driver.rb'
+require 'openstack'
+require 'tempfile'
+
 module Deltacloud
   module Drivers
     module Openstack
-      class OpenstackDriver < Rackspace::RackspaceDriver
+      class OpenstackDriver < Deltacloud::BaseDriver
 
         feature :instances, :user_name
         feature :instances, :authentication_password
         feature :instances, :user_files
+        feature :images, :user_name
 
         define_instance_states do
           start.to( :pending )          .on( :create )
           pending.to( :running )        .automatically
           running.to( :running )        .on( :reboot )
-          running.to( :shutting_down )  .on( :stop )
-          shutting_down.to( :stopped )  .automatically
+          running.to( :stopping )       .on( :stop )
+          stopping.to( :stopped )       .automatically
           stopped.to( :finish )         .automatically
         end
 
-        def new_client(credentials)
+        define_hardware_profile('default')
+
+        def hardware_profiles(credentials, opts = {})
+          os = new_client(credentials)
+          results = []
+          safely do
+            if opts[:id]
+              flavor = os.flavor(opts[:id])
+              results << convert_from_flavor(flavor)
+            else
+              results = os.flavors.collect do |f|
+                convert_from_flavor(f)
+              end
+            end
+            filter_hardware_profiles(results, opts)
+          end
+        end
+
+        def images(credentials, opts={})
+          os = new_client(credentials)
+          results = []
+          profiles = hardware_profiles(credentials)
+          safely do
+            if(opts[:id])
+              img = os.get_image(opts[:id])
+              results << convert_from_image(img, os.connection.authuser)
+            else
+              results = os.list_images.collect do |img|
+                convert_from_image(img, os.connection.authuser)
+              end
+            end
+          end
+          results.each do |img|
+            img.hardware_profiles = profiles
+          end
+          filter_on(results, :owner_id, opts)
+        end
+
+        def create_image(credentials, opts)
+          os = new_client(credentials)
+          safely do
+            server = os.get_server(opts[:id])
+            image_name = opts[:name] || "#{server.name}_#{Time.now}"
+            img = server.create_image(:name=>image_name)
+            convert_from_image(img, os.connection.authuser)
+          end
+        end
+
+        def destroy_image(credentials, image_id)
+          os = new_client(credentials)
+          begin
+            image = os.get_image(image_id)
+            image.delete!
+          rescue => e
+            raise Deltacloud::ExceptionHandler::BackendError.new(e, "ERROR: Cannot delete image with ID:#{image_id}.")
+          end
+        end
+
+        def realms(credentials, opts={})
+          os = new_client(credentials)
+          limits = ""
+          safely do
+            lim = os.limits
+              limits << "ABSOLUTE >> Max. Instances: #{lim[:absolute][:maxTotalInstances]} Max. RAM: #{lim[:absolute][:maxTotalRAMSize]}   ||   "
+              lim[:rate].each do |rate|
+                if rate[:regex] =~ /servers/
+                  limits << "SERVERS >> Total: #{rate[:limit].first[:value]}  Remaining: #{rate[:limit].first[:remaining]} Time Unit: per #{rate[:limit].first[:unit]}"
+                end
+              end
+          end
+          [ Realm.new( { :id=>'default',
+                        :name=>'default',
+                        :limit => limits,
+                        :state=>'AVAILABLE' })]
+        end
+
+        def instances(credentials, opts={})
+          os = new_client(credentials)
+          insts = []
+          safely do
+            if opts[:id]
+              server = os.get_server(opts[:id].to_i)
+              insts << convert_from_server(server, os.connection.authuser)
+            else
+              insts = os.list_servers_detail.collect do |server|
+                convert_from_server(server, os.connection.authuser)
+              end
+            end
+          end
+          insts = filter_on( insts, :state, opts )
+          insts
+        end
+
+        def create_instance(credentials, image_id, opts)
+          os = new_client( credentials )
+          result = nil
+#opts[:personality]: path1='server_path1'. content1='contents1', path2='server_path2', content2='contents2' etc
+          params = {}
+          params[:personality] = extract_personality(opts)
+          params[:name] = (opts[:name] && opts[:name].length>0)? opts[:name] : Time.now.to_s
+          params[:imageRef] = image_id
+          params[:flavorRef] =  (opts[:hwp_id] && opts[:hwp_id].length>0) ?
+                          opts[:hwp_id] : hardware_profiles(credentials).first.name
+          if opts[:password] && opts[:password].length > 0
+            params[:adminPass]=opts[:password]
+          end
+          safely do
+            server = os.create_server(params)
+            result = convert_from_server(server, os.connection.authuser)
+          end
+          result
+        end
+
+        def reboot_instance(credentials, instance_id)
+          os = new_client(credentials)
+          safely do
+            server = os.get_server(instance_id.to_i)
+            server.reboot! # sends a hard reboot (power cycle) - could instead server.reboot("SOFT")
+            convert_from_server(server, os.connection.authuser)
+          end
+        end
+
+        def destroy_instance(credentials, instance_id)
+          os = new_client(credentials)
+          safely do
+            server = os.get_server(instance_id.to_i)
+            server.delete!
+            convert_from_server(server, os.connection.authuser)
+          end
+        end
+
+        alias_method :stop_instance, :destroy_instance
+
+        def valid_credentials?(credentials)
+          begin
+            new_client(credentials)
+          rescue
+            return false
+          end
+          true
+        end
+
+        def buckets(credentials, opts={})
+          os = new_client(credentials, :buckets)
+          buckets = []
+          safely do
+            if opts[:id]
+              buckets << convert_bucket(os.container(opts[:id]))
+            else
+              os.containers.each{|bucket_name| buckets << convert_bucket(os.container(bucket_name))}
+            end
+          end
+          buckets
+        end
+
+        def create_bucket(credentials, name, opts={})
+          os = new_client(credentials, :buckets)
+          bucket = nil
+          safely do
+            bucket = os.create_container(name)
+          end
+          convert_bucket(bucket)
+        end
+
+        def delete_bucket(credentials, name, opts={})
+          os = new_client(credentials, :buckets)
+          safely do
+            os.delete_container(name)
+          end
+        end
+
+        def blobs(credentials, opts={})
+          os = new_client(credentials, :buckets)
+          blobs = []
+          safely do
+            bucket = os.container(opts['bucket'])
+            if(opts[:id])
+              blobs << convert_blob(bucket.object(opts[:id]), opts['bucket'])
+            else
+              bucket.objects_detail.each{|blob| blobs << convert_blob(blob, opts['bucket'])}
+            end
+          end
+          blobs
+        end
+
+        def blob_data(credentials, bucket, blob, opts={})
+          os = new_client(credentials, :buckets)
+          safely do
+            os.container(bucket).object(blob).data_stream do |chunk|
+              yield chunk
+            end
+          end
+        end
+
+        def create_blob(credentials, bucket, blob, data, opts={})
+          os = new_client(credentials, :buckets)
           safely do
-            CloudServers::Connection.new(:username => credentials.user, :api_key => credentials.password, :auth_url => api_provider)
+            BlobHelper.rename_metadata_headers(opts, "X-Object-Meta-")
+            os_blob = os.container(bucket).create_object(blob, {:content_type=> data[:type], :metadata=>opts}, data[:tempfile])
+            convert_blob(os_blob, bucket)
           end
         end
 
-        private :new_client
+        def delete_blob(credentials, bucket, blob, opts={})
+          os = new_client(credentials, :buckets)
+          safely do
+            os.container(bucket).delete_object(blob)
+          end
+        end
+
+        def blob_metadata(credentials, opts={})
+          os = new_client(credentials, :buckets)
+          safely do
+            os.container(opts['bucket']).object(opts[:id]).metadata
+          end
+        end
+
+        def update_blob_metadata(credentials, opts={})
+          os = new_client(credentials, :buckets)
+          safely do
+            BlobHelper.rename_metadata_headers(opts["meta_hash"], "")
+            blob = os.container(opts['bucket']).object(opts[:id])
+            blob.set_metadata(opts['meta_hash'])
+          end
+        end
+
+        #params: {:user,:password,:bucket,:blob,:content_type,:content_length,:metadata}
+        def blob_stream_connection(params)
+          tokens = params[:user].split("+")
+          user_name, tenant_name = tokens.first, tokens.last
+          #need a client for the auth_token and endpoints
+          os = OpenStack::Connection.create(:username => user_name, :api_key => params[:password], :authtenant => tenant_name, :auth_url => api_provider, :service_type => "object-store")
+          http = Net::HTTP.new(os.connection.service_host, os.connection.service_port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          path = os.connection.service_path + URI.encode("/#{params[:bucket]}/#{params[:blob]}")
+          request = Net::HTTP::Put.new(path)
+          request['X-Auth-Token'] = os.connection.authtoken
+          request['X-Storage-Token'] = os.connection.authtoken
+          request['Connection'] = "Keep-Alive"
+          request['Content-Type'] = params[:content_type]
+          request['Content-Length'] = params[:content_length]
+          request['Expect'] = "100-continue"
+          metadata = params[:metadata] || {}
+          BlobHelper::rename_metadata_headers(metadata, 'X-Object-Meta-')
+          metadata.each{|k,v| request[k] = v}
+          return http, request
+        end
+
+private
+
+        #for v2 authentication credentials.name == "username+tenant_name"
+        def new_client(credentials, type = :compute)
+          tokens = credentials.user.split("+")
+          if (tokens.size != 2 && api_v2)
+            raise ValidationFailure.new(Exception.new("Error: expected \"username+tenantname\" as username, you provided: #{credentials.user}"))
+          else
+            user_name, tenant_name = tokens.first, tokens.last
+          end
+          safely do
+              case type
+                when :compute
+                  OpenStack::Connection.create(:username => user_name, :api_key => credentials.password, :authtenant => tenant_name, :auth_url => api_provider)
+                when :buckets
+                  OpenStack::Connection.create(:username => user_name, :api_key => credentials.password, :authtenant => tenant_name, :auth_url => api_provider, :service_type => "object-store")
+                else
+                  raise ValidationFailure.new(Exception.new("Error: tried to initialise Openstack connection using" +
+                    " an unknown service_type: #{type}"))
+              end
+          end
+        end
+
+        def cloudfiles_client(credentials)
+          safely do
+            CloudFiles::Connection.new(:username => credentials.user, :api_key => credentials.password)
+          end
+        end
+
+#NOTE: for the convert_from_foo methods below... openstack-compute
+#gives Hash for 'flavors' but OpenStack::Compute::Flavor for 'flavor'
+#hence the use of 'send' to deal with both cases and save duplication
+
+        def convert_from_flavor(flavor)
+          op = (flavor.class == Hash)? :fetch : :send
+          HardwareProfile.new(flavor.send(op, :id).to_s) do
+            architecture 'x86_64'
+            memory flavor.send(op, :ram).to_i
+            storage flavor.send(op, :disk).to_i
+            cpu flavor.send(op, :vcpus).to_i
+          end
+        end
+
+        def convert_from_image(image, owner)
+          op = (image.class == Hash)? :fetch : :send
+          Image.new({
+                    :id => image.send(op, :id),
+                    :name => image.send(op, :name),
+                    :description => image.send(op, :name),
+                    :owner_id => owner,
+                    :state => image.send(op, :status),
+                    :architecture => 'x86_64'
+                    })
+        end
+
+        def convert_from_server(server, owner)
+          op = (server.class == Hash)? :fetch : :send
+          image = server.send(op, :image)
+          flavor = server.send(op, :flavor)
+          begin
+            password = server.send(op, :adminPass) || ""
+            rescue IndexError
+              password = ""
+          end
+          inst = Instance.new(
+            :id => server.send(op, :id).to_s,
+            :realm_id => 'default',
+            :owner_id => owner,
+            :description => server.send(op, :name),
+            :name => server.send(op, :name),
+            :state => convert_instance_state(server.send(op, :status).downcase),
+            :architecture => 'x86_64',
+            :image_id => image[:id] || image["id"],
+            :instance_profile => InstanceProfile::new(flavor[:id] || flavor["id"]),
+            :public_addresses => convert_server_addresses(server, :public),
+            :private_addresses => convert_server_addresses(server, :private),
+            :username => 'root',
+            :password => password
+          )
+          inst.actions = instance_actions_for(inst.state)
+          inst.create_image = 'RUNNING'.eql?(inst.state)
+          inst
+        end
+
+        def convert_instance_state(openstack_state)
+          case openstack_state
+            when /.*reboot/
+              "PENDING"
+            when /.*deleting/
+              "STOPPING"
+            when /.*deleted/
+              "STOPPED"
+            when /build.*$/
+              "PENDING"
+            when /active/
+              "RUNNING"
+            else
+              "UNKOWN"
+          end
+        end
+
+        def convert_server_addresses(server, type)
+          op, address_label = (server.class == Hash)? [:fetch, :addr] : [:send, :address]
+          addresses = (server.send(op, :addresses)[type] || []).collect do |addr|
+            type = (addr.send(op, :version) == 4)? :ipv4 : :ipv6
+            InstanceAddress.new(addr.send(op, address_label), {:type=>type} )
+          end
+        end
+
+        def convert_bucket(bucket)
+          Bucket.new({ :id => bucket.name,
+                       :name => bucket.name,
+                       :size => bucket.count,
+                       :blob_list => bucket.objects })
+        end
+
+        def convert_blob(blob, bucket_name)
+          op, blob_meta = (blob.class == Hash)? [:fetch, {}] : [:send, blob.metadata]
+          Blob.new({   :id => blob.send(op, :name),
+                       :bucket => bucket_name,
+                       :content_length => blob.send(op, :bytes),
+                       :content_type => blob.send(op, :content_type),
+                       :last_modified => blob.send(op, :last_modified),
+                       :user_metadata => blob_meta })
+        end
+
+        #IN: path1='server_path1'. content1='contents1', path2='server_path2', content2='contents2' etc
+        #OUT:{local_path=>server_path, local_path1=>server_path2 etc}
+        def extract_personality(opts)
+          personality_hash =  opts.inject({}) do |result, (opt_k,opt_v)|
+            if (opt_k.to_s =~ /^path([1-5]+)/ and opts[opt_k] != nil and opts[opt_k].length > 0)
+              unless opts[:"content#{$1}"].nil?
+                case opts[:"content#{$1}"]
+                  when String
+                    tempfile = Tempfile.new("os_personality_local_#{$1}")
+                    tempfile.write(opts[:"content#{$1}"])
+                    result[tempfile.path]=opts[:"path#{$1}"]
+                  when Hash
+                    result[opts[:"content#{$1}"][:tempfile].path]=opts[:"path#{$1}"]
+                end
+              end
+            end
+            result
+          end
+        end
+
+        def api_v2
+          if api_provider =~ /.*v2.0/
+            true
+          else
+            false
+          end
+        end
+
+        exceptions do
+
+          on /(Exception::BadRequest|PersonalityFilePathTooLong|PersonalityFileTooLarge|TooManyPersonalityItems)/ do
+            status 400
+          end
+
+          on /OpenStack::Exception::Authentication/ do
+            status 401
+          end
+
+          on /OpenStack::Exception::ItemNotFound/ do
+            status 404
+          end
+
+          on /Exception::Other/ do
+            status 500
+          end
+
+        end
+
+
       end
     end
   end
 end
-