deltacloud-core 0.3.0 → 0.4.0

data/lib/sinatra/rack_accept.rb

@@ -0,0 +1,157 @@
+# respond_to (The MIT License)
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+# and associated documentation files (the 'Software'), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge, publish, distribute,
+# sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+# NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
+
+require 'sinatra/base'
+require 'rack/accept'
+
+use Rack::Accept
+
+module Rack
+
+  module RespondTo
+    
+    # This method is triggered after this helper is registred
+    # within Sinatra.
+    # 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.helpers Rack::RespondTo::Helpers
+      app.class_eval do
+        alias :render_without_format :render
+        def render(*args, &block)
+          begin
+            assumed_layout = args[1] == :layout
+            args[1] = "#{args[1]}.#{@media_type}".to_sym if args[1].is_a?(::Symbol)
+            render_without_format *args, &block
+          rescue Errno::ENOENT => e
+            raise "ERROR: Missing template: #{args[1]}.#{args[0]}" unless assumed_layout
+            raise e
+          end
+        end
+        private :render
+      end
+    end
+
+      module Helpers
+
+        # This code was inherited from respond_to plugin
+        # http://github.com/cehoffman/sinatra-respond_to
+        #
+        # This method is used to overide the default content_type returned from
+        # rack-accept middleware.
+        def self.included(klass)
+          klass.class_eval do
+            alias :content_type_without_save :content_type
+            def content_type(*args)
+              content_type_without_save *args
+              request.env['rack-accept.formats'] = { args.first.to_sym => 1 }
+              response['Content-Type']
+            end
+          end
+        end
+
+        def accepting_formats
+          request.env['rack-accept.formats']
+        end
+
+        def static_file?(path)
+          public_dir = File.expand_path(options.public)
+          path = File.expand_path(File.join(public_dir, unescape(path)))
+          path[0, public_dir.length] == public_dir && File.file?(path)
+        end
+
+        def respond_to(&block)
+          wants = {}
+          def wants.method_missing(type, *args, &handler)
+            self[type] = handler
+          end
+          yield wants
+          @media_type = accepting_formats.to_a.sort { |a,b| a[1]<=>b[1] }.reverse.select do |format, priority|
+            wants.keys.include?(format) == true
+          end.first
+          if @media_type and @media_type[0]
+            @media_type = @media_type[0]
+            headers 'Content-Type' => Rack::MediaType::ACCEPTED_MEDIA_TYPES[@media_type][:return]
+            wants[@media_type.to_sym].call if wants[@media_type.to_sym]
+          else
+            headers 'Content-Type' => nil
+            status 406
+          end
+        end
+
+    end
+
+  end
+
+  class MediaType < Sinatra::Base
+
+    include Rack::RespondTo::Helpers
+
+    # Define supported media types here
+    # The :return key stands for content-type which will be returned
+    # The :match key stands for the matching Accept header 
+    ACCEPTED_MEDIA_TYPES = {
+      :xml => { :return => 'application/xml', :match => ['application/xml', 'text/xml'] },
+      :json => { :return => 'application/json', :match => ['application/json'] },
+      :html => { :return => 'text/html', :match => ['application/xhtml+xml', 'text/html', '*/*'] },
+      :png => { :return => 'image/png', :match => ['image/png'] },
+      :gv => { :return => 'application/ghostscript', :match => ['application/ghostscript'] }
+    }
+
+    def call(env)
+      accept, index = env['rack-accept.request'], {}
+
+      # Skip everything when 'format' parameter is set in URL
+      if env['rack.request.query_hash']["format"]
+         media_type = case env['rack.request.query_hash']["format"]
+            when 'html' then :html 
+            when 'xml' then :xml
+            when 'json' then :json
+            when 'gv' then :gv
+            when 'png' then :png
+          end
+        index[media_type] = 1 if media_type
+      else
+        # Sort all requested media types in Accept using their 'q' values
+        sorted_media_types = accept.media_type.qvalues.to_a.sort{ |a,b| a[1]<=>b[1] }.collect { |t| t.first }
+        # If Accept header is missing or is empty, fallback to XML format
+        sorted_media_types << 'application/xml' if sorted_media_types.empty?
+        # Choose the right format with the media type according to the priority
+        ACCEPTED_MEDIA_TYPES.each do |format, definition|
+          definition[:match].each do |media_type|
+            break if index[format] = sorted_media_types.index(media_type)
+          end
+        end
+        # Reject formats with no/nil priority
+        index.reject! { |format, priority| not priority }
+      end
+
+      #puts sorted_media_types.inspect
+      #puts index.inspect
+      
+      # If after all we don't have any matching format assume that client has
+      # requested unknown/wrong media type and throw an 406 error with no body
+      if index.keys.empty?
+        status, headers, response = 406, {}, ""
+      else
+        env['rack-accept.formats'] = index
+        status, headers, response = @app.call(env)
+      end
+      [status, headers, response]
+    end
+
+  end
+
+end
+

data/lib/sinatra/rack_date.rb

@@ -0,0 +1,38 @@
+
+# Copyright (c) 2008 The Committers
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'time'
+
+module Rack
+  class Date
+
+    def initialize(app, no_cache_control = nil, cache_control = nil)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers['Date'] = Time.new.httpdate if not headers['Date']
+      [status, headers, body]
+    end
+
+  end
+end
+

data/lib/sinatra/rack_etag.rb

@@ -30,11 +30,10 @@ module Rack
   # used when Etag is absent and a directive when it is present. The first
   # defaults to nil, while the second defaults to "max-age=0, privaute, must-revalidate"
   class ETag
-    DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate".freeze
 
-    def initialize(app, no_cache_control = nil, cache_control = DEFAULT_CACHE_CONTROL)
+    def initialize(app, no_cache_control = nil, cache_control = nil)
       @app = app
-      @cache_control = cache_control
+      @cache_control = cache_control || "max-age=0, private, must-revalidate"
       @no_cache_control = no_cache_control
     end
 

data/lib/sinatra/rack_matrix_params.rb

@@ -36,46 +36,68 @@ module Rack
     #
     # All HTTP methods are supported, in case of POST they will be passed as a
     # regular <form> parameters.
-    
+
     def call(env)
       # Copy PATH_INFO to REQUEST_URI if Rack::Test
       env['REQUEST_URI'] = env['PATH_INFO'] if env['rack.test']
+      env['REQUEST_PATH'] = env['PATH_INFO'] if env['rack.test']
 
       # Split URI to components and then extract ;var=value pairs
       uri_components = env['REQUEST_URI'].split('/')
       matrix_params = {}
       uri_components.each do |component|
-	sub_components, value = component.split(/\;(\w+)\=/), nil
-	next unless sub_components.first  # Skip subcomponent if it's empty (usually /)
-	while param=sub_components.pop do
-	  if value
-	    matrix_params[sub_components.first] ||= {}
-	    matrix_params[sub_components.first].merge!(
-	      param => value
-	    )
-	    value=nil
-	    next
-	  else
-	    value = param
-	  end
-	end
+        sub_components, value = component.split(/\;(\w+)\=/), nil
+        next unless sub_components.first  # Skip subcomponent if it's empty (usually /)
+        while param=sub_components.pop do
+          if value
+            matrix_params[sub_components.first] ||= {}
+            matrix_params[sub_components.first].merge!(
+                                                       param => value
+                                                       )
+            value=nil
+            next
+          else
+            value = param.gsub(/\?.*$/, '')
+          end
+        end
       end
 
-      # If request method is POST, simply include matrix params in form_hash
-      env['rack.request.form_hash'].merge!(matrix_params) if env['rack.request.form_hash']
+      # Two things need to happen to make matrix params work:
+      #     (1) the parameters need to be appended to the 'normal' params
+      #         for the request. 'Normal' really depends on the content
+      #         type of the request, which does not seem accessible from
+      #         Middleware, so we use the existence of
+      #         rack.request.form_hash in the environment to distinguish
+      #         between basic and application/x-www-form-urlencoded
+      #         requests
+      #     (2) the parameters need to be stripped from the appropriate
+      #         path related env variables, so that request dispatching
+      #         does not trip over them
+
+      # (1) Rewrite current path by stripping all matrix params from it
+      if env['REQUEST_PATH'] == '/'
+        env['REQUEST_URI'] = env['REQUEST_PATH']
+        env['REQUEST_PATH'] = env['PATH_INFO']
+      end
+      env['REQUEST_PATH'] = env['REQUEST_PATH'].gsub(/;([^\/]*)/, '').gsub(/\?(.*)$/, '')
+      env['PATH_INFO'] = env['REQUEST_PATH']
 
-      # For other methods it's a way complicated ;-)
-      if env['REQUEST_METHOD']!='POST' and not matrix_params.keys.empty?
-	# Rewrite current path and query string and strip all matrix params from it
-	env['REQUEST_PATH'], env['PATH_INFO'] = env['REQUEST_URI'].gsub(/;([^\/]*)/, '').gsub(/\?(.*)$/, '')
-	env['PATH_INFO'] = env['REQUEST_PATH']
-	env['QUERY_STRING'].gsub!(/;([^\/]*)/, '')
-	new_params = matrix_params.collect do |component, params|
-	  params.collect { |k,v| "#{component}[#{k}]=#{CGI::escape(v.to_s)}" }
-	end.flatten
-	# Add matrix params as a regular GET params
-	env['QUERY_STRING'] += '&' if not env['QUERY_STRING'].empty?
-	env['QUERY_STRING'] += "#{new_params.join('&')}"
+      # (2) Append the matrix params to the 'normal' request params
+      # FIXME: Make this work for multipart/form-data
+      if env['rack.request.form_hash']
+        # application/x-www-form-urlencoded, most likely a POST
+        env['rack.request.form_hash'].merge!(matrix_params)
+      else
+        # For other methods it's more complicated
+        if env['REQUEST_METHOD']!='POST' and not matrix_params.keys.empty?
+          env['QUERY_STRING'].gsub!(/;([^\/]*)/, '')
+          new_params = matrix_params.collect do |component, params|
+            params.collect { |k,v| "#{component}[#{k}]=#{CGI::escape(v.to_s)}" }
+          end.flatten
+          # Add matrix params as a regular GET params
+          env['QUERY_STRING'] += '&' if not env['QUERY_STRING'].empty?
+          env['QUERY_STRING'] += "#{new_params.join('&')}"
+        end
       end
       @app.call(env)
     end

data/lib/sinatra/rack_runtime.rb

@@ -39,7 +39,7 @@ module Rack
       if !headers.has_key?(@header_name)
         headers[@header_name] = "%0.6f" % request_time
       end
-      
+
       [status, headers, body]
     end
   end

data/lib/sinatra/rack_syslog.rb

@@ -0,0 +1,86 @@
+require 'syslog'
+require 'lib/sinatra/body_proxy'
+
+class SyslogFile < File
+
+  def initialize
+    @log = Syslog.open($0, Syslog::LOG_PID | Syslog::LOG_LOCAL5)
+  end
+
+  def write(string)
+    @log.warning(string) if string.strip.length > 0
+    return string.chars.count
+  end
+
+  def info(msg)
+    @log.info(msg)
+  end
+
+  def err(msg)
+    @log.err(msg)
+  end
+
+  alias :warning :err
+
+end
+
+# Code bellow was originaly copied from Rack::CommonLogger
+# https://raw.github.com/rack/rack/master/lib/rack/commonlogger.rb
+
+module Rack
+  # Rack::CommonLogger forwards every request to an +app+ given, and
+  # logs a line in the Apache common log format to the +logger+, or
+  # rack.errors by default.
+  class SyslogLogger
+
+    # Common Log Format: http://httpd.apache.org/docs/1.3/logs.html#common
+    # lilith.local - - [07/Aug/2006 23:58:02] "GET / HTTP/1.1" 500 -
+    #             %{%s - %s [%s] "%s %s%s %s" %d %s\n} %
+    FORMAT = %{%s - %s [%s] "%s %s%s %s" %d %s %0.4f\n}
+
+    def initialize(app, logger=nil)
+      @app = app
+      @logger = logger || $stdout
+    end
+
+    def call(env)
+      began_at = Time.now
+      status, header, body = @app.call(env)
+      header = Utils::HeaderHash.new(header)
+      body = Rack::BodyProxy.new(body) { log(env, status, header, began_at) }
+      [status, header, body]
+    end
+
+    private
+
+    def log(env, status, header, began_at)
+      now = Time.now
+      length = extract_content_length(header)
+
+      if status.to_s =~ /5(\d{2})/
+        method = :err
+      else
+        method = :info
+      end
+
+      logger = @logger || env['rack.errors']
+      logger.send(method, FORMAT % [
+        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
+        env["REMOTE_USER"] || "-",
+        now.strftime("%d/%b/%Y %H:%M:%S"),
+        env["REQUEST_METHOD"],
+        env["PATH_INFO"],
+        env["QUERY_STRING"].empty? ? "" : "?"+env["QUERY_STRING"],
+        env["HTTP_VERSION"],
+        status.to_s[0..3],
+        length,
+        now - began_at ])
+    end
+
+    def extract_content_length(headers)
+      value = headers['Content-Length'] or return '-'
+      value.to_s == '0' ? '-' : value
+    end
+  end
+end
+

data/lib/sinatra/url_for.rb

@@ -28,6 +28,19 @@ require 'uri'
 
 module Sinatra
   module UrlForHelper
+
+    DEFAULT_URI_PREFIX = "/api"
+
+    def api_url_for(url_fragment, mode=:path_only)
+      matrix_params = ''
+      if request.params['api']
+        matrix_params += ";provider=%s" % request.params['api']['provider'] if request.params['api']['provider']
+        matrix_params += ";driver=%s" % request.params['api']['driver'] if request.params['api']['driver']
+      end
+      url_fragment = "/#{url_fragment}" unless url_fragment =~ /^\// # There is no need to prefix URI with '/'
+      url_for "#{DEFAULT_URI_PREFIX}#{matrix_params}#{url_fragment}", mode
+    end
+
     # Construct a link to +url_fragment+, which should be given relative to
     # the base of this Sinatra app.  The mode should be either
     # <code>:path_only</code>, which will generate an absolute path within
@@ -70,7 +83,7 @@ module Sinatra
     end
 
     def root_url
-      url_for '/'
+      DEFAULT_URI_PREFIX
     end
   end