deltacloud-core 0.3.0 → 0.4.0

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

@@ -1,10 +1,17 @@
-:name: MockUserInstance
-:state: RUNNING
-:image_id: img3
-:owner_id: mockuser
-:public_addresses: [ img3.inst1.public.com ]
-:private_addresses: [ img3.inst1.private.com ]
-:realm_id: us
+---
 :instance_profile: !ruby/object:InstanceProfile
   id: m1-small
+:realm_id: us
+:owner_id: mockuser
+:public_addresses:
+- img3.inst1.public.com
+:private_addresses:
+- img3.inst1.private.com
 :create_image: true
+:image_id: img3
+:name: MockUserInstance
+:id: inst1
+:state: RUNNING
+:actions:
+- :reboot
+- :stop

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

@@ -1,10 +1,17 @@
-:name: AnotherInstance
-:state: RUNNING
-:image_id: img1
-:owner_id: anotheruser
-:public_addresses: [ img1.inst2.public.com ]
-:private_addresses: [ img1.inst2.private.com ]
-:realm_id: us
+---
 :instance_profile: !ruby/object:InstanceProfile
   id: m1-large
+:realm_id: us
+:owner_id: anotheruser
+:public_addresses:
+- img1.inst2.public.com
+:private_addresses:
+- img1.inst2.private.com
 :create_image: true
+:image_id: img1
+:name: AnotherInstance
+:id: inst2
+:state: RUNNING
+:actions:
+- :reboot
+- :stop

data/lib/deltacloud/drivers/mock/data/storage_snapshots/snap1.yml

@@ -1,4 +1,5 @@
-:owner_id: fedoraproject
+---
 :created: Wed Jul 29 18:15:24 UTC 2009
-:state: COMPLETED
 :storage_volume_id: vol1
+:id: snap1
+:state: COMPLETED

data/lib/deltacloud/drivers/mock/data/storage_snapshots/snap2.yml

@@ -1,4 +1,5 @@
-:owner_id: mockuser
+---
 :created: Wed Jul 29 18:15:24 UTC 2009
-:state: COMPLETED
 :storage_volume_id: vol2
+:id: snap2
+:state: COMPLETED

data/lib/deltacloud/drivers/mock/data/storage_snapshots/snap3.yml

@@ -1,4 +1,5 @@
-:owner_id: mockuser
+---
 :created: Wed Jul 29 18:15:24 UTC 2009
-:state: COMPLETED
 :storage_volume_id: vol2
+:id: snap3
+:state: COMPLETED

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

@@ -1,7 +1,8 @@
-:owner_id: fedoraproject
+---
 :realm_id: us
-:created: Thu Jul 30 14:35:11 UTC 2009
-:state: AVAILABLE
 :capacity: 1
 :device:
+:created: Thu Jul 30 14:35:11 UTC 2009
 :instance_id:
+:id: vol1
+:state: AVAILABLE

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

@@ -1,7 +1,8 @@
-:owner_id: mockuser
+---
 :realm_id: us
-:created: Thu Jul 30 14:35:11 UTC 2009
-:state: AVAILABLE
 :capacity: 1
 :device:
+:created: Thu Jul 30 14:35:11 UTC 2009
 :instance_id:
+:id: vol2
+:state: AVAILABLE

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

@@ -1,7 +1,8 @@
-:owner_id: mockuser
+---
 :realm_id: us
-:created: Thu Jul 30 14:35:11 UTC 2009
-:state: IN-USE
 :capacity: 1
 :device: /dev/sda1
+:created: Thu Jul 30 14:35:11 UTC 2009
 :instance_id: inst1
+:id: vol3
+:state: IN-USE

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

@@ -0,0 +1,101 @@
+#
+# 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.
+
+# The mock client does a bunch of filesystem judo. It's mostly there to
+# keep the driver from looking too ugly with all the File I/O
+
+module Deltacloud::Drivers::Mock
+
+  class Client
+    def initialize(storage_root)
+      @storage_root = storage_root
+      @collections = []
+
+      if ! File::directory?(@storage_root)
+        FileUtils::rm_rf(@storage_root)
+        FileUtils::mkdir_p(@storage_root)
+        data = Dir[File::join(File::dirname(__FILE__), "data", "*")]
+        FileUtils::cp_r(data, @storage_root)
+      end
+    end
+
+    def dir(collection)
+      result = File::join(@storage_root, collection.to_s)
+      unless @collections.include?(collection)
+        FileUtils::mkdir_p(result) unless File::directory?(result)
+        @collections << collection
+      end
+      result
+    end
+
+    def file(collection, id)
+      File::join(dir(collection), "#{id}.yml")
+    end
+
+    def files(collection)
+      Dir[File::join(dir(collection), "*.yml")]
+    end
+
+    # Return the ID's of all members of +collection+
+    def members(collection)
+      files(collection).map { |f| File::basename(f, ".yml") }
+    end
+
+    def load(collection, id)
+      fname = file(collection, id)
+      begin
+        YAML.load(File.read(fname))
+      rescue Errno::ENOENT
+        nil
+      end
+    end
+
+    def store(collection, obj)
+      raise "Why no obj[:id] ?" unless obj[:id]
+      File::open(file(collection, obj[:id]), "w") { |f| YAML.dump(obj, f) }
+    end
+
+    # Return the object with id +id+ of class +klass+ from the collection
+    # derived from the classes name
+    def build(klass, id)
+      klass.new(load(collection_name(klass), id))
+    end
+
+    # Return an array of hashes of all the resources in the collection
+    def load_all(collection)
+      members(collection).map { |id| load(collection, id) }
+    end
+
+    # Return an array of model objects of the resources in the collection
+    # corresponding to class. The name of the collection is derived from
+    # the name of the class
+    def build_all(klass)
+      load_all(collection_name(klass)).map { |hash| klass.new(hash) }
+    end
+
+    def destroy(collection, id)
+      fname = file(collection, id)
+      FileUtils.rm(fname) if File::exists?(fname)
+    end
+
+    private
+
+    def collection_name(klass)
+      klass.name.underscore.pluralize
+    end
+  end
+
+end

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

@@ -17,502 +17,440 @@
 
 require 'deltacloud/base_driver'
 require 'yaml'
+require 'deltacloud/drivers/mock/mock_client'
 
-module Deltacloud
-  module Drivers
-    module Mock
-class MockDriver < Deltacloud::BaseDriver
+module Deltacloud::Drivers::Mock
 
-  # If the provider is set to storage, pretend to be a storage-only
-  # driver
-  def supported_collections
-    endpoint = Thread.current[:provider] || ENV['API_PROVIDER']
-    if endpoint == 'storage'
-      [:buckets]
-    else
-      DEFAULT_COLLECTIONS + [:buckets, :keys]
+  class MockDriver < Deltacloud::BaseDriver
+
+    # If the provider is set to storage, pretend to be a storage-only
+    # driver
+    def supported_collections
+      if api_provider == 'storage'
+        [:buckets]
+      else
+        DEFAULT_COLLECTIONS + [:buckets, :keys]
+      end
     end
-  end
 
-  ( REALMS = [
-    Realm.new({
-      :id=>'us',
-      :name=>'United States',
-      :limit=>:unlimited,
-      :state=>'AVAILABLE',
-    }),
-    Realm.new({
-      :id=>'eu',
-      :name=>'Europe',
-      :limit=>:unlimited,
-      :state=>'AVAILABLE',
-    }),
-  ] ) unless defined?( REALMS )
-
-  define_hardware_profile('m1-small') do
-    cpu              1
-    memory         1.7 * 1024
-    storage        160
-    architecture 'i386'
-  end
+    ( REALMS = [
+      Realm.new({
+        :id=>'us',
+        :name=>'United States',
+        :limit=>:unlimited,
+        :state=>'AVAILABLE'}),
+      Realm.new({
+        :id=>'eu',
+        :name=>'Europe',
+        :limit=>:unlimited,
+        :state=>'AVAILABLE'}),
+      ] ) unless defined?( REALMS )
+
+    define_hardware_profile('m1-small') do
+      cpu              1
+      memory         1.7 * 1024
+      storage        160
+      architecture 'i386'
+    end
 
-  define_hardware_profile('m1-large') do
-    cpu                2
-    memory           (7.5*1024 .. 15*1024), :default => 10 * 1024
-    storage          [ 850, 1024 ]
-    architecture     'x86_64'
-  end
+    define_hardware_profile('m1-large') do
+      cpu                2
+      memory           (7.5*1024 .. 15*1024), :default => 10 * 1024
+      storage          [ 850, 1024 ]
+      architecture     'x86_64'
+    end
 
-  define_hardware_profile('m1-xlarge') do
-    cpu              4
-    memory           (12*1024 .. 32*1024)
-    storage          [ 1024, 2048, 4096 ]
-    architecture     'x86_64'
-  end
+    define_hardware_profile('m1-xlarge') do
+      cpu              4
+      memory           (12*1024 .. 32*1024)
+      storage          [ 1024, 2048, 4096 ]
+      architecture     'x86_64'
+    end
 
-  # Some clouds tell us nothing about hardware profiles (e.g., OpenNebula)
-  define_hardware_profile 'opaque'
+    # Some clouds tell us nothing about hardware profiles (e.g., OpenNebula)
+    define_hardware_profile 'opaque'
 
-  define_instance_states do
-    start.to( :pending )       .on( :create )
+    define_instance_states do
+      start.to( :pending )       .on( :create )
 
-    pending.to( :running )     .automatically
+      pending.to( :running )     .automatically
 
-    running.to( :running )     .on( :reboot )
-    running.to( :stopped )     .on( :stop )
+      running.to( :running )     .on( :reboot )
+      running.to( :stopped )     .on( :stop )
 
-    stopped.to( :running )     .on( :start )
-    stopped.to( :finish )      .on( :destroy )
-  end
+      stopped.to( :running )     .on( :start )
+      stopped.to( :finish )      .on( :destroy )
+    end
 
-  feature :instances, :user_name
-  feature :instances, :authentication_key
+    feature :instances, :user_name
+    feature :instances, :user_data
+    feature :instances, :authentication_key
 
-  def initialize
-    if ENV["DELTACLOUD_MOCK_STORAGE"]
-      @storage_root = ENV["DELTACLOUD_MOCK_STORAGE"]
-    elsif ENV["USER"]
-      @storage_root = File::join("/var/tmp", "deltacloud-mock-#{ENV["USER"]}")
-    else
-      raise "Please set either the DELTACLOUD_MOCK_STORAGE or USER environment variable"
-    end
-    if ! File::directory?(@storage_root)
-      FileUtils::rm_rf(@storage_root)
-      FileUtils::mkdir_p(@storage_root)
-      data = Dir::glob(File::join(File::dirname(__FILE__), "data", "*"))
-      FileUtils::cp_r(data, @storage_root)
+    def initialize
+      if ENV["DELTACLOUD_MOCK_STORAGE"]
+        storage_root = ENV["DELTACLOUD_MOCK_STORAGE"]
+      elsif ENV["USER"]
+        storage_root = File::join("/var/tmp", "deltacloud-mock-#{ENV["USER"]}")
+      else
+        raise "Please set either the DELTACLOUD_MOCK_STORAGE or USER environment variable"
+      end
+      @client = Client.new(storage_root)
     end
-  end
 
-  def realms(credentials, opts=nil)
-    return REALMS if ( opts.nil? )
-    results = REALMS
-    results = filter_on( results, :id, opts )
-    results
-  end
+    def realms(credentials, opts=nil)
+      return REALMS if ( opts.nil? )
+      results = REALMS
+      results = filter_on( results, :id, opts )
+      results
+    end
 
-  #
-  # Images
-  #
-  def images(credentials, opts=nil )
-    check_credentials( credentials )
-    images = []
-    Dir[ "#{@storage_root}/images/*.yml" ].each do |image_file|
-      image = YAML.load( File.read( image_file ) )
-      image[:id] = File.basename( image_file, ".yml" )
-      image[:name] = image[:description]
-      images << Image.new( image )
-    end
-    images = filter_on( images, :id, opts )
-    images = filter_on( images, :architecture, opts )
-    if ( opts && opts[:owner_id] == 'self' )
-      images = images.select{|e| e.owner_id == credentials.user }
-    else
-      images = filter_on( images, :owner_id, opts )
-    end
-    images.sort_by{|e| [e.owner_id,e.description]}
-  end
+    #
+    # Images
+    #
+    def images(credentials, opts=nil )
+      check_credentials( credentials )
+      images = []
+      images = @client.build_all(Image)
+      images = filter_on( images, :id, opts )
+      images = filter_on( images, :architecture, opts )
+      if ( opts && opts[:owner_id] == 'self' )
+        images = images.select{|e| e.owner_id == credentials.user }
+      else
+        images = filter_on( images, :owner_id, opts )
+      end
+      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 )
+    def create_image(credentials, opts={})
+      check_credentials(credentials)
+      instance = instance(credentials, :id => opts[:id])
+      safely do
+        raise 'CreateImageNotSupported' unless instance and instance.can_create_image?
+        image = {
+          :id => opts[:name],
+          :name => opts[:name],
+          :owner_id => 'root',
+          :state => "AVAILABLE",
+          :description => opts[:description],
+          :architecture => 'i386'
+        }
+        @client.store(:images, image)
+        Image.new(image)
       end
-      image[:id] = next_id
-      Image.new(image)
     end
-  end
 
-  #
-  # Instances
-  #
-
-  def instance(credentials, opts={})
-    check_credentials( credentials )
-    instance_filename = File.join(@storage_root, 'instances', "#{opts[:id]}.yml")
-    return nil unless File.exists?(instance_filename)
-    instance = YAML::load_file(instance_filename)
-    instance[:actions] = instance_actions_for( instance[:state] )
-    instance[:id] = File::basename(instance_filename, ".yml")
-    Instance.new(instance)
-  end
+    def destroy_image(credentials, id)
+      check_credentials( credentials )
+      @client.destroy(:images, id)
+    end
+
+    #
+    # Instances
+    #
 
-  def instances(credentials, opts=nil)
-    check_credentials( credentials )
-    instances = []
-    Dir[ "#{@storage_root}/instances/*.yml" ].each do |instance_file|
-      instance = YAML::load_file(instance_file)
-      if ( instance[:owner_id] == credentials.user )
-        instance[:id] = File.basename( instance_file, ".yml" )
-        instance[:actions] = instance_actions_for( instance[:state] )
-        instances << Instance.new( instance )
+    def instance(credentials, opts={})
+      check_credentials( credentials )
+      if instance = @client.load(:instances, opts[:id])
+        Instance.new(instance)
       end
     end
-    instances = filter_on( instances, :id, opts )
-    instances = filter_on( instances, :state, opts )
-    instances
-  end
 
-  def create_instance(credentials, image_id, opts)
-    check_credentials( credentials )
-    ids = Dir[ "#{@storage_root}/instances/*.yml" ].collect{|e| File.basename( e, ".yml" )}
+    def instances(credentials, opts=nil)
+      check_credentials( credentials )
+      instances = @client.build_all(Instance)
+      instances = filter_on( instances, :owner_id, :owner_id => credentials.user )
+      instances = filter_on( instances, :id, opts )
+      instances = filter_on( instances, :state, opts )
+      instances
+    end
+
+    def create_instance(credentials, image_id, opts)
+      check_credentials( credentials )
+      ids = @client.members(:instances)
 
-    count = 0
-    while true
-      next_id = "inst" + count.to_s
-      if not ids.include?(next_id)
-        break
+      count = 0
+      while true
+        next_id = "inst" + count.to_s
+        if not ids.include?(next_id)
+          break
+        end
+        count = count + 1
       end
-      count = count + 1
-    end
-
-    realm_id = opts[:realm_id]
-    if ( realm_id.nil? )
-      realm = realms(credentials).first
-      ( realm_id = realm.id ) if realm
-    end
-
-    hwp = find_hardware_profile(credentials, opts[:hwp_id], image_id)
-
-    name = opts[:name] || "i-#{Time.now.to_i}"
-
-    instance = {
-      :name=>name,
-      :state=>'RUNNING',
-      :image_id=>image_id,
-      :owner_id=>credentials.user,
-      :public_addresses=>["#{image_id}.#{next_id}.public.com"],
-      :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|
-      YAML.dump( instance, f )
-    }
-    instance[:id] = next_id
-    Instance.new( instance )
-  end
 
-  def update_instance_state(credentials, id, state)
-    instance_file = "#{@storage_root}/instances/#{id}.yml"
-    instance_yml  = YAML.load( File.read( instance_file ) )
-    instance_yml[:id] = id
-    instance_yml[:state] = state
-    instance_yml[:actions] = instance_actions_for( instance_yml[:state] )
-    File.open( instance_file, 'w' ) do |f|
-      f << YAML.dump( instance_yml )
+      realm_id = opts[:realm_id]
+      if ( realm_id.nil? )
+        realm = realms(credentials).first
+        ( realm_id = realm.id ) if realm
+      end
+
+      hwp = find_hardware_profile(credentials, opts[:hwp_id], image_id)
+
+      name = opts[:name] || "i-#{Time.now.to_i}"
+
+      instance = {
+        :id => next_id,
+        :name=>name,
+        :state=>'RUNNING',
+        :keyname => opts[:keyname],
+        :image_id=>image_id,
+        :owner_id=>credentials.user,
+        :public_addresses=>["#{image_id}.#{next_id}.public.com"],
+        :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' ),
+        :user_data => opts[:user_data]
+      }
+      @client.store(:instances, instance)
+      Instance.new( instance )
     end
-    Instance.new( instance_yml )
-  end
 
-  def start_instance(credentials, id)
-    update_instance_state(credentials, id, 'RUNNING')
-  end
+    def update_instance_state(credentials, id, state)
+      instance  = @client.load(:instances, id)
+      instance[:state] = state
+      instance[:actions] = instance_actions_for( instance[:state] )
+      @client.store(:instances, instance)
+      Instance.new( instance )
+    end
 
-  def reboot_instance(credentials, id)
-    update_instance_state(credentials, id, 'RUNNING')
-  end
+    def start_instance(credentials, id)
+      update_instance_state(credentials, id, 'RUNNING')
+    end
 
-  def stop_instance(credentials, id)
-    update_instance_state(credentials, id, 'STOPPED')
-  end
+    def reboot_instance(credentials, id)
+      update_instance_state(credentials, id, 'RUNNING')
+    end
 
+    def stop_instance(credentials, id)
+      update_instance_state(credentials, id, 'STOPPED')
+    end
 
-  def destroy_instance(credentials, id)
-    check_credentials( credentials )
-    FileUtils.rm( "#{@storage_root}/instances/#{id}.yml" )
-  end
 
-  #
-  # Storage Volumes
-  #
-
-  def storage_volumes(credentials, opts=nil)
-    check_credentials( credentials )
-    volumes = []
-    Dir[ "#{@storage_root}/storage_volumes/*.yml" ].each do |storage_volume_file|
-      storage_volume = YAML.load( File.read( storage_volume_file ) )
-      if ( storage_volume[:owner_id] == credentials.user )
-        storage_volume[:id] = File.basename( storage_volume_file, ".yml" )
-        volumes << StorageVolume.new( storage_volume )
-      end
+    def destroy_instance(credentials, id)
+      check_credentials( credentials )
+      @client.destroy(:instances, id)
     end
-    volumes = filter_on( volumes, :id, opts )
-    volumes
-  end
 
-  #
-  # Storage Snapshots
-  #
-
-  def storage_snapshots(credentials, opts=nil)
-    check_credentials( credentials )
-    snapshots = []
-    Dir[ "#{@storage_root}/storage_snapshots/*.yml" ].each do |storage_snapshot_file|
-      storage_snapshot = YAML.load( File.read( storage_snapshot_file ) )
-      if ( storage_snapshot[:owner_id] == credentials.user )
-        storage_snapshot[:id] = File.basename( storage_snapshot_file, ".yml" )
-        snapshots << StorageSnapshot.new( storage_snapshot )
-      end
-    end
-    snapshots = filter_on( snapshots, :id, opts )
-    snapshots
-  end
+    #
+    # Storage Volumes
+    #
 
-  def keys(credentials, opts={})
-    check_credentials(credentials)
-    result = []
-    key_dir = File.join(@storage_root, 'keys')
-    Dir[key_dir + '/*.yml'].each do |key_file|
-      result << Key.new(YAML::load(File.read(key_file)))
+    def storage_volumes(credentials, opts=nil)
+      check_credentials( credentials )
+      volumes = @client.build_all(StorageVolume)
+      volumes = filter_on( volumes, :id, opts )
+      volumes
     end
-    result = filter_on( result, :id, opts )
-    result
-  end
 
-  def key(credentials, opts={})
-    keys(credentials, opts).first
-  end
+    #
+    # Storage Snapshots
+    #
 
-  def create_key(credentials, opts={})
-    check_credentials(credentials)
-    key_hash = {
-      :id => opts[:key_name],
-      :credential_type => :key,
-      :fingerprint => Key::generate_mock_fingerprint,
-      :pem_rsa_key => Key::generate_mock_pem
-    }
-    key_dir = File.join(@storage_root, 'keys')
-    if File.exists?(key_dir + "/#{key_hash[:id]}.yml")
-     raise Deltacloud::BackendError.new(403, self.class.to_s, "key-exists",
-                                          ["Key with same name already exists"])
-    end
-    FileUtils.mkdir_p(key_dir) unless File.directory?(key_dir)
-    File.open(key_dir + "/#{key_hash[:id]}.yml", 'w') do |f|
-      f.puts(YAML::dump(key_hash))
-    end
-    return Key.new(key_hash)
-  end
+    def storage_snapshots(credentials, opts=nil)
+      check_credentials( credentials )
+      snapshots = @client.build_all(StorageSnapshot)
+      snapshots = filter_on(snapshots, :id, opts )
+      snapshots
+    end
 
-  def destroy_key(credentials, opts={})
-    key = key(credentials, opts)
-    safely do
-      key_dir = File.join(@storage_root, 'keys')
-      File.delete(key_dir + "/#{key.id}.yml")
+    def keys(credentials, opts={})
+      check_credentials(credentials)
+      result = @client.build_all(Key)
+      result = filter_on( result, :id, opts )
+      result
     end
-  end
 
-#--
-# Buckets
-#--
-  def buckets(credentials, opts={})
-    check_credentials(credentials)
-    buckets=[]
-    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
+    def key(credentials, opts={})
+      keys(credentials, opts).first
     end
-    buckets = filter_on( buckets, :id, opts )
-  end
 
-#--
-# Create bucket
-#--
-  def create_bucket(credentials, name, opts={})
-    check_credentials(credentials)
-    bucket = {
-      :id => name,
-      :name=>name,
-      :size=>'0',
-      :blob_list=>[]
-    }
-    File.open( File::join(@storage_root, 'buckets', "#{name}.yml"), 'w') {|b| YAML.dump( bucket, b )}
-    Bucket.new(bucket)
-  end
+    def create_key(credentials, opts={})
+      check_credentials(credentials)
+      key_hash = {
+        :id => opts[:key_name],
+        :credential_type => :key,
+        :fingerprint => Key::generate_mock_fingerprint,
+        :pem_rsa_key => Key::generate_mock_pem
+      }
 
-#--
-# Delete bucket
-#--
-  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")
+      raise "KeyExist" if @client.load(:keys, key_hash[:id])
+      @client.store(:keys, key_hash)
+      return Key.new(key_hash)
     end
-    safely do
-      File.delete(File::join(@storage_root, 'buckets', "#{name}.yml"))
+
+    def destroy_key(credentials, opts={})
+      key = key(credentials, opts)
+      @client.destroy(:keys, key.id)
     end
-  end
 
-#--
-# Blobs
-#--
-  def blobs(credentials, opts = {})
-    check_credentials(credentials)
-    blobs=[]
-    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 )
+    #--
+    # Buckets
+    #--
+    def buckets(credentials, opts={})
+      check_credentials(credentials)
+      buckets = @client.build_all(Bucket)
+      blob_map = @client.load_all(:blobs).inject({}) do |map, blob|
+        map[blob[:bucket]] ||= []
+        map[blob[:bucket]] << blob[:id]
+        map
+      end
+      buckets.each { |bucket| bucket.blob_list = blob_map[bucket.id] }
+      filter_on( buckets, :id, opts )
     end
-  end
 
-#--
-# Blob content
-#--
-  def blob_data(credentials, bucket_id, blob_id, opts = {})
-    check_credentials(credentials)
-    blob=nil
-    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 bucket
+    #--
+    def create_bucket(credentials, name, opts={})
+      check_credentials(credentials)
+      bucket = {
+        :id => name,
+        :name=>name,
+        :size=>'0',
+        :blob_list=>[]
+      }
+      @client.store(:buckets, bucket)
+      Bucket.new(bucket)
+    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 bucket
+    #--
+    def delete_bucket(credentials, name, opts={})
+      check_credentials(credentials)
+      bucket = bucket(credentials, {:id => name})
+      raise "BucketNotEmpty" unless (bucket.size == "0")
+      @client.destroy(:buckets, bucket.id)
+    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")
+    #--
+    # Blobs
+    #--
+    def blobs(credentials, opts = {})
+      check_credentials(credentials)
+      blobs = @client.build_all(Blob)
+      filter_on( blobs, :bucket, :bucket => opts['bucket'] )
+      filter_on( blobs, :id, opts )
+    end
+
+    #--
+    # Blob content
+    #--
+    def blob_data(credentials, bucket_id, blob_id, opts = {})
+      check_credentials(credentials)
+      if blob = @client.load(:blobs, blob_id)
+        blob[:content].each {|part| yield part}
       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
+    #--
+    # Create blob
+    #--
+    def create_blob(credentials, bucket_id, blob_id, blob_data, opts={})
+      check_credentials(credentials)
+      blob_meta = BlobHelper::extract_blob_metadata_hash(opts)
+      blob = {
+        :id => blob_id,
+        :name => blob_id,
+        :bucket => bucket_id,
+        :content_length => blob_data[:tempfile].length,
+        :content_type => blob_data[:type],
+        :last_modified => Time.now,
+        :user_metadata => BlobHelper::rename_metadata_headers(blob_meta, ''),
+        :content => blob_data[:tempfile].read
+      }
+      @client.store(:blobs, blob)
+      Blob.new(blob)
+    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 )}
+    #--
+    # Delete blob
+    #--
+    def delete_blob(credentials, bucket_id, blob_id, opts={})
+      check_credentials(credentials)
+      safely do
+        raise "NotExistentBlob" unless @client.load(:blobs, blob_id)
+        @client.destroy(:blobs, blob_id)
+      end
     end
-  end
 
-  def valid_credentials?(credentials)
-    begin
+    #--
+    # Get metadata
+    #--
+    def blob_metadata(credentials, opts={})
       check_credentials(credentials)
-      return true
-    rescue Deltacloud::AuthException
+      if blob = @client.load(:blobs, params[:id])
+        blob[:user_metadata]
+      else
+        nil
+      end
     end
-    return false
-  end
 
-  private
+    #--
+    # Update metadata
+    #--
+    def update_blob_metadata(credentials, opts={})
+      check_credentials(credentials)
+      safely do
+        blob = @client.load(:blobs, params[:id])
+        return false unless blob
+        blob[:user_metadata] = BlobHelper::rename_metadata_headers(opts['meta_hash'], '')
+        @client.store(:blobs, blob)
+      end
+    end
 
-  def check_credentials(credentials)
-    if ( credentials.user != 'mockuser' ) or ( credentials.password != 'mockpassword' )
-      raise Deltacloud::AuthException.new
+    def valid_credentials?(credentials)
+      begin
+        check_credentials(credentials)
+        return true
+      rescue
+      end
+      return false
     end
-  end
 
-  def catched_exceptions_list
-    {
-      :auth => [],
-      :error => [ /Deltacloud::BackendError/, /Errno::ENOENT/ ],
-      :glob => [ /Error/ ]
-    }
-  end
+    private
 
-end
+    def check_credentials(credentials)
+      safely do
+        if ( credentials.user != 'mockuser' ) or ( credentials.password != 'mockpassword' )
+          raise 'AuthFailure'
+        end
+      end
+    end
+
+    exceptions do
+
+      on /AuthFailure/ do
+        status 401
+        message "Authentication Failure"
+      end
+
+      on /BucketNotEmpty/ do
+        status 403
+        message "Delete operation not valid for non-empty bucket"
+      end
+
+      on /KeyExist/ do
+        status 403
+        message "Key with same name already exists"
+      end
+
+      on /CreateImageNotSupported/ do
+        status 500
+      end
+
+      on /NotExistentBlob/ do
+        status 500
+        message "Could not delete a non existent blob"
+      end
+
+      on /Err/ do
+        status 500
+      end
 
     end
+
   end
+
 end