deltacloud-core 1.0.5 → 1.1.0

data/lib/deltacloud/drivers/ec2/ec2_driver.rb

@@ -507,33 +507,51 @@ module Deltacloud
         #--
         # Create Blob - NON Streaming way (i.e. was called with POST html multipart form data)
         #--
+        #also called for segmented blobs - as final call with blob manifest
         def create_blob(credentials, bucket_id, blob_id, data = nil, opts = {})
           s3_client = new_client(credentials, :s3)
           #data is a construct with the temporary file created by server @.tempfile
           #also file[:type] will give us the content-type
-          res = nil
-          # File stream needs to be reopened in binary mode for whatever reason
-          file = File::open(data[:tempfile].path, 'rb')
-          #insert ec2-specific header for user metadata ... x-amz-meta-KEY = VALUE
-          BlobHelper::rename_metadata_headers(opts, 'x-amz-meta-')
-          opts["Content-Type"] = data[:type]
-          safely do
-            res = s3_client.interface.put(bucket_id,
-                                        blob_id,
-                                        file,
-                                        opts)
+          if(opts[:segment_manifest])
+            safely do
+              s3_client.interface.complete_multipart(bucket_id, blob_id, opts[:segmented_blob_id], opts[:segment_manifest])
+            end
+          else
+            # File stream needs to be reopened in binary mode
+            file = File::open(data[:tempfile].path, 'rb')
+            #insert ec2-specific header for user metadata ... x-amz-meta-KEY = VALUE
+            BlobHelper::rename_metadata_headers(opts, 'x-amz-meta-')
+            opts["Content-Type"] = data[:type]
+            safely do
+              s3_client.interface.put(bucket_id,
+                                          blob_id,
+                                          file,
+                                          opts)
+            end
           end
           #create a new Blob object and return that
           Blob.new( { :id => blob_id,
                       :bucket => bucket_id,
-                      :content_length => data[:tempfile].length,
-                      :content_type => data[:type],
+                      :content_length => ((data && data[:tempfile]) ? data[:tempfile].length : nil),
+                      :content_type => ((data && data[:type]) ? data[:type] : nil),
                       :last_modified => '',
                       :user_metadata => opts.select{|k,v| k.match(/^x-amz-meta-/i)}
                     }
                   )
         end
 
+        def init_segmented_blob(credentials, opts={})
+          s3_client = new_client(credentials, :s3)
+          safely do
+            s3_client.interface.initiate_multipart(opts[:bucket],opts[:id])
+          end
+
+        end
+
+        def blob_segment_id(request, response)
+          response["etag"].gsub("\"", "")
+        end
+
         #--
         # Delete Blob
         #--
@@ -591,8 +609,16 @@ module Deltacloud
           timestamp = Time.now.httpdate
           string_to_sign =
             "PUT\n\n#{params[:content_type]}\n#{timestamp}\n#{signature_meta_string}/#{params[:bucket]}/#{params[:blob]}"
+          if BlobHelper.segmented_blob_op_type(params[:context]) == "segment"
+            partNumber = BlobHelper.segment_order(params[:context])
+            uploadId = BlobHelper.segmented_blob_id(params[:context])
+            segment_string = "?partNumber=#{partNumber}&uploadId=#{uploadId}"
+            string_to_sign << segment_string
+            request = Net::HTTP::Put.new("/#{params[:blob]}#{segment_string}")
+          else
+            request = Net::HTTP::Put.new("/#{params[:blob]}")
+          end
           auth_string = Aws::Utils::sign(params[:password], string_to_sign)
-          request = Net::HTTP::Put.new("/#{params[:blob]}")
           request['Host'] = "#{params[:bucket]}.#{uri.host}"
           request['Date'] = timestamp
           request['Content-Type'] = params[:content_type]

data/lib/deltacloud/drivers/exceptions.rb

@@ -58,6 +58,13 @@ module Deltacloud
       end
     end
 
+    class Conflict < DeltacloudException
+      def initialize(e, message=nil)
+        message ||= e.message
+        super(409, e.class.name, message, e.backtrace)
+      end
+    end
+
     class MethodNotAllowed < DeltacloudException
       def initialize(e, message=nil)
         message ||= e.message
@@ -157,6 +164,7 @@ module Deltacloud
           when 406 then UnknownMediaTypeError.new(e, @message)
           when 405 then MethodNotAllowed.new(e, @message)
           when 400 then ValidationFailure.new(e, @message)
+          when 409 then Conflict.new(e, @message)
           when 500 then BackendError.new(e, @message)
           when 501 then NotImplemented.new(e, @message)
           when 502 then ProviderError.new(e, @message)

data/lib/deltacloud/drivers/features.rb

@@ -112,8 +112,6 @@ module Deltacloud
         operation :create do
           param :keyname, :string,  :optional, [], "Key authentification method"
         end
-        operation :show do
-        end
       end
 
       feature :authentication_password, :for => :instances do
@@ -163,6 +161,25 @@ module Deltacloud
         end
       end
 
+      feature :volume_name, :for => :storage_volumes do
+        description "Specify name when creating storage_volume"
+        operation :create do
+          param :name, :string, :optional
+        end
+      end
+
+      feature :volume_description, :for => :storage_volumes do
+        description "Specify description when creating storage_volume"
+        operation :create do
+          param :description, :string, :optional
+        end
+      end
+
+
+
+
+
+
     end
 
   end

data/lib/deltacloud/drivers/fgcp/fgcp_client.rb

@@ -115,6 +115,17 @@ class FgcpClient
       'networkId'   => network_id})
   end
 
+  def create_vservers(vsys_id, vservers_xml)
+    @version = '2012-07-20'
+    request('CreateMultipleVServer',
+      {
+        'vsysId'    => vsys_id,
+      },
+      vservers_xml,
+      'vserversXMLFilePath'
+    )
+  end
+
   def destroy_vserver(vserver_id)
     request('DestroyVServer', {'vsysId' => extract_vsys_id(vserver_id), 'vserverId' => vserver_id})
   end

data/lib/deltacloud/drivers/fgcp/fgcp_driver.rb

@@ -30,6 +30,7 @@ class FgcpDriver < Deltacloud::BaseDriver
   feature :instances, :user_name
   feature :instances, :metrics
   feature :instances, :realm_filter
+  feature :instances, :instance_count
   feature :images, :user_name
   feature :images, :user_description
 
@@ -343,7 +344,7 @@ class FgcpDriver < Deltacloud::BaseDriver
   # Create a new instance, given an image id
   # opts can include an optional name for the instance, hardware profile (hwp_id) and realm_id
   def create_instance(credentials, image_id, opts={})
-    name = opts[:name]
+    name = (opts[:name] && opts[:name].length > 0)? opts[:name] : "server_#{Time.now.to_s}"
     # default to 'economy' or obtain latest hardware profiles and pick the lowest spec profile?
     hwp = opts[:hwp_id] || 'economy'
     network_id = opts[:realm_id]
@@ -355,9 +356,33 @@ class FgcpDriver < Deltacloud::BaseDriver
         # use first returned system's DMZ as realm
         network_id = xml ? xml[0]['vsys'][0]['vsysId'][0] + '-N-DMZ' : nil
       end
-      xml = client.create_vserver(name, hwp, image_id, network_id)
-      # returns vserver details
-      instances(credentials, {:id => xml['vserverId'][0]}).first
+      if opts[:instance_count] and opts[:instance_count].to_i > 1
+
+        vservers = Array.new(opts[:instance_count].to_i) { |n|
+          {
+            'vserverName' => "#{name}_#{n+1}",
+            'vserverType' => hwp,
+            'diskImageId' => image_id,
+            'networkId'   => network_id
+          }
+        }
+        new_vservers = { 'vservers' => { 'vserver' => vservers } }
+        vservers_xml = XmlSimple.xml_out(new_vservers,
+          'RootName' => 'Request',
+          'NoAttr' => true
+        )
+
+        xml = client.create_vservers(client.extract_vsys_id(network_id), vservers_xml)
+        vserver_ids = xml['vservers'][0]['vserver'].collect { |vserver| vserver['vserverId'][0] }
+        # returns vservers' details using filter
+        instances(credentials, {:realm_id => network_id}).select { |instance|
+          vserver_ids.include? instance.id
+        }
+      else
+        xml = client.create_vserver(name, hwp, image_id, network_id)
+        # returns vserver details
+        instances(credentials, {:id => xml['vserverId'][0]}).first
+      end
     end
   end
 
@@ -697,6 +722,7 @@ class FgcpDriver < Deltacloud::BaseDriver
     addresses
   end
 
+  # allocates (and enables) new ip in specified vsys/network
   def create_address(credentials, opts={})
     safely do
       client = new_client(credentials)
@@ -710,10 +736,32 @@ class FgcpDriver < Deltacloud::BaseDriver
         opts[:realm_id] = xml[0]['vsys'][0]['vsysId'][0] if xml
       end
 
+      old_ips = []
+      xml = client.list_public_ips(opts[:realm_id])['publicips']
+      old_ips = xml[0]['publicip'].collect { |ip| ip['address'][0]} if xml and xml[0]['publicip']
+
       client.allocate_public_ip(opts[:realm_id])
+      # new address not returned immediately:
+      # Seems to take 15-30s. to appear in list, so poll for a while
+      # prepare dummy id in case new ip does not appear soon.
+      id = 'PENDING-xxx.xxx.xxx.xxx'
+      sleep(8)
+      10.times {
+
+        sleep(5)
+        xml = client.list_public_ips(opts[:realm_id])['publicips']
+        if xml and xml[0]['publicip'] and xml[0]['publicip'].size > old_ips.size
+
+          new_ips = xml[0]['publicip'].collect { |ip| ip['address'][0]}
+          new_ip = (new_ips - old_ips).first
+          # enable IP address
+          client.attach_public_ip(opts[:realm_id], new_ip)
+          id = new_ip
+          break
+        end
+      }
+      Address.new(:id => id)
     end
-    # new address not returned immediately!
-    Address.new(:id => 'PENDING-xxx.xxx.xxx.xxx')
   end
 
   def destroy_address(credentials, opts={})
@@ -731,12 +779,23 @@ class FgcpDriver < Deltacloud::BaseDriver
         end
       end
       begin
-        # detach just in case
+        # disable IP if still enabled
         client.detach_public_ip(opts[:realm_id], opts[:id])
+        sleep(8)
       rescue Exception => ex
         raise ex unless ex.message =~ /^ALREADY_DETACHED.*/
       end
-      client.free_public_ip(opts[:realm_id], opts[:id])
+      attempts = 0
+      begin
+        # this may fail if the ip is still detaching, hence retry for a while
+        client.free_public_ip(opts[:realm_id], opts[:id])
+      rescue Exception => ex
+        raise unless attempts < 10 and ex.message =~ /^ILLEGAL_CONDITION.*/
+        # Detaching seems to take 15-30s, so keep trying for a while
+        sleep(5)
+        attempts += 1
+        retry
+      end
     end
   end
 
@@ -746,7 +805,9 @@ class FgcpDriver < Deltacloud::BaseDriver
       vsys_id = client.extract_vsys_id(opts[:instance_id])
 
       begin
+        # enable IP in case not enabled already
         client.attach_public_ip(vsys_id, opts[:id])
+        sleep(8)
       rescue Exception => ex
         raise ex unless ex.message =~ /^ALREADY_ATTACHED.*/
       end
@@ -768,7 +829,8 @@ class FgcpDriver < Deltacloud::BaseDriver
       fw_id = "#{vsys_id}-S-0001"
       nat_rules = client.get_efm_configuration(fw_id, 'FW_NAT_RULE')['efm'][0]['firewall'][0]['nat'][0]['rules'][0]
 
-      if nat_rules and not nat_rules.empty? # happens only if no enabled IP address?
+	# TODO: if no IP address enabled yet
+      if nat_rules and not nat_rules.empty? and nat_rules['rule'].find { |rule| rule['publicIp'][0] == opts[:id] }
 
         nat_rules['rule'].each do |rule|
 
@@ -830,7 +892,6 @@ class FgcpDriver < Deltacloud::BaseDriver
       )
 
       client.update_efm_configuration(fw_id, 'FW_NAT_RULE', conf_xml_new)
-      client.detach_public_ip(client.extract_vsys_id(opts[:realm_id]), opts[:id])
     end
   end
 
@@ -1194,8 +1255,11 @@ eofwopxml
   def create_load_balancer(credentials, opts={})
     safely do
       client = new_client(credentials)
-      # if opts['realm_id'].nil? network id specified, pick first vsys' DMZ?
+      # if opts['realm_id'].nil? network id specified, pick first vsys' DMZ
+      # if realm has SLB already, use that, else create
       # CreateEFM -vsysId vsysId -efmType SLB -efmName opts['name'] -networkId opts['realm_id']
+      # if not started already, start
+      # add group and return :id => efmId_groupId
       network_id = opts[:realm_id]
       if not network_id
         xml = client.list_vsys['vsyss']
@@ -1215,6 +1279,9 @@ eofwopxml
   def destroy_load_balancer(credentials, id)
     safely do
       client = new_client(credentials)
+      # remove group from SLB
+      # if no groups left, stop and destroy SLB
+      # destroy in new thread? May fail if public IP associated?
       client.destroy_efm(id)
     end
   end
@@ -1376,6 +1443,11 @@ eofwopxml
       status 404 # Not Found
     end
 
+    # reached maximum number of attempts while polling for an update
+    on /Server did not include public IP address in FW NAT rules/ do
+      status 504 # Gateway Timeout
+    end
+
     # wrong FW description (vsys descriptor)
     on /does not exist. Specify one of / do
       status 404 # Not Found

data/lib/deltacloud/drivers/gogrid/gogrid_client.rb

@@ -17,7 +17,7 @@
 require 'digest/md5'
 require 'cgi'
 require 'open-uri'
-require 'json'
+require 'json/pure'
 
 module Kernel
   def suppress_warnings

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

@@ -25,11 +25,9 @@ module Deltacloud::Drivers::Mock
     def initialize(storage_root)
       @storage_root = storage_root
       @collections = []
-
-      if ! File::directory?(@storage_root)
-        FileUtils::rm_rf(@storage_root)
-        FileUtils::mkdir_p(@storage_root, :mode => 0750)
+      if ! File::directory?(File::join(@storage_root, "images"))
         data = Dir[File::join(File::dirname(__FILE__), "data", "*")]
+        FileUtils::mkdir_p(@storage_root, :verbose => true)
         FileUtils::cp_r(data, @storage_root)
       end
     end

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

@@ -84,6 +84,15 @@ module Deltacloud::Drivers::Mock
     feature :images, :user_name
     feature :images, :user_description
 
+    #cimi features
+    feature :machines, :default_initial_state do
+      { :values => ["STARTED"] }
+    end
+    feature :machines, :initial_states do
+      { :values => ["STARTED", "STOPPED"]}
+    end
+
+
     def initialize
       if ENV["DELTACLOUD_MOCK_STORAGE"]
         storage_root = ENV["DELTACLOUD_MOCK_STORAGE"]
@@ -305,6 +314,26 @@ module Deltacloud::Drivers::Mock
       snapshots
     end
 
+    def create_storage_snapshot(credentials, opts={})
+      check_credentials(credentials)
+      id = "store_snapshot_#{Time.now.to_i}"
+      snapshot = {
+            :id => id,
+            :created => Time.now.to_s,
+            :state => "COMPLETED",
+            :storage_volume_id => opts[:volume_id],
+      }
+      snapshot.merge!({:name=>opts[:name]}) if opts[:name]
+      snapshot.merge!({:description=>opts[:description]}) if opts[:description]
+      @client.store(:storage_snapshots, snapshot)
+      StorageSnapshot.new(snapshot)
+    end
+
+    def destroy_storage_snapshot(credentials, opts={})
+      check_credentials(credentials)
+      @client.destroy(:storage_snapshots, opts[:id])
+    end
+
     def keys(credentials, opts={})
       check_credentials(credentials)
       result = @client.build_all(Key)

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

@@ -30,6 +30,8 @@ module Deltacloud
         feature :instances, :user_data
         feature :images, :user_name
         feature :keys, :import_key
+        feature :storage_volumes, :volume_name
+        feature :storage_volumes, :volume_description
 
         define_instance_states do
           start.to( :pending )          .on( :create )
@@ -38,6 +40,7 @@ module Deltacloud
           running.to( :stopping )       .on( :stop )
           stopping.to( :stopped )       .automatically
           stopped.to( :finish )         .automatically
+          error.from(:running, :pending, :stopping)
         end
 
         define_hardware_profile('default')
@@ -46,9 +49,14 @@ module Deltacloud
           #get the collections as defined by 'capability' and 'respond_to?' blocks
           super_collections = super
           begin
-             new_client(credentials, :buckets)
+             new_client(credentials, "object-store")
           rescue Deltacloud::Exceptions::NotImplemented #OpenStack::Exception::NotImplemented...
-             return super_collections - [Sinatra::Rabbit::BucketsCollection]
+             super_collections = super_collections - [Sinatra::Rabbit::BucketsCollection]
+          end
+          begin
+              new_client(credentials, "volume")
+          rescue Deltacloud::Exceptions::NotImplemented
+              super_collections = super_collections - [Sinatra::Rabbit::StorageVolumesCollection]
           end
           super_collections
         end
@@ -138,19 +146,19 @@ module Deltacloud
 
         def instances(credentials, opts={})
           os = new_client(credentials)
-          insts = []
+          insts = attachments = []
           safely do
             if opts[:id]
               begin
                 server = os.get_server(opts[:id])
-                insts << convert_from_server(server, os.connection.authuser)
+                insts << convert_from_server(server, os.connection.authuser, get_attachments(opts[:id], os))
               rescue => e
                 raise e unless e.message =~ /The resource could not be found/
                 insts = []
               end
             else
               insts = os.list_servers_detail.collect do |s|
-                convert_from_server(s, os.connection.authuser)
+                convert_from_server(s, os.connection.authuser,get_attachments(s[:id], os))
               end
             end
           end
@@ -173,13 +181,13 @@ module Deltacloud
           end
           if opts[:keyname] && opts[:keyname].length > 0
             params[:key_name]=opts[:keyname]
-	  end
-	  if opts[:user_data] && opts[:user_data].length > 0
-	    params[:user_data]=Base64.encode64(opts[:user_data])
-	  end
+          end
+          if opts[:user_data] && opts[:user_data].length > 0
+            params[:user_data]=Base64.encode64(opts[:user_data])
+          end
           safely do
             server = os.create_server(params)
-            result = convert_from_server(server, os.connection.authuser)
+            result = convert_from_server(server, os.connection.authuser, get_attachments(server.id, os))
           end
           result
         end
@@ -189,7 +197,7 @@ module Deltacloud
           safely do
             server = os.get_server(instance_id)
             server.reboot! # sends a hard reboot (power cycle) - could instead server.reboot("SOFT")
-            convert_from_server(server, os.connection.authuser)
+            convert_from_server(server, os.connection.authuser, get_attachments(instance_id, os))
           end
         end
 
@@ -222,7 +230,7 @@ module Deltacloud
         end
 
         def buckets(credentials, opts={})
-          os = new_client(credentials, :buckets)
+          os = new_client(credentials, "object-store")
           buckets = []
           safely do
             if opts[:id]
@@ -235,7 +243,7 @@ module Deltacloud
         end
 
         def create_bucket(credentials, name, opts={})
-          os = new_client(credentials, :buckets)
+          os = new_client(credentials, "object-store")
           bucket = nil
           safely do
             bucket = os.create_container(name)
@@ -244,14 +252,14 @@ module Deltacloud
         end
 
         def delete_bucket(credentials, name, opts={})
-          os = new_client(credentials, :buckets)
+          os = new_client(credentials, "object-store")
           safely do
             os.delete_container(name)
           end
         end
 
         def blobs(credentials, opts={})
-          os = new_client(credentials, :buckets)
+          os = new_client(credentials, "object-store")
           blobs = []
           safely do
             bucket = os.container(opts['bucket'])
@@ -265,7 +273,7 @@ module Deltacloud
         end
 
         def blob_data(credentials, bucket, blob, opts={})
-          os = new_client(credentials, :buckets)
+          os = new_client(credentials, "object-store")
           safely do
             os.container(bucket).object(blob).data_stream do |chunk|
               yield chunk
@@ -274,30 +282,34 @@ module Deltacloud
         end
 
         def create_blob(credentials, bucket, blob, data, opts={})
-          os = new_client(credentials, :buckets)
+          os = new_client(credentials, "object-store")
           safely do
-            BlobHelper.rename_metadata_headers(opts, "X-Object-Meta-")
-            os_blob = os.container(bucket).create_object(blob, {:content_type=> data[:type], :metadata=>opts}, data[:tempfile])
+            if(opts[:segment_manifest]) # finalize a segmented blob upload
+              os_blob = os.container(bucket).create_object(blob, {:manifest=>"#{bucket}/#{opts[:segmented_blob_id]}"})
+            else
+              BlobHelper.rename_metadata_headers(opts, "X-Object-Meta-")
+              os_blob = os.container(bucket).create_object(blob, {:content_type=> data[:type], :metadata=>opts}, data[:tempfile])
+            end
             convert_blob(os_blob, bucket)
           end
         end
 
         def delete_blob(credentials, bucket, blob, opts={})
-          os = new_client(credentials, :buckets)
+          os = new_client(credentials, "object-store")
           safely do
             os.container(bucket).delete_object(blob)
           end
         end
 
         def blob_metadata(credentials, opts={})
-          os = new_client(credentials, :buckets)
+          os = new_client(credentials, "object-store")
           safely do
             os.container(opts['bucket']).object(opts[:id]).metadata
           end
         end
 
         def update_blob_metadata(credentials, opts={})
-          os = new_client(credentials, :buckets)
+          os = new_client(credentials, "object-store")
           safely do
             BlobHelper.rename_metadata_headers(opts["meta_hash"], "")
             blob = os.container(opts['bucket']).object(opts[:id])
@@ -305,8 +317,23 @@ module Deltacloud
           end
         end
 
+        def init_segmented_blob(credentials, opts={})
+          opts[:id]
+        end
+
+        def blob_segment_id(request, response)
+          #could be in http header OR query string:
+          segment_order = BlobHelper.segment_order(request)
+          blob_name = request.env["PATH_INFO"].gsub(/(&\w*=\w*)*$/, "").split("/").pop
+          "#{blob_name}#{segment_order}"
+        end
+
         #params: {:user,:password,:bucket,:blob,:content_type,:content_length,:metadata}
+        #params[:context] holds the request object - for getting to blob segment params
         def blob_stream_connection(params)
+          if BlobHelper.segmented_blob_op_type(params[:context]) == "segment"
+            params[:blob] = "#{params[:blob]}#{BlobHelper.segment_order(params[:context])}"
+          end
           tokens = params[:user].split("+")
           user_name, tenant_name = tokens.first, tokens.last
           #need a client for the auth_token and endpoints
@@ -352,10 +379,82 @@ module Deltacloud
           end
         end
 
+        def storage_volumes(credentials, opts={})
+          vs = new_client(credentials, "volume")
+          volumes = []
+          safely do
+            if opts[:id]
+              volumes <<  convert_volume(vs.get_volume(opts[:id]))
+            else
+              vs.volumes.each do |vol|
+                volumes << convert_volume(vol)
+              end
+            end
+          end
+          volumes
+        end
+
+        def create_storage_volume(credentials, opts=nil)
+          vs = new_client(credentials, "volume")
+          params = {}
+          safely do
+            params[:size] = opts.delete("capacity") || 1
+            params[:display_name] = opts.delete("name") || "Volume#{Time.now}"
+            params[:display_description] = opts.delete("description") || params[:display_name]
+            params[:availability_zone] = opts.delete("realm_id") unless (opts["realm_id"].nil? || opts["realm_id"].empty?)
+            opts.delete("commit")
+            opts.delete("snapshot_id") #FIXME AFTER ADDING SNAPSHOTS TO OPENSTACK GEM
+            volume = convert_volume(vs.create_volume(opts.merge(params)))
+          end
+        end
+
+        def destroy_storage_volume(credentials, opts={})
+          vs = new_client(credentials, "volume")
+          safely do
+            vs.delete_volume(opts[:id])
+          end
+        end
+
+        def attach_storage_volume(credentials, opts={})
+          vs = new_client(credentials, "volume")
+          cs = new_client(credentials, "compute")
+          safely do
+            cs.attach_volume(opts[:instance_id], opts[:id], opts[:device])
+            volume = convert_volume(vs.get_volume(opts[:id]))
+          end
+        end
+
+        def detach_storage_volume(credentials, opts={})
+          vs = new_client(credentials, "volume")
+          cs = new_client(credentials, "compute")
+          safely do
+            cs.detach_volume(opts[:instance_id], opts[:id])
+            volume = convert_volume(vs.get_volume(opts[:id]))
+          end
+        end
+
+        def storage_snapshots(credentials, opts={})
+          vs = new_client(credentials, "volume")
+          safely do
+          end
+        end
+
+        def create_storage_snapshot(credentials, opts={})
+          vs = new_client(credentials, "volume")
+          safely do
+          end
+        end
+
+        def destroy_storage_snapshot(credentials, opts={})
+          vs = new_client(credentials, "volume")
+          safely do
+          end
+        end
+
 private
 
         #for v2 authentication credentials.name == "username+tenant_name"
-        def new_client(credentials, type = :compute)
+        def new_client(credentials, type = "compute")
           tokens = credentials.user.split("+")
           if credentials.user.empty?
             raise AuthenticationFailure.new(Exception.new("Error: you must supply the username"))
@@ -366,16 +465,10 @@ private
             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
+            raise ValidationFailure.new(Exception.new("Error: tried to initialise Openstack connection using" +
+                    " an unknown service_type: #{type}")) unless ["volume", "compute", "object-store"].include? type
+            OpenStack::Connection.create(:username => user_name, :api_key => credentials.password, :authtenant => tenant_name, :auth_url => api_provider, :service_type => type)
+           end
         end
 
 #NOTE: for the convert_from_foo methods below... openstack-compute
@@ -407,7 +500,7 @@ private
                     })
         end
 
-        def convert_from_server(server, owner)
+        def convert_from_server(server, owner, attachments=[])
           op = (server.class == Hash)? :fetch : :send
           image = server.send(op, :image)
           flavor = server.send(op, :flavor)
@@ -430,7 +523,8 @@ private
             :private_addresses => convert_server_addresses(server, :private),
             :username => 'root',
             :password => password,
-            :keyname => server.send(op, :key_name)
+            :keyname => server.send(op, :key_name),
+            :storage_volumes => attachments.inject([]){|res, cur| res << {cur[:volumeId] => cur[:device]} ;res}
           )
           inst.actions = instance_actions_for(inst.state)
           inst.create_image = 'RUNNING'.eql?(inst.state)
@@ -447,10 +541,12 @@ private
               "STOPPED"
             when /build.*$/
               "PENDING"
+            when /error.*/
+              "ERROR"
             when /active/
               "RUNNING"
             else
-              "UNKOWN"
+              "UNKNOWN"
           end
         end
 
@@ -489,6 +585,27 @@ private
           )
         end
 
+        def get_attachments(server_id, client)
+          if client.api_extensions[:"os-volumes"]
+            attachments = client.list_attachments(server_id)
+            attachments[:volumeAttachments] || []
+          else
+            []
+          end
+        end
+
+        def convert_volume(vol)
+          StorageVolume.new({ :id => vol.id,
+                              :name => vol.display_name,
+                              :created => vol.created_at,
+                              :state => (vol.attachments.inject([]){|res, cur| res << cur if cur.size > 0 ; res}.empty?) ? "AVAILABLE" : "IN-USE",
+                              :capacity => vol.size,
+                              :instance_id => (vol.attachments.first["serverId"] unless vol.attachments.empty?),
+                              :device => (vol.attachments.first["device"] unless vol.attachments.empty?),
+                              :realm_id => vol.availability_zone,
+                              :description => vol.display_description # openstack volumes have a display_description attr
+          })
+        end
 
         #IN: path1='server_path1'. content1='contents1', path2='server_path2', content2='contents2' etc
         #OUT:{local_path=>server_path, local_path1=>server_path2 etc}