deltacloud-core 0.1.2 → 0.3.0

data/lib/deltacloud/drivers/mock/data/instances/inst2.yml

@@ -7,3 +7,4 @@
 :realm_id: us
 :instance_profile: !ruby/object:InstanceProfile
   id: m1-large
+:create_image: true

data/lib/deltacloud/drivers/mock/data/storage_volumes/vol1.yml

@@ -1,4 +1,5 @@
 :owner_id: fedoraproject
+:realm_id: us
 :created: Thu Jul 30 14:35:11 UTC 2009
 :state: AVAILABLE
 :capacity: 1

data/lib/deltacloud/drivers/mock/data/storage_volumes/vol2.yml

@@ -1,4 +1,5 @@
 :owner_id: mockuser
+:realm_id: us
 :created: Thu Jul 30 14:35:11 UTC 2009
 :state: AVAILABLE
 :capacity: 1

data/lib/deltacloud/drivers/mock/data/storage_volumes/vol3.yml

@@ -1,4 +1,5 @@
 :owner_id: mockuser
+:realm_id: us
 :created: Thu Jul 30 14:35:11 UTC 2009
 :state: IN-USE
 :capacity: 1

data/lib/deltacloud/drivers/mock/mock_driver.rb

@@ -1,6 +1,4 @@
 #
-# Copyright (C) 2009, 2010  Red Hat, Inc.
-#
 # 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
@@ -25,8 +23,15 @@ module Deltacloud
     module Mock
 class MockDriver < Deltacloud::BaseDriver
 
+  # If the provider is set to storage, pretend to be a storage-only
+  # driver
   def supported_collections
-    DEFAULT_COLLECTIONS + [ :buckets, :keys]
+    endpoint = Thread.current[:provider] || ENV['API_PROVIDER']
+    if endpoint == 'storage'
+      [:buckets]
+    else
+      DEFAULT_COLLECTIONS + [:buckets, :keys]
+    end
   end
 
   ( REALMS = [
@@ -128,6 +133,33 @@ class MockDriver < Deltacloud::BaseDriver
     images.sort_by{|e| [e.owner_id,e.description]}
   end
 
+  def create_image(credentials, opts={})
+    check_credentials(credentials)
+    instance = instance(credentials, :id => opts[:instance_id])
+    raise BackendError::new(500, 'CreateImageNotSupported', '', '') unless instance.can_create_image?
+    ids = Dir[ "#{@storage_root}/images/*.yml" ].collect{|e| File.basename( e, ".yml" )}
+    count = 0
+    while true
+      next_id = "img#{count}"
+      break if not ids.include?(next_id)
+      count += 1
+    end
+    safely do
+      image = {
+	:name => opts[:name],
+	:owner_id => 'root',
+	:description => opts[:description],
+	:architecture => 'i386',
+	:state => 'UP'
+      }
+      File.open( "#{@storage_root}/images/#{next_id}.yml", 'w' ) do |f|
+	YAML.dump( image, f )
+      end
+      image[:id] = next_id
+      Image.new(image)
+    end
+  end
+
   #
   # Instances
   #
@@ -190,6 +222,7 @@ class MockDriver < Deltacloud::BaseDriver
       :private_addresses=>["#{image_id}.#{next_id}.private.com"],
       :instance_profile => InstanceProfile.new(hwp.name, opts),
       :realm_id=>realm_id,
+      :create_image=>true,
       :actions=>instance_actions_for( 'RUNNING' )
     }
     File.open( "#{@storage_root}/instances/#{next_id}.yml", 'w' ) {|f|
@@ -311,73 +344,145 @@ class MockDriver < Deltacloud::BaseDriver
 #--
 # Buckets
 #--
-  def buckets(credentials, opts=nil)
+  def buckets(credentials, opts={})
     check_credentials(credentials)
     buckets=[]
-     Dir[ "#{@storage_root}/buckets/*.yml" ].each do |bucket_file|
-      bucket = YAML.load( File.read( bucket_file ) )
-      bucket[:id] = File.basename( bucket_file, ".yml" )
-      bucket[:name] = bucket[:id]
-      buckets << Bucket.new( bucket )
+    safely do
+      unless (opts[:id].nil?)
+        bucket_file = File::join(@storage_root, 'buckets', "#{opts[:id]}.yml") 
+        bucket = YAML.load_file(bucket_file)
+        bucket[:id] = opts[:id]
+        bucket[:name] = bucket[:id]
+        buckets << Bucket.new( bucket )
+      else
+         Dir[ File::join(@storage_root, 'buckets', '*.yml')].each do |bucket_file|
+          bucket_id = File.basename( bucket_file, ".yml" )
+          buckets << Bucket.new( {:id => bucket_id, :name => bucket_id } )
+        end
+      end
     end
     buckets = filter_on( buckets, :id, opts )
-    buckets
   end
 
 #--
 # Create bucket
 #--
-  def create_bucket(credentials, name, opts=nil)
+  def create_bucket(credentials, name, opts={})
     check_credentials(credentials)
     bucket = {
+      :id => name,
       :name=>name,
       :size=>'0',
       :blob_list=>[]
     }
-    File.open( "#{@storage_root}/buckets/#{name}.yml", 'w' ) {|b| YAML.dump( bucket, b )}
+    File.open( File::join(@storage_root, 'buckets', "#{name}.yml"), 'w') {|b| YAML.dump( bucket, b )}
     Bucket.new(bucket)
   end
 
 #--
 # Delete bucket
 #--
-  def delete_bucket(credentials, name, opts=nil)
+  def delete_bucket(credentials, name, opts={})
+    check_credentials(credentials)
     bucket = bucket(credentials, {:id => name})
     unless (bucket.size == "0")
      raise Deltacloud::BackendError.new(403, self.class.to_s, "bucket-not-empty", "delete operation not valid for non-empty bucket")
     end
     safely do
-      File.delete("#{@storage_root}/buckets/#{name}.yml")
+      File.delete(File::join(@storage_root, 'buckets', "#{name}.yml"))
     end
   end
 
 #--
 # Blobs
 #--
-  def blobs(credentials, opts = nil)
+  def blobs(credentials, opts = {})
     check_credentials(credentials)
     blobs=[]
-    Dir[ "#{@storage_root}/buckets/blobs/*.yml" ].each do |blob_file|
-      blob = YAML.load( File.read( blob_file ) )
-      blob[:id] = File.basename( blob_file, ".yml" )
+    blobfile = File::join("#{@storage_root}", "buckets", "blobs", "#{opts[:id]}.yml")
+    safely do
+      blob = YAML.load_file(blobfile)
+      return [] unless blob[:bucket] == opts['bucket'] #can't return nil since base_driver invokes .first on return
+      blob[:id] = File.basename( blobfile, ".yml" )
       blob[:name] = blob[:id]
       blobs << Blob.new( blob )
+      blobs = filter_on( blobs, :id, opts )
     end
-    blobs = filter_on( blobs, :id, opts )
-    blobs
   end
 
 #--
 # Blob content
 #--
-  def blob_data(credentials, bucket_id, blob_id, opts = nil)
+  def blob_data(credentials, bucket_id, blob_id, opts = {})
     check_credentials(credentials)
     blob=nil
-    Dir[ "#{@storage_root}/buckets/blobs/*.yml" ].each do |blob_file|
-      if File.basename(blob_file, ".yml") == blob_id
-        blob = YAML.load(File.read(blob_file))
-        blob[:content].each {|part| yield part}
+    safely do
+      blobfile = File::join("#{@storage_root}", "buckets", "blobs", "#{opts['blob']}.yml")
+      blob = YAML.load_file(blobfile)
+    end
+    blob[:content].each {|part| yield part}
+  end
+
+#--
+# Create blob
+#--
+  def create_blob(credentials, bucket_id, blob_id, blob_data, opts={})
+    check_credentials(credentials)
+      blob_meta = {}
+      opts.inject({}){|result, (k,v)| blob_meta[k] = v if k.match(/X[_-]Deltacloud[_-]Blobmeta[_-]/i)} #select{|k,v| k.match(/X[_-]Deltacloud[_-]Blobmeta[_-]/i)}
+       blob = {
+      :id => blob_id,
+      :bucket => bucket_id,
+      :content_length => blob_data[:tempfile].length,
+      :content_type => blob_data[:type],
+      :last_modified => Time.now,
+      :user_metadata => blob_meta.gsub_keys('X_Deltacloud_Blobmeta_', ''),
+      :content => blob_data[:tempfile].read
+    }
+    File.open( File::join("#{@storage_root}", "buckets", "blobs", "#{blob_id}.yml"), 'w' ) {|b| YAML.dump( blob, b )}
+    Blob.new(blob)
+  end
+
+#--
+# Delete blob
+#--
+  def delete_blob(credentials, bucket_id, blob_id, opts={})
+    check_credentials(credentials)
+    blobfile = File::join("#{@storage_root}", "buckets", "blobs", "#{blob_id}.yml")
+    safely do
+      unless File.exists?(blobfile)
+        raise Deltacloud::BackendError.new(500, self.class.to_s, "blob #{blob_id} doesn't exist", "cannot delete non existant blob")
       end
+      File.delete(blobfile)
+    end
+  end
+
+#--
+# Get metadata
+#--
+  def blob_metadata(credentials, opts={})
+    check_credentials(credentials)
+    blobfile = File::join("#{@storage_root}", "buckets", "blobs", "#{opts[:id]}.yml")
+    #safely do - mechanism not suitable here since head requests don't return a body response
+    begin
+      blob = YAML.load_file(blobfile)
+    rescue Errno::ENOENT
+      return nil #server.rb picks this up and gives 404
+    end
+    blob[:user_metadata]
+  end
+
+#--
+# Update metadata
+#--
+  def update_blob_metadata(credentials, opts={})
+    check_credentials(credentials)
+    blobfile = File::join("#{@storage_root}", "buckets", "blobs", "#{opts[:id]}.yml")
+    safely do
+      blob = YAML.load_file(blobfile)
+      return false unless blob
+      blob[:user_metadata] = opts['meta_hash'].gsub_keys('HTTP[-_]X[-_]Deltacloud[-_]Blobmeta[-_]', '')
+      File.open(File::join("#{@storage_root}", "buckets", "blobs", "#{opts[:id]}.yml"), 'w' ) {|b| YAML.dump( blob, b )}
     end
   end
 
@@ -393,15 +498,18 @@ class MockDriver < Deltacloud::BaseDriver
   private
 
   def check_credentials(credentials)
-    if ( credentials.user != 'mockuser' )
-      raise Deltacloud::AuthException.new
-    end
-
-    if ( credentials.password != 'mockpassword' )
+    if ( credentials.user != 'mockuser' ) or ( credentials.password != 'mockpassword' )
       raise Deltacloud::AuthException.new
     end
   end
 
+  def catched_exceptions_list
+    {
+      :auth => [],
+      :error => [ /Deltacloud::BackendError/, /Errno::ENOENT/ ],
+      :glob => [ /Error/ ]
+    }
+  end
 
 end
 

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

@@ -1,21 +1,19 @@
-#--------------------------------------------------------------------------- #
-# Copyright 2002-2009, Distributed Systems Architecture Group, Universidad
-# Complutense de Madrid (dsa-research.org)
 #
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
+# 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
 #
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
+#       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.
 #
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
-#--------------------------------------------------------------------------- #
 
 require 'rubygems'
 require 'uri'

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

@@ -1,21 +1,19 @@
-#--------------------------------------------------------------------------- #
-# Copyright 2002-2009, Distributed Systems Architecture Group, Universidad
-# Complutense de Madrid (dsa-research.org)
 #
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
+# 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
 #
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
+#       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.
 #
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
-#--------------------------------------------------------------------------- #
 
 require 'rubygems'
 require 'uri'

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

@@ -1,21 +1,19 @@
-#--------------------------------------------------------------------------- #
-# Copyright 2002-2009, Distributed Systems Architecture Group, Universidad
-# Complutense de Madrid (dsa-research.org)
 #
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
+# 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
 #
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
+#       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.
 #
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
-#--------------------------------------------------------------------------- #
 
 require 'deltacloud/base_driver'
 

data/lib/deltacloud/drivers/rackspace/rackspace_driver.rb

@@ -1,6 +1,4 @@
 #
-# Copyright (C) 2009  Red Hat, Inc.
-#
 # 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
@@ -17,8 +15,9 @@
 # under the License.
 
 require 'deltacloud/base_driver'
-require 'deltacloud/drivers/rackspace/rackspace_client'
 require 'cloudfiles'
+require 'cloudservers'
+require 'base64'
 
 module Deltacloud
   module Drivers
@@ -27,20 +26,22 @@ module Deltacloud
 class RackspaceDriver < Deltacloud::BaseDriver
 
   feature :instances, :user_name
+  feature :instances, :authentication_password
+  feature :instances, :user_files
 
   def supported_collections
-    DEFAULT_COLLECTIONS + [ :buckets ]
+    DEFAULT_COLLECTIONS + [ :buckets ] - [ :storage_snapshots, :storage_volumes ]
   end
 
-  def hardware_profiles(credentials, opts = nil)
-    racks = new_client( credentials )
-    results=""
+  def hardware_profiles(credentials, opts = {})
+    rs = new_client( credentials )
+    results = []
     safely do
-      results = racks.list_flavors.map do |flav|
-        HardwareProfile.new(flav["id"].to_s) do
+      results = rs.list_flavors.collect do |f|
+        HardwareProfile.new(f[:id].to_s) do
           architecture 'x86_64'
-          memory flav["ram"].to_i
-          storage flav["disk"].to_i
+          memory f[:ram].to_i
+          storage f[:disk].to_i
         end
       end
     end
@@ -48,22 +49,21 @@ class RackspaceDriver < Deltacloud::BaseDriver
   end
 
   def images(credentials, opts=nil)
-    racks = new_client( credentials )
-    results=""
+    rs = new_client(credentials)
+    results = []
     safely do
-      results = racks.list_images.map do |img|
-        Image.new( {
-                     :id=>img["id"].to_s,
-                     :name=>img["name"],
-                     :description => img["name"] + " " + img["status"] + "",
-                     :owner_id=>"root",
-                     :architecture=>'x86_64'
-                   } )
+      results = rs.list_images.collect do |img|
+        Image.new(
+          :id => img[:id].to_s,
+          :name => img[:name],
+          :description => img[:name],
+          :owner_id => credentials.user,
+          :state => img[:status],
+          :architecture => 'x86_64'
+        )
       end
     end
-    results.sort_by{|e| [e.description]}
-    results = filter_on( results, :id, opts )
-    results
+    filter_on( results, :id, opts )
   end
 
   #rackspace does not at this stage have realms... its all US/TX, all the time (at least at time of writing)
@@ -75,67 +75,99 @@ class RackspaceDriver < Deltacloud::BaseDriver
     } )]
   end
 
-  def reboot_instance(credentials, id)
-    racks = new_client(credentials)
+  #
+  # create instance. Default to flavor 1 - really need a name though...
+  # In rackspace, all flavors work with all images.
+  #
+  def create_instance(credentials, image_id, opts)
+    rs = new_client( credentials )
+    result = nil
+    params = extract_personality(opts)
+    params[:name] = opts[:name] || Time.now.to_s
+    params[:imageId] = image_id.to_i
+    params[:flavorId] = (opts[:hwp_id] && opts[:hwp_id].length>0) ? opts[:hwp_id].to_i : 1
     safely do
-      racks.reboot_server(id)
+      server = rs.create_server(params)
+      result = convert_instance_after_create(server, credentials.user, server.adminPass)
     end
-    Instance.new( {
-      :id => id,
-      :state => "RUNNING",
-      :actions => instance_actions_for( "RUNNING" ),
-    } )
+    result
   end
 
-  def stop_instance(credentials, id)
-    destroy_instance(credentials, id)
+  def create_image(credentials, opts={})
+    rs = new_client(credentials)
+    safely do
+      server = rs.get_server(opts[:id].to_i)
+      image = server.create_image(opts[:name])
+      Image.new(
+        :id => image.id.to_s,
+        :name => image.name,
+        :description => image.name,
+        :owner_id => credentials.user,
+        :state => image.status,
+        :architecture => 'x86_64'
+      )
+    end
   end
 
-  def destroy_instance(credentials, id)
-    racks = new_client(credentials)
+  def run_on_instance(credentials, opts={})
+    target = instance(credentials, :id => opts[:id])
+    param = {}
+    param[:credentials] = {
+      :username => 'root',
+      :password => opts[:password]
+    }
+    param[:port] = opts[:port] || '22'
+    param[:ip] = target.public_addresses.first
     safely do
-      racks.delete_server(id)
+      Deltacloud::Runner.execute(opts[:cmd], param)
     end
-    Instance.new( {
-      :id => id,
-      :state => "STOPPED",
-      :actions => instance_actions_for( "STOPPED" ),
-    } )
   end
 
+  def reboot_instance(credentials, instance_id)
+    rs = new_client(credentials)
+    safely do
+      server = rs.get_server(instance_id.to_i)
+      server.reboot!
+      convert_instance_after_create(server, credentials.user)
+    end
+  end
 
-  #
-  # create instance. Default to flavor 1 - really need a name though...
-  # In rackspace, all flavors work with all images.
-  #
-  def create_instance(credentials, image_id, opts)
-    racks = new_client( credentials )
-    hwp_id = opts[:hwp_id] || 1
-    name = Time.now.to_s
-    if (opts[:name]) then name = opts[:name] end
+  def destroy_instance(credentials, instance_id)
+    rs = new_client(credentials)
     safely do
-      return convert_srv_to_instance(racks.start_server(image_id, hwp_id, name))
+      server = rs.get_server(instance_id.to_i)
+      server.delete!
+      convert_instance_after_create(server, credentials.user)
     end
   end
 
+  alias_method :stop_instance, :destroy_instance
+
   #
   # Instances
   #
-  def instances(credentials, opts=nil)
-    racks = new_client(credentials)
-    instances = []
+  def instances(credentials, opts={})
+
+    rs = new_client(credentials)
+    insts = []
+
     safely do
-      if (opts.nil?)
-        instances = racks.list_servers.map do |srv|
-          convert_srv_to_instance(srv)
+      begin
+        if opts[:id]
+          server = rs.get_server(opts[:id].to_i)
+          insts << convert_instance_after_create(server, credentials.user)
+        else
+          insts = rs.list_servers_detail.collect do |server|
+            convert_instance(server, credentials.user)
+          end
         end
-      else
-        instances << convert_srv_to_instance(racks.load_server_details(opts[:id]))
+      rescue CloudServers::Exception::ItemNotFound
       end
     end
-    instances = filter_on( instances, :id, opts )
-    instances = filter_on( instances, :state, opts )
-    instances
+
+    insts = filter_on( insts, :id, opts )
+    insts = filter_on( insts, :state, opts )
+    insts
   end
 
   def valid_credentials?(credentials)
@@ -147,42 +179,38 @@ class RackspaceDriver < Deltacloud::BaseDriver
     true
   end
 
-
-
-
   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
-
     stopped.to( :finish )         .automatically
   end
 
 #--
 # Buckets
 #--
-  def buckets(credentials, opts)
+  def buckets(credentials, opts = {})
     bucket_list = []
     cf = cloudfiles_client(credentials)
     safely do
-      cf.containers.each do |container_name|
-        current = cf.container(container_name)
-        bucket_list << convert_container(current)
-      end #containers.each
+      unless (opts[:id].nil?)
+        bucket = cf.container(opts[:id])
+        bucket_list << convert_container(bucket)
+      else
+        cf.containers.each do |container_name|
+          bucket_list << Bucket.new({:id => container_name, :name => container_name})
+        end #containers.each
+      end #unless
     end #safely
-    bucket_list = filter_on(bucket_list, :id, opts)
-    bucket_list
+    filter_on(bucket_list, :id, opts)
   end
 
 #--
 # Create Bucket
 #--
-  def create_bucket(credentials, name, opts)
+  def create_bucket(credentials, name, opts = {})
     bucket = nil
     cf = cloudfiles_client(credentials)
     safely do
@@ -195,7 +223,7 @@ class RackspaceDriver < Deltacloud::BaseDriver
 #--
 # Delete Bucket
 #--
-  def delete_bucket(credentials, name, opts)
+  def delete_bucket(credentials, name, opts = {})
     cf = cloudfiles_client(credentials)
     safely do
       cf.delete_container(name)
@@ -205,7 +233,7 @@ class RackspaceDriver < Deltacloud::BaseDriver
 #--
 # Blobs
 #--
-  def blobs(credentials, opts)
+  def blobs(credentials, opts = {})
     cf = cloudfiles_client(credentials)
     blobs = []
     safely do
@@ -221,7 +249,7 @@ class RackspaceDriver < Deltacloud::BaseDriver
 #-
 # Blob data
 #-
-  def blob_data(credentials, bucket_id, blob_id, opts)
+  def blob_data(credentials, bucket_id, blob_id, opts = {})
     cf = cloudfiles_client(credentials)
     cf.container(bucket_id).object(blob_id).data_stream do |chunk|
       yield chunk
@@ -231,18 +259,25 @@ class RackspaceDriver < Deltacloud::BaseDriver
 #--
 # Create Blob
 #--
-  def create_blob(credentials, bucket_id, blob_id, blob_data, opts=nil)
+  def create_blob(credentials, bucket_id, blob_id, blob_data, opts={})
     cf = cloudfiles_client(credentials)
-    #must first create the object using cloudfiles_client.create_object
-    #then can write using object.write(data)
-    object = cf.container(bucket_id).create_object(blob_id)
-    #blob_data is a construct with data in .tempfile and content-type in {:type}
-    res = object.write(blob_data[:tempfile], {'Content-Type' => blob_data[:type]})
+    #insert ec2-specific header for user metadata ... X-Object-Meta-KEY = VALUE
+    opts.gsub_keys("HTTP_X_Deltacloud_Blobmeta_", "X-Object-Meta-")
+    opts['Content-Type'] = blob_data[:type]
+    object = nil
+    safely do
+      #must first create the object using cloudfiles_client.create_object
+      #then can write using object.write(data)
+      object = cf.container(bucket_id).create_object(blob_id)
+      #blob_data is a construct with data in .tempfile and content-type in {:type}
+      res = object.write(blob_data[:tempfile], opts)
+    end
     Blob.new( { :id => object.name,
                 :bucket => object.container.name,
                 :content_length => blob_data[:tempfile].length,
                 :content_type => blob_data[:type],
-                :last_modified => ''
+                :last_modified => '',
+                :user_metadata => opts.select{|k,v| k.match(/^X-Object-Meta-/i)}
               }
             )
   end
@@ -250,32 +285,45 @@ class RackspaceDriver < Deltacloud::BaseDriver
 #--
 # Delete Blob
 #--
-  def delete_blob(credentials, bucket_id, blob_id, opts=nil)
+  def delete_blob(credentials, bucket_id, blob_id, opts={})
+    cf = cloudfiles_client(credentials)
+    safely do
+      cf.container(bucket_id).delete_object(blob_id)
+    end
+  end
+
+#-
+# Blob Metadada
+#-
+  def blob_metadata(credentials, opts = {})
+    cf = cloudfiles_client(credentials)
+    meta = {}
+    safely do
+      meta = cf.container(opts['bucket']).object(opts[:id]).metadata
+    end
+    meta
+  end
+
+#-
+# Update Blob Metahash
+#-
+  def update_blob_metadata(credentials, opts={})
     cf = cloudfiles_client(credentials)
-    cf.container(bucket_id).delete_object(blob_id)
+    meta_hash = opts['meta_hash']
+    #the set_metadata method actually places the 'X-Object-Meta-' prefix for us:
+    meta_hash.gsub_keys('HTTP_X_Deltacloud_Blobmeta_', '')
+    safely do
+      blob = cf.container(opts['bucket']).object(opts[:id])
+      blob.set_metadata(meta_hash)
+    end 
   end
 
 private
 
-  def convert_srv_to_instance(srv)
-    inst = Instance.new(:id => srv["id"].to_s,
-                        :owner_id => "root",
-                        :realm_id => "us")
-    inst.name = srv["name"]
-    inst.state = srv["status"] == "ACTIVE" ? "RUNNING" : "PENDING"
-    inst.actions = instance_actions_for(inst.state)
-    inst.image_id = srv["imageId"].to_s
-    inst.instance_profile = InstanceProfile.new(srv["flavorId"].to_s)
-    if srv["addresses"]
-      inst.public_addresses  = srv["addresses"]["public"]
-      inst.private_addresses = srv["addresses"]["private"]
-    end
-    inst
-  end
 
   def new_client(credentials)
     safely do
-      return RackspaceClient.new(credentials.user, credentials.password)
+      CloudServers::Connection.new(:username => credentials.user, :api_key => credentials.password)
     end
   end
 
@@ -292,24 +340,87 @@ private
                  :bucket => cf_object.container.name,
                  :content_length => cf_object.bytes,
                  :content_type => cf_object.content_type,
-                 :last_modified => cf_object.last_modified
+                 :last_modified => cf_object.last_modified,
+                 :user_metadata => cf_object.metadata
               })
   end
 
+  def convert_instance_after_create(server, user_name, password='')
+    inst = Instance.new(
+      :id => server.id.to_s,
+      :realm_id => 'us',
+      :owner_id => user_name,
+      :description => server.name,
+      :name => server.name,
+      :state => (server.status == 'ACTIVE') ? 'RUNNING' : 'PENDING',
+      :architecture => 'x86_64',
+      :image_id => server.imageId.to_s,
+      :instance_profile => InstanceProfile::new(server.flavorId.to_s),
+      :public_addresses => server.addresses[:public],
+      :private_addresses => server.addresses[:private],
+      :username => 'root',
+      :password => password ? password : nil
+    )
+    inst.actions = instance_actions_for(inst.state)
+    inst.create_image = 'RUNNING'.eql?(inst.state)
+    inst
+  end
+
+  def convert_instance(server, user_name = '')
+    inst = Instance.new(
+      :id => server[:id].to_s,
+      :realm_id => 'us',
+      :owner_id => user_name,
+      :description => server[:name],
+      :name => server[:name],
+      :state => (server[:status] == 'ACTIVE') ? 'RUNNING' : 'PENDING',
+      :architecture => 'x86_64',
+      :image_id => server[:imageId].to_s,
+      :instance_profile => InstanceProfile::new(server[:flavorId].to_s),
+      :public_addresses => server[:addresses][:public],
+      :private_addresses => server[:addresses][:private]
+    )
+    inst.create_image = 'RUNNING'.eql?(inst.state)
+    inst.actions = instance_actions_for(inst.state)
+    inst
+  end
+
   def cloudfiles_client(credentials)
     safely do
       CloudFiles::Connection.new(:username => credentials.user, :api_key => credentials.password)
     end
   end
 
-  def safely(&block)
-    begin
-      block.call
-    rescue Exception => e
-      raise Deltacloud::BackendError.new(500, e.class.to_s, e.message, e.backtrace)
-    end
+  def catched_exceptions_list
+    {
+      :auth => [ /Authentication failed/ ],
+      :error => [ /Error/ ],
+      :glob => [ /CloudServers::Exception::(\w+)/, /Deltacloud::Runner::(\w+)/ ]
+    }
   end
 
+  private
+
+  def extract_personality(opts)
+    # This relies on an undocumented feature of the cloudservers gem:
+    # create_server allows passing in strings for the file contents
+    # directly if :personality maps to an array of hashes
+    ary = opts.inject([]) do |a, e|
+      k, v = e
+      if k.to_s =~ /^path([0-9]+)/
+        a << {
+          :path => v,
+          :contents => Base64.decode64(opts[:"content#{$1}"])
+        }
+      end
+      a
+    end
+    if ary.empty?
+      {}
+    else
+      { :personality => ary }
+    end
+  end
 end
 
     end