deltacloud-core 1.0.3 → 1.0.4

data/lib/deltacloud/helpers.rb

@@ -15,81 +15,6 @@
 
 require_relative 'helpers/driver_helper'
 require_relative 'helpers/auth_helper'
-require_relative 'helpers/url_helper'
 require_relative 'helpers/deltacloud_helper'
 require_relative 'helpers/rabbit_helper'
 require_relative 'helpers/blob_stream_helper'
-
-module Deltacloud::Collections
-  class Base < Sinatra::Base
-
-    include Sinatra::Rabbit
-    extend Deltacloud::Helpers::Drivers
-    include Sinatra::Rabbit::Features
-
-    helpers Deltacloud::Helpers::Drivers
-    helpers Sinatra::AuthHelper
-    helpers Sinatra::UrlForHelper
-    helpers Rack::RespondTo::Helpers
-    helpers Deltacloud::Helpers::Application
-
-    register Rack::RespondTo
-
-    enable :xhtml
-    enable :dump_errors
-    enable :show_errors
-    enable :method_override
-    disable :show_exceptions
-
-    set :config, Deltacloud[:deltacloud]
-    set :root_url, config.root_url
-    set :root_path, config.root_url
-    set :version, config.version
-    set :root, File.join(File.dirname(__FILE__), '..', '..')
-    set :views, root + '/views'
-    set :public_folder, root + '/public'
-
-    Sinatra::Rabbit.set :root_path, "#{config.root_url}/"
-
-    error do
-      report_error
-    end
-
-    error Deltacloud::ExceptionHandler::ValidationFailure do
-      report_error
-    end
-
-    before do
-      # Respond with 400, If we don't get a http Host header,
-      halt 400, "Unable to find HTTP Host header" if @env['HTTP_HOST'] == nil
-    end
-
-    after do
-      headers 'Server' => 'Apache-Deltacloud/' + settings.version
-      headers 'X-Deltacloud-Driver' => driver_name
-      if provider_name
-        headers 'X-Deltacloud-Provider' => provider_name
-      end
-    end
-
-    def self.new_route_for(route, &block)
-      get route_for('/' + route.to_s + '/new') do
-        instance_eval(&block) if block_given?
-        respond_to do |format|
-          format.html do
-            haml :"#{route}/new"
-          end
-        end
-      end
-    end
-
-    def self.check_features(opts={})
-      Sinatra::Rabbit.set :check_features, opts[:for]
-    end
-
-    def self.route_for(url)
-      "#{settings.root_url}#{url}"
-    end
-
-  end
-end

data/lib/deltacloud/helpers/deltacloud_helper.rb

@@ -18,22 +18,6 @@ module Deltacloud::Helpers
 
     require 'benchmark'
 
-    def supported_collections
-      collection_arr = []
-      Deltacloud::Collections.deltacloud_modules.each do |m|
-        m.collections.each do |c|
-          # Get the required capability for the :index operation (like 'realms' or 'instance_state_machine')
-          index_operation_capability = c.operation(:index).required_capability
-          # Then use this capability to check if the 'capability' lambda defined
-          # for the Sinatra::Base class evaluate to 'true'
-          next if m.settings.respond_to?(:capability) and !m.settings.capability(index_operation_capability)
-          yield c if block_given?
-          collection_arr << c
-        end
-      end
-      collection_arr
-    end
-
     def auth_feature_name
       return 'key' if driver.class.has_feature?(:instances, :authentication_key)
       return 'password' if driver.class.has_feature?(:instances, :authentication_password)
@@ -49,18 +33,10 @@ module Deltacloud::Helpers
     end
 
     def filter_all(model)
-      filter = {}
-      filter.merge!(:id => params[:id]) if params[:id]
-      filter.merge!(:architecture => params[:architecture]) if params[:architecture]
-      filter.merge!(:owner_id => params[:owner_id]) if params[:owner_id]
-      filter.merge!(:state => params[:state]) if params[:state]
-      filter = {} if filter.keys.size.eql?(0)
       begin
-        @benchmark = Benchmark.measure do
-          @elements = driver.send(model.to_sym, credentials, filter)
-        end
-      rescue
-        @exception = $!
+        @benchmark = Benchmark.measure { @elements = driver.send(model.to_sym, credentials, params) }
+      rescue => e
+        @exception = e
       end
       if @elements
         headers['X-Backend-Runtime'] = @benchmark.real.to_s
@@ -105,9 +81,24 @@ module Deltacloud::Helpers
       @error, @code = (request.env['sinatra.error'] || @exception), code
       @code = 500 if not @code and not @error.class.method_defined? :code
       response.status = @code || @error.code
+      log = Deltacloud::ExceptionHandler.logger
+      message = @error.respond_to?(:message) ? @error.message : translate_error_code(@code)
+      backtrace = (@error.respond_to?(:backtrace) and !@error.backtrace.nil?) ?
+        "\n\n#{@error.backtrace[0..10].join("\n")}\n\n" : ''
+      log.error "[#{@code}] #{[@error.class.to_s, message].join(':')}#{backtrace}"
       respond_to do |format|
         format.xml {  haml :"errors/#{@code || @error.code}", :layout => false }
-        format.html { haml :"errors/#{@code || @error.code}", :layout => :error }
+        format.json { xml_to_json("errors/#{@code || @error.code}") }
+        format.html {
+          begin
+            haml :"errors/#{@code || @error.code}", :layout => :error
+          rescue RuntimeError
+            # If the HTML representation of error is missing, then try to report
+            # it through XML
+            @media_type=:xml
+            haml :"errors/#{@code || @error.code}", :layout => false
+          end
+        }
       end
     end
 
@@ -286,6 +277,53 @@ module Deltacloud::Helpers
       not features_arr.empty?
     end
 
+    module SinatraHelper
+
+      def new_route_for(route, &block)
+        get '/%s/new' % route.to_s do
+          instance_eval(&block) if block_given?
+          respond_to do |format|
+            format.html do
+              haml :"#{route}/new"
+            end
+          end
+        end
+      end
+
+      def check_features(opts={})
+        Sinatra::Rabbit.set :check_features, opts[:for]
+      end
+
+    end
+
+    def Application.included(klass)
+      klass.extend SinatraHelper
+    end
+
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
+
+    def h(s)
+      s.to_s.gsub(/[&"><]/n) { |special| HTML_ESCAPE[special] }
+    end
+
+    def bt(trace)
+      return trace.join("\n") if params['fulltrace']
+      app_path = File::expand_path("../../..", __FILE__)
+      dots = false
+
+        trace = trace.map { |t| t.match(%r{^#{app_path}(.*)$}) ? "$app#{$1}" : "..." }.select do |t|
+        if t == "..."
+          keep = ! dots
+          dots = true
+        else
+          keep = true
+          dots = false
+        end
+        keep
+      end
+      "[\nAbbreviated trace\n   pass fulltrace=1 as query param to see everything\n  $app = #{app_path}\n]\n" + trace.join("\n")
+    end
+
     private
     def hardware_property_unit(prop)
       u = ::Deltacloud::HardwareProfile::unit(prop)

data/lib/deltacloud/helpers/driver_helper.rb

@@ -17,6 +17,13 @@ module Deltacloud::Helpers
 
   module Drivers
 
+    # This will make the Driver helpers, like 'driver'
+    # accessible on class level
+    #
+    def Drivers.included(klass)
+      klass.extend Deltacloud::Helpers::Drivers
+    end
+
     def driver_symbol
       driver_name.to_sym
     end

data/lib/deltacloud/helpers/rabbit_helper.rb

@@ -32,3 +32,54 @@ Sinatra::Rabbit::Collection.class_eval do
 
 end
 
+module Sinatra::Rabbit
+
+  module URLHelper
+    def url_for(path); url(path); end
+    def root_url; settings.root_url; end
+    def base_uri; url_for('/').gsub(/\/$/,''); end
+  end
+
+  def self.URLFor(collections)
+    collections.each do |c|
+      c.operations.each do |operation|
+        URLHelper.instance_eval(&generate_url_helper_for(c, operation)[0])
+      end
+    end
+    URLHelper
+  end
+
+  def self.generate_url_helper_for(collection, operation)
+    operation_name = operation.operation_name.to_s
+    collection_name = collection.collection_name.to_s
+
+    # Construct OPERATION_COLLECTION_URL helper
+    # The :index and :create operation does not get any prefix
+    #
+
+    helper_method_name = case operation_name
+                         when 'index' then collection_name
+                         when 'show' then collection_name.singularize
+                         else operation_name + '_' + collection_name.singularize
+                         end
+
+    helper_method_name += '_url'
+
+    [Proc.new do
+      define_method helper_method_name do |*args|
+        if (opts = args.first).kind_of? Hash
+          path = operation.full_path.convert_query_params(opts)
+        elsif !args.empty? and (obj_id = args.first)
+          path = operation.full_path.convert_query_params(:id => obj_id)
+        elsif operation_name == 'show'
+          path = collection.operation(:index).full_path
+        else
+          path = operation.full_path
+        end
+        path.slice!(root_url)
+        url(path)
+      end unless respond_to?(helper_method_name)
+    end, helper_method_name]
+  end
+
+end

data/lib/deltacloud/server.rb

@@ -36,20 +36,20 @@ module Deltacloud
     use Deltacloud[:deltacloud].logger unless RUBY_PLATFORM == 'java'
     use Rack::Date
     use Rack::ETag
-    use Rack::MatrixParams
     use Rack::DriverSelect
-    use Rack::Accept
-    use Rack::MediaType
 
     include Deltacloud::Helpers
     include Deltacloud::Collections
 
+    helpers Sinatra::Rabbit::URLFor(Deltacloud.collections)
+
     set :config, Deltacloud[:deltacloud]
 
-    get Deltacloud.config[:deltacloud].root_url + '/?' do
+    get '/' do
       if params[:force_auth]
         return [401, 'Authentication failed'] unless driver.valid_credentials?(credentials)
       end
+      @collections = driver.supported_collections(credentials)
       respond_to do |format|
         format.xml { haml :"api/show" }
         format.json { xml_to_json :"api/show" }
@@ -57,24 +57,22 @@ module Deltacloud
       end
     end
 
-    options Deltacloud.config[:deltacloud].root_url + '/?' do
-      headers 'Allow' => supported_collections { |c| c.collection_name }.join(',')
+    options '/' do
+      headers 'Allow' => driver.supported_collections(credentials) { |c| c.collection_name }.join(',')
     end
 
-    post Deltacloud.config[:deltacloud].root_url + '/?' do
+    post '/' do
       param_driver, param_provider = params["driver"], params["provider"]
       if param_driver
-        redirect "#{Deltacloud.config[:deltacloud].root_url}\;driver=#{param_driver}", 301
+        redirect "#{root_url};driver=#{param_driver}", 301
       elsif param_provider && param_provider != "default"
-#FIXME NEEDS A BETTER WAY OF GRABBING CURRENT DRIVER FROM MATRIX PARAMS...
-        current_matrix_driver = env['HTTP_REFERER'] ? env["HTTP_REFERER"].match(/\;(driver)=(\w*).*$/i) : nil
-        if current_matrix_driver
-          redirect "#{Deltacloud.config[:deltacloud].root_url}\;driver=#{$2}\;provider=#{param_provider}", 301
+        if request.referrer and request.referrer[/\;(driver)=(\w*).*$/i]
+          redirect "#{root_url};driver=#{$2}\;provider=#{param_provider}", 301
         else
-          redirect "#{Deltacloud.config[:deltacloud].root_url}\;provider=#{param_provider}", 301
+          redirect "#{root_url};provider=#{param_provider}", 301
         end
       else
-        redirect "#{Deltacloud.config[:deltacloud].root_url}", 301
+        redirect url('/'), 301
       end
     end
 

data/lib/deltacloud/version.rb

@@ -15,5 +15,5 @@
 # under the License.
 
 module Deltacloud
-  API_VERSION = '1.0.3' unless defined?(API_VERSION)
+  API_VERSION = '1.0.4' unless defined?(API_VERSION)
 end

data/lib/deltacloud_rack.rb

@@ -42,6 +42,10 @@ module Deltacloud
     Deltacloud[frontend].klass eval('::'+Deltacloud[frontend].klass)
   end
 
+  def self.enabled_frontends
+    @config.keys.select { |k| frontend_required?(k) }.map { |f| Deltacloud[f] }
+  end
+
   def self.frontend_required?(frontend)
     true unless Deltacloud[frontend].klass.kind_of? String
   end
@@ -52,6 +56,26 @@ module Deltacloud
     @default_frontend || config[:deltacloud]
   end
 
+  require 'sinatra/base'
+  require_relative './deltacloud/helpers/deltacloud_helper'
+  require_relative './sinatra/rack_accept'
+
+  class IndexApp < Sinatra::Base
+
+    helpers Deltacloud::Helpers::Application
+    register Rack::RespondTo
+
+    set :views, File.join(File.dirname(__FILE__), '..', 'views')
+
+    get '/' do
+      respond_to do |format|
+        format.xml { haml :'index', :layout => false }
+        format.html { haml :'index', :layout => false }
+        format.json { xml_to_json "index" }
+      end
+    end
+  end
+
   class Server
 
     attr_reader :name
@@ -66,8 +90,8 @@ module Deltacloud
       @root_url = opts[:root_url]
       @version = opts[:version]
       @klass = opts[:klass]
-      @logger = opts[:logger] || Rack::DeltacloudLogger
-      @default_driver = opts[:default_driver] || :mock
+      @logger = opts[:logger] || Rack::DeltacloudLogger.setup(ENV['API_LOG'], ENV['API_VERBOSE'])
+      @default_driver = opts[:default_driver] || ENV['API_DRIVER'] || :mock
       instance_eval(&block)
     end
 

data/lib/ec2/query_parser.rb

@@ -20,7 +20,7 @@ module Deltacloud::EC2
     MAPPINGS = {
       :describe_availability_zones => { :method => :realms, :params => { 'ZoneName.1' => :id } },
       :describe_images => { :method => :images, :params => { 'ImageId.1' => :id }},
-      :describe_instances => { :method => :instances, :params => {} },
+      :describe_instances => { :method => :instances, :params => {'InstanceId.1' => :id } },
       :describe_key_pairs => { :method => :keys, :params => {} },
       :create_key_pair => { :method => :create_key, :params => { 'KeyName' => :key_name }},
       :delete_key_pair => { :method => :destroy_key, :params => { 'KeyName' => :id }},
@@ -56,14 +56,29 @@ module Deltacloud::EC2
     def perform!(credentials, driver)
       @result = case deltacloud_method
         when :create_instance then driver.send(deltacloud_method, credentials, deltacloud_method_params.delete(:image_id), deltacloud_method_params)
-        when :stop_instance then driver.send(deltacloud_method, credentials, deltacloud_method_params.delete(:id))
-        when :start_instance then driver.send(deltacloud_method, credentials, deltacloud_method_params.delete(:id))
+        when :stop_instance then instance_action(driver, deltacloud_method, credentials, deltacloud_method_params.delete(:id))
+        when :start_instance then instance_action(driver, deltacloud_method, credentials, deltacloud_method_params.delete(:id))
         when :destroy_instance then driver.send(deltacloud_method, credentials, deltacloud_method_params.delete(:id))
         when :reboot_instance then driver.send(deltacloud_method, credentials, deltacloud_method_params.delete(:id))
         else driver.send(deltacloud_method, credentials, deltacloud_method_params)
       end
     end
 
+    # Some drivers, like RHEV-M does not return the instance object
+    # but just notify client that the action was executed successfully.
+    #
+    # If we not received an Instance object, then we need to do additional
+    # query.
+    #
+    def instance_action(driver, action, credentials, id)
+      instance = driver.send(action, credentials, id)
+      if instance.kind_of? Instance
+        instance
+      else
+        driver.instance(credentials, :id => id)
+      end
+    end
+
     def to_xml(context)
       ResultParser.parse(action, @result, context)
     end

data/lib/sinatra/rack_accept.rb

@@ -23,6 +23,9 @@ module Rack
     # We need to overide the default render method to supply correct path to the
     # template, since Sinatra is by default looking in the current __FILE__ path
     def self.registered(app)
+      app.use Rack::Accept
+      app.use Rack::MediaType
+      app.helpers Rack::RespondTo::Helpers
       app.class_eval do
         alias :render_without_format :render
         def render(*args, &block)
@@ -48,12 +51,14 @@ module Rack
       # rack-accept middleware.
       def self.included(klass)
         klass.class_eval do
-          alias :content_type_without_save :content_type
+          alias_method :original_content_type, :content_type
+
           def content_type(*args)
-            content_type_without_save(*args)
+            original_content_type(*args)
             request.env['rack-accept.formats'] = { args.first.to_sym => 1 }
             response['Content-Type']
           end
+
         end
       end