deltacloud-core 1.0.5 → 1.1.0

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

@@ -0,0 +1,20 @@
+# This is a copy of code that has been submitted upstream
+# https://github.com/rackspace/ruby-cloudservers/pull/22
+#
+# Once the pull request is merged we can remove this patch
+# Also see https://issues.apache.org/jira/browse/DTACLOUD-319
+
+module CloudServers
+  class Connection
+
+    def list_servers_detail(options = {})
+      anti_cache_param="cacheid=#{Time.now.to_i}"
+      path = CloudServers.paginate(options).empty? ? "#{svrmgmtpath}/servers/detail?#{anti_cache_param}" : "#{svrmgmtpath}/servers/detail?#{CloudServers.paginate(options)}&#{anti_cache_param}"
+      response = csreq("GET",svrmgmthost,path,svrmgmtport,svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      CloudServers.symbolize_keys(JSON.parse(response.body)["servers"])
+    end
+    alias :servers_detail :list_servers_detail
+
+  end
+end

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

@@ -17,6 +17,7 @@
 require 'cloudfiles'
 require 'cloudservers'
 require 'base64'
+require_relative 'anti_cache_monkey_patch'
 
 module Deltacloud
   module Drivers

data/lib/deltacloud/drivers/rhevm/rhevm_driver.rb

@@ -118,9 +118,7 @@ class RhevmDriver < Deltacloud::BaseDriver
   def destroy_image(credentials, image_id)
     client = new_client(credentials)
     safely do
-      unless client.destroy_template(image_id)
-        raise "ERROR: Unable to remove image"
-      end
+      client.destroy_template(image_id)
     end
   end
 
@@ -208,8 +206,13 @@ class RhevmDriver < Deltacloud::BaseDriver
   def new_client(credentials)
     safely do
       raise 'No API provider set for this request.' unless api_provider
-      url, datacenter = api_provider.split(';')
-      OVIRT::Client.new(credentials.user, credentials.password, url, datacenter)
+      url, datacenter, filtered = api_provider.split(';')
+      if filtered.nil?
+        OVIRT::Client.new(credentials.user, credentials.password, url, datacenter)
+      else
+        filtered_api = filtered.upcase == 'USER'
+        OVIRT::Client.new(credentials.user, credentials.password, url, datacenter, nil, filtered_api)
+      end
     end
   end
 
@@ -244,14 +247,25 @@ class RhevmDriver < Deltacloud::BaseDriver
       ip = confserver_ip(inst.id)
       public_addresses = [ InstanceAddress.new(ip) ]
     end
-    # If IP retrieval failed, fallback to VNC and MAC address
-    if public_addresses.empty?
-      public_addresses = inst.interfaces.map { |interface| InstanceAddress.new(interface.mac, :type => :mac) }
-    end
+
+    public_addresses += inst.interfaces.map { |interface| InstanceAddress.new(interface.mac, :type => :mac) }
+
     if inst.vnc
       public_addresses << InstanceAddress.new(inst.vnc[:address], :port => inst.vnc[:port], :type => :vnc)
     end
+
+    # Remove 'destroy' operation from list of actions when RHEV-M instance
+    # is suspended or paused.
+    if state == 'PAUSED'
+      actions = instance_actions_for(state = 'STOPPED')
+      actions.delete(:destroy)
+    else
+      actions = instance_actions_for(state)
+      can_create_image = true
+    end
+
     Instance.new(
+      :actions=>actions,
       :id => inst.id,
       :name => inst.name,
       :state => state,
@@ -261,10 +275,9 @@ class RhevmDriver < Deltacloud::BaseDriver
       :launch_time => inst.creation_time,
       :instance_profile => profile,
       :hardware_profile_id => profile.id,
-      :actions=>instance_actions_for( state ),
       :public_addresses => public_addresses,
       :private_addresses => [],
-      :create_image => true
+      :create_image => can_create_image || false
     )
   end
 
@@ -283,9 +296,10 @@ class RhevmDriver < Deltacloud::BaseDriver
     return 'PENDING' if ['WAIT_FOR_LAUNCH', 'REBOOT_IN_PROGRESS', 'SAVING_STATE',
                         'RESTORING_STATE', 'POWERING_UP', 'IMAGE_LOCKED', 'SAVING_STATE'].include? state
     return 'STOPPING' if state == 'POWERING_DOWN'
-    return 'STOPPED' if ['UNASSIGNED', 'DOWN', 'PAUSED', 'NOT_RESPONDING', 'SUSPENDED',
+    return 'STOPPED' if ['UNASSIGNED', 'DOWN', 'NOT_RESPONDING',
                          'IMAGE_ILLEGAL', 'UNKNOWN'].include? state
     return 'RUNNING' if ['UP', 'MIGRATING_TO', 'MIGRATING_FROM'].include? state
+    return 'PAUSED' if ['PAUSED', 'SUSPENDED'].include? state
     raise "Unexpected state '#{state}'"
   end
 
@@ -342,6 +356,10 @@ class RhevmDriver < Deltacloud::BaseDriver
       status 404
     end
 
+    on /(Cannot delete Template. Template is being used)/ do
+      status 409
+    end
+
     on /(RestClient|RHEVM|OVIRT)/ do
       status 500
     end

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

@@ -16,7 +16,6 @@
 
 require 'base64'
 require 'net/https'
-require 'json'
 require 'digest/md5'
 
 module Deltacloud

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

@@ -87,7 +87,11 @@ class SbcDriver < Deltacloud::BaseDriver
     # Map DeltaCloud keywords to SBC
     body['imageID'] = opts[:image_id]
     body['location'] = opts[:realm_id] || @last_image['location']
-    body['instanceType'] = opts[:hwp_id].gsub('-', '/') || @last_image['supportedInstanceTypes'][0]['id']
+    if opts[:hwp_id]
+      body['instanceType'] = opts[:hwp_id].gsub('-', '/')
+    else
+      body['instanceType'] = @last_image['supportedInstanceTypes'][0]['id']
+    end
 
     if not body['name']
       body['name'] = Time.now.to_i.to_s

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

@@ -45,7 +45,7 @@ module Deltacloud::Drivers::VSphere
               end
             end
           end
-          break if [:datastore]
+          break if vm[:datastore]
         end
         vm
       end

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

@@ -162,6 +162,7 @@ module Deltacloud::Drivers::Vsphere
           # instance.
           template_id = vm.config[:extraConfig].select { |k| k.key == 'template_id' }
           template_id = template_id.first.value unless template_id.empty?
+
           properties = {
             :memory => config[:memorySizeMB],
             :cpus => config[:numCpu],
@@ -177,17 +178,15 @@ module Deltacloud::Drivers::Vsphere
           # We're getting IP address from 'vmware guest tools'.
           # If guest tools are not installed, we return list of MAC addresses
           # assigned to this instance.
-          public_addresses = []
-          if vm.guest[:net].empty?
-            public_addresses = vm.macs.values.collect { |mac_address| InstanceAddress.new(mac_address, :type => :mac) }
-          else
-            public_addresses = [InstanceAddress.new(vm.guest[:net].first[:ipAddress].first)]
+          public_addresses = vm.macs.values.collect { |mac_address| InstanceAddress.new(mac_address, :type => :mac) }
+          if !vm.guest[:net].empty? and ip_address = vm.guest[:net].first[:ipAddress].first
+            public_addresses += [InstanceAddress.new(ip_address)]
           end
           Instance.new(
             :id => properties[:name],
             :name => properties[:name],
             :owner_id => credentials.user,
-            :image_id => template_id,
+            :image_id => template_id.empty? ? nil : template_id,
             :description => properties[:full_name],
             :realm_id => realm_id,
             :state => instance_state,
@@ -215,7 +214,7 @@ module Deltacloud::Drivers::Vsphere
         if opts[:hwp_cpu]
           raise "Invalid CPU value. Must be in integer format" unless valid_cpu_value?(opts[:hwp_cpu])
         end
-        vm = find_vm(credentials, opts[:image_id])
+        vm = find_vm(credentials, image_id)
         raise "ERROR: Could not find the image in given datacenter" unless vm[:instance]
         # New instance need valid resource pool and datastore to be placed.
         # For this reason, realm_id **needs** to be set.
@@ -291,7 +290,7 @@ module Deltacloud::Drivers::Vsphere
           :config => RbVmomi::VIM.VirtualMachineConfigSpec(machine_config)
         )
         instance_profile = InstanceProfile::new('default', :hwp_memory => opts[:hwp_memory], :hwp_cpu => opts[:hwp_cpu])
-        task = vm[:instance].CloneVM_Task(:folder => vm[:instance].parent, :name => opts[:name], :spec => spec)
+        task = vm[:instance].CloneVM_Task(:folder => vm[:instance].parent, :name => opts[:name] || "inst#{Time.now.to_i}", :spec => spec)
         new_instance = Instance::new(
           :id => opts[:name],
           :name => opts[:name],
@@ -381,6 +380,10 @@ module Deltacloud::Drivers::Vsphere
         status 504
       end
 
+      on /missing required parameter name/ do
+        status 400
+      end
+
       on /Invalid/ do
         status 400
       end
@@ -410,7 +413,14 @@ module Deltacloud::Drivers::Vsphere
     end
 
     def host_endpoint
-      endpoint = api_provider
+      endpoint = "#{api_provider}"
+      # We need to have the 'hostname' form in API_PROVIDER, but to be
+      # compatible with other drivers, we allow 'https://vsphere/api' format.
+      # The 'http' and '/.*' parts are however stripped.
+      if endpoint =~ /^http/
+        endpoint.gsub!(/^http(s?):\/\//, '')
+        endpoint.gsub!(/\/.*$/, '')
+      end
       endpoint || Deltacloud::Drivers::driver_config[:vsphere][:entrypoints]['default']['default']
     end
 

data/lib/deltacloud/helpers/blob_stream_helper.rb

@@ -77,6 +77,43 @@ DELTACLOUD_BLOBMETA_HEADER = /HTTP[-_]X[-_]Deltacloud[-_]Blobmeta[-_]/i
     metadata.gsub_keys(DELTACLOUD_BLOBMETA_HEADER, rename_to)
   end
 
+  #in the following segment* methods, using context.env["QUERY_STRING"] rather than context.params so it works for both Thin and Sinatra request objects (streaming)
+  def self.segmented_blob(request_context)
+    return true if (request_context.env["HTTP_X_DELTACLOUD_BLOBTYPE"] == 'segmented' || request_context.env["QUERY_STRING"].match(/blob_type=segmented/))
+    false
+  end
+
+  def self.segment_order(request_context)
+    (request_context.env["HTTP_X_DELTACLOUD_SEGMENTORDER"] || request_context.env["QUERY_STRING"].match(/segment_order=(\w)*/){|m| m[0].split("=").pop})
+  end
+
+  def self.segmented_blob_id(request_context)
+    (request_context.env["HTTP_X_DELTACLOUD_SEGMENTEDBLOB"] || request_context.env["QUERY_STRING"].match(/segmented_blob=(\w)*/){|m| m[0].split("=").pop})
+  end
+
+  def self.segmented_blob_op_type(request_context)
+    is_segmented = segmented_blob(request_context)
+    blob_id = segmented_blob_id(request_context)
+    segment_order = segment_order(request_context)
+    #if blob_type=segmented AND segmented_blob_id AND segment_order then it is a "SEGMENT"
+    #if blob_type=segmented AND segmented_blob_id then it is a "FINALIZE"
+    #if blob_type=segmented then it is "INIT"
+    return "segment" if (is_segmented && blob_id && segment_order)
+    return "finalize" if (is_segmented && blob_id)
+    return "init" if is_segmented
+    nil # should explode something instead
+  end
+
+  #in "1=abc , 2=def , 3=ghi"
+  #out {"1"=>"abc", "2"=>"def", "3"=>"ghi"}
+  def self.extract_segmented_blob_manifest(request)
+    manifest_hash = request.body.read.split(",").inject({}) do |res,current|
+      k,v=current.strip.split("=")
+      res[k]=v
+      res
+    end
+  end
+
 end
 
 #Monkey patch for streaming blobs:
@@ -158,11 +195,10 @@ class BlobStreamIO
     @content_length = request.env['CONTENT_LENGTH']
     @http, provider_request = Deltacloud::API.driver.blob_stream_connection({:user=>user,
        :password=>password, :bucket=>bucket, :blob=>blob, :metadata=> user_meta,
-       :content_type=>content_type, :content_length=>@content_length })
+       :content_type=>content_type, :content_length=>@content_length, :context=>request })
     @content_length = @content_length.to_i #for comparison of size in '<< (data)'
     @sock = @http.request(provider_request, nil, true)
   end
-
   def << (data)
     @sock.write(data)
     @size += data.length
@@ -170,6 +206,9 @@ class BlobStreamIO
       result = @http.end_request
       if result.is_a?(Net::HTTPSuccess)
         @client_request.env["BLOB_SUCCESS"] = "true"
+        if BlobHelper.segmented_blob_op_type(@client_request) == "segment"
+          @client_request.env["BLOB_SEGMENT_ID"] = Deltacloud::API.driver.blob_segment_id(@client_request, result)
+        end
       else
         @client_request.env["BLOB_FAIL"] = result.body
       end
@@ -195,7 +234,7 @@ class BlobStreamIO
   private
 
   def parse_bucket_blob(request_string)
-    array = request_string.split("/")
+    array = request_string.gsub(/(&\w*=\w*)*$/, "").split("/")
     blob = array.pop
     bucket = array.pop
     return bucket, blob

data/lib/deltacloud/helpers/deltacloud_helper.rb

@@ -18,6 +18,31 @@ module Deltacloud::Helpers
 
     require 'benchmark'
 
+    def collections_to_json(collections)
+      r = {
+        :version => settings.version,
+        :driver => driver_symbol,
+        :provider => Thread.current[:provider] || ENV['API_PROVIDER'],
+        :links => collections.map { |c|
+          {
+            :rel => c.collection_name,
+            :href => self.send(:"#{c.collection_name}_url"),
+            :features => c.features.select { |f| driver.class.has_feature?(c.collection_name, f.name) }.map { |f|
+              f.operations.map { |o|
+                { :name => f.name, :rel => o.name, :params => o.params_array, :constraints => constraints_hash_for(c.collection_name, f.name) }
+              }
+            }
+          }
+        }
+      }
+      r[:provider] ||= 'default'
+      JSON::dump(:api => r)
+    end
+
+    def constraints_hash_for(collection_name, feature_name)
+      driver.class.constraints(:collection => collection_name, :feature => feature_name).inject({}) { |r, v| r[v[0]]=v[1];r }
+    end
+
     def request_headers
       env.inject({}){|acc, (k,v)| acc[$1.downcase] = v if k =~ /^http_(.*)/i; acc}
     end
@@ -48,22 +73,13 @@ module Deltacloud::Helpers
         respond_to do |format|
           format.html { haml :"#{model}/index" }
           format.xml { haml :"#{model}/index" }
-          format.json { @media_type=:xml; to_json(haml(:"#{model}/index")) }
+          format.json { JSON::dump({ model => @elements.map { |el| el.to_hash(self) }}) }
         end
       else
         report_error(@exception.respond_to?(:code) ? @exception.code : 500)
       end
     end
 
-    def xml_to_json(model)
-      @media_type = :xml
-      to_json(haml(:"#{model}"))
-    end
-
-    def to_json(xml)
-      Crack::XML.parse(xml).to_json
-    end
-
     def show(model)
       @benchmark = Benchmark.measure do
         @element = driver.send(model, credentials, { :id => params[:id]} )
@@ -74,7 +90,7 @@ module Deltacloud::Helpers
         respond_to do |format|
           format.html { haml :"#{model.to_s.pluralize}/show" }
           format.xml { haml :"#{model.to_s.pluralize}/show" }
-          format.json { @media_type=:xml; to_json(haml(:"#{model.to_s.pluralize}/show")) }
+          format.json { JSON::dump(model => @element.to_hash(self)) }
         end
       else
         report_error(404)
@@ -101,7 +117,7 @@ module Deltacloud::Helpers
       response.status = @code
 
       backtrace = (@error.respond_to?(:backtrace) and !@error.backtrace.nil?) ?
-        "\n\n#{@error.backtrace[0..10].join("\n")}\n\n" : ''
+        "\n\n#{@error.backtrace[0..20].join("\n")}\n\n" : ''
 
       if @code.to_s =~ /5(\d+)/
         log.error(@code.to_s) { "[#{@error.class.to_s}] #{message}#{backtrace}" }
@@ -109,7 +125,7 @@ module Deltacloud::Helpers
 
       respond_to do |format|
         format.xml {  haml :"errors/#{@code || @error.code}", :layout => false }
-        format.json { xml_to_json("errors/#{@code || @error.code}") }
+        format.json { JSON::dump({ :code => @code || @error.code, :message => message, :error => @error.class.name }) }
         format.html {
           begin
             haml :"errors/#{@code || @error.code}", :layout => :error
@@ -151,7 +167,7 @@ module Deltacloud::Helpers
         response = respond_to do |format|
           format.xml { haml :"instances/show" }
           format.html { haml :"instances/show" }
-          format.json { xml_to_json("instances/show") }
+          format.json { JSON::dump(@instance.to_hash(self)) }
         end
         halt 202, response
       end
@@ -245,6 +261,7 @@ module Deltacloud::Helpers
       when 404; { :message => "Not Found" }
       when 405; { :message => "Method Not Allowed" }
       when 406; { :message => "Not Acceptable" }
+      when 409; { :message => "Resource Conflict" }
       when 500; { :message => "Internal Server Error" }
       when 502; { :message => "Backend Server Error" }
       when 504; { :message => "Gateway Timeout" }

data/lib/deltacloud/models/address.rb

@@ -25,4 +25,13 @@ class Address < BaseModel
     !self.instance_id.nil?
   end
 
+  def to_hash(context)
+    r = {
+      :id => self.id,
+      :associated => associated?
+    }
+    r[:instance_id] = instance_id if associated?
+    r
+  end
+
 end

data/lib/deltacloud/models/base_model.rb

@@ -44,4 +44,8 @@ class BaseModel
     @id
   end
 
+  def to_entity
+    self.class.name.downcase
+  end
+
 end

data/lib/deltacloud/models/blob.rb

@@ -24,4 +24,16 @@ class Blob < BaseModel
   attr_accessor :content
   attr_accessor :user_metadata
 
+  def to_hash(context)
+    {
+      :id => self.id,
+      :bucket => { :rel => :bucket, :href => context.bucket_url(bucket), :id => bucket },
+      :content_length => content_length,
+      :content_type => content_type,
+      :last_modified => last_modified,
+      :content => content,
+      :user_metadata => user_metadata
+    }
+  end
+
 end

data/lib/deltacloud/models/bucket.rb

@@ -24,4 +24,13 @@ class Bucket < BaseModel
     @blob_list || []
   end
 
+  def to_hash(context)
+    {
+      :id => self.id,
+      :name => name,
+      :size => size,
+      :blob_list => blob_list.map { |b| { :rel => :blob, :href => context.url("/buckets/#{self.id}/#{b}"), :id => b }}
+    }
+  end
+
 end