steamcannon-deltacloud-core 0.0.7.1-java

data/lib/sinatra/accept_media_types.rb

@@ -0,0 +1,128 @@
+module Rack
+  class Request
+    # The media types of the HTTP_ACCEPT header ordered according to their
+    # "quality" (preference level), without any media type parameters.
+    #
+    # ===== Examples
+    #
+    #   env['HTTP_ACCEPT']  #=> 'application/xml;q=0.8,text/html,text/plain;q=0.9'
+    #
+    #   req = Rack::Request.new(env)
+    #   req.accept_media_types          #=> ['text/html', 'text/plain', 'application/xml']
+    #   req.accept_media_types.prefered #=>  'text/html'
+    #
+    # For more information, see:
+    # * Acept header:   http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+    # * Quality values: http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.9
+    #
+    # ===== Returns
+    # AcceptMediaTypes:: ordered list of accept header's media types
+    #
+    def accept_media_types
+       @accept_media_types ||= Rack::AcceptMediaTypes.new(@env['HTTP_ACCEPT'])
+    end
+  end
+
+  # AcceptMediaTypes is intended for wrapping env['HTTP_ACCEPT'].
+  #
+  # It allows ordering of its values (accepted media types) according to their
+  # "quality" (preference level).
+  #
+  # This wrapper is typically used to determine the request's prefered media
+  # type (see example below).
+  #
+  # ===== Examples
+  #
+  #   env['HTTP_ACCEPT']  #=> 'application/xml;q=0.8,text/html,text/plain;q=0.9'
+  #
+  #   types = Rack::AcceptMediaTypes.new(env['HTTP_ACCEPT'])
+  #   types               #=> ['text/html', 'text/plain', 'application/xml']
+  #   types.prefered      #=>  'text/html'
+  #
+  # ===== Notes
+  #
+  # For simplicity, media type parameters are striped, as they are seldom used
+  # in practice. Users who need them are excepted to parse the Accept header
+  # manually.
+  #
+  # ===== References
+  #
+  # HTTP 1.1 Specs:
+  # * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+  # * http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.9
+  #
+  class AcceptMediaTypes < Array
+
+    #--
+    # NOTE
+    # Reason for special handling of nil accept header:
+    #
+    # "If no Accept header field is present, then it is assumed that the client
+    # accepts all media types."
+    #
+    def initialize(header)
+      if header.nil?
+        replace(['*/*'])
+      else
+        replace(order(header.gsub(/ /, '').split(/,/)))
+      end
+    end
+
+    # The client's prefered media type.
+    def prefered
+      first
+    end
+
+    private
+
+    # Order media types by quality values, remove invalid types, and return media ranges.
+    #
+    def order(types) #:nodoc:
+      types.map {|type| AcceptMediaType.new(type) }.reverse.sort.reverse.select {|type| type.valid? }.map {|type| type.range }
+    end
+
+    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+    #
+    class AcceptMediaType #:nodoc:
+      include Comparable
+
+      # media-range = ( "*/*"
+      #               | ( type "/" "*" )
+      #               | ( type "/" subtype )
+      #               ) *( ";" parameter )
+      attr_accessor :range
+
+      # qvalue = ( "0" [ "." 0*3DIGIT ] )
+      #        | ( "1" [ "." 0*3("0") ] )
+      attr_accessor :quality
+
+      def initialize(type)
+        self.range, *params = type.split(';')
+        self.quality = extract_quality(params)
+      end
+
+      def <=>(type)
+        self.quality <=> type.quality
+      end
+
+      # "A weight is normalized to a real number in the range 0 through 1,
+      # where 0 is the minimum and 1 the maximum value. If a parameter has a
+      # quality value of 0, then content with this parameter is `not
+      # acceptable' for the client."
+      #
+      def valid?
+        self.quality.between?(0.1, 1)
+      end
+
+      private
+        # Extract value from 'q=FLOAT' parameter if present, otherwise assume 1
+        #
+        # "The default value is q=1."
+        #
+        def extract_quality(params)
+          q = params.detect {|p| p.match(/q=\d\.?\d{0,3}/) }
+          q ? q.split('=').last.to_f : 1.0
+        end
+    end
+  end
+end

data/lib/sinatra/lazy_auth.rb

@@ -0,0 +1,56 @@
+require 'sinatra/base'
+
+# Lazy Basic HTTP authentication. Authentication is only forced when the
+# credentials are actually needed.
+module Sinatra
+  module LazyAuth
+    class LazyCredentials
+      def initialize(app)
+        @app = app
+        @provided = false
+      end
+
+      def user
+        credentials!
+        @user
+      end
+
+      def password
+        credentials!
+        @password
+      end
+
+      def provided?
+        @provided
+      end
+
+      private
+      def credentials!
+        unless provided?
+          auth = Rack::Auth::Basic::Request.new(@app.request.env)
+          unless auth.provided? && auth.basic? && auth.credentials
+            @app.authorize!
+          end
+          @user = auth.credentials[0]
+          @password = auth.credentials[1]
+          @provided = true
+        end
+      end
+
+    end
+
+    def authorize!
+      r = "#{DRIVER}-deltacloud@#{HOSTNAME}"
+      response['WWW-Authenticate'] = %(Basic realm="#{r}")
+      throw(:halt, [401, "Not authorized\n"])
+    end
+
+    # Request the current user's credentials. Actual credentials are only
+    # requested when an attempt is made to get the user name or password
+    def credentials
+      LazyCredentials.new(self)
+    end
+  end
+
+  helpers LazyAuth
+end

data/lib/sinatra/rabbit.rb

@@ -0,0 +1,279 @@
+require 'sinatra/base'
+require 'sinatra/url_for'
+require 'deltacloud/validation'
+
+module Sinatra
+
+  module Rabbit
+
+    class DuplicateParamException < Exception; end
+    class DuplicateOperationException < Exception; end
+    class DuplicateCollectionException < Exception; end
+
+    class Operation
+      attr_reader :name, :method
+
+      include ::Deltacloud::Validation
+
+      STANDARD = {
+        :index => { :method => :get, :member => false },
+        :show =>  { :method => :get, :member => true },
+        :create => { :method => :post, :member => false },
+        :update => { :method => :put, :member => true },
+        :destroy => { :method => :delete, :member => true }
+      }
+
+      def initialize(coll, name, opts, &block)
+        @name = name.to_sym
+        opts = STANDARD[@name].merge(opts) if standard?
+        @collection = coll
+        raise "No method for operation #{name}" unless opts[:method]
+        @method = opts[:method].to_sym
+        @member = opts[:member]
+        @description = ""
+        instance_eval(&block) if block_given?
+        generate_documentation
+      end
+
+      def standard?
+        STANDARD.keys.include?(name)
+      end
+
+      def description(text="")
+        return @description if text.blank?
+        @description = text
+      end
+
+      def generate_documentation
+        coll, oper = @collection, self
+        ::Sinatra::Application.get("/api/docs/#{@collection.name}/#{@name}") do
+          @collection, @operation = coll, oper
+          respond_to do |format|
+            format.html { haml :'docs/operation' }
+            format.xml { haml :'docs/operation' }
+          end
+        end
+      end
+
+      def control(opts=nil, &block)
+        op = self
+        @control = Proc.new do
+          if opts and
+              opts[:with_feature] and
+              !driver.respond_to?(opts[:with_feature])
+            raise Deltacloud::BackendFeatureUnsupported.new('501', nil,
+              "#{opts[:with_feature]} not supported by backend", nil)
+          end
+          op.validate(params)
+          instance_eval(&block)
+        end
+      end
+
+      def prefix
+        # FIXME: Make the /api prefix configurable
+        "/api"
+      end
+
+      def path(args = {})
+        l_prefix = args[:prefix] ? args[:prefix] : prefix
+        if @member
+          if standard?
+            "#{l_prefix}/#{@collection.name}/:id"
+          else
+            "#{l_prefix}/#{@collection.name}/:id/#{name}"
+          end
+        else
+          "#{l_prefix}/#{@collection.name}"
+        end
+      end
+
+      def generate
+        ::Sinatra::Application.send(@method, path, {}, &@control)
+        # Set up some Rails-like URL helpers
+        if name == :index
+          gen_route "#{@collection.name}_url"
+        elsif name == :show
+          gen_route "#{@collection.name.to_s.singularize}_url"
+        else
+          gen_route "#{name}_#{@collection.name.to_s.singularize}_url"
+        end
+      end
+
+      private
+      def gen_route(name)
+        route_url = path
+        if @member
+          ::Sinatra::Application.send(:define_method, name) do |id, *args|
+            url = query_url(route_url, args[0])
+            url_for url.gsub(/:id/, id.to_s), :full
+          end
+        else
+          ::Sinatra::Application.send(:define_method, name) do |*args|
+            url = query_url(route_url, args[0])
+            url_for url, :full
+          end
+        end
+      end
+    end
+
+    class Collection
+      attr_reader :name, :operations
+
+      def initialize(name, &block)
+        @name = name
+        @description = ""
+        @operations = {}
+        instance_eval(&block) if block_given?
+        generate_documentation
+      end
+
+      # Set/Return description for collection
+      # If first parameter is not present, full description will be
+      # returned.
+      def description(text='')
+        return @description if text.blank?
+        @description = text
+      end
+
+      def generate_documentation
+        coll, oper, features = self, @operations, driver.features(name)
+        ::Sinatra::Application.get("/api/docs/#{@name}") do
+          @collection, @operations, @features = coll, oper, features
+          respond_to do |format|
+            format.html { haml :'docs/collection' }
+            format.xml { haml :'docs/collection' }
+          end
+        end
+      end
+
+      # Add a new operation for this collection. For the standard REST
+      # operations :index, :show, :update, and :destroy, we already know
+      # what method to use and whether this is an operation on the URL for
+      # individual elements or for the whole collection.
+      #
+      # For non-standard operations, options must be passed:
+      #  :method : one of the HTTP methods
+      #  :member : whether this is an operation on the collection or an
+      #            individual element (FIXME: custom operations on the
+      #            collection will use a nonsensical URL) The URL for the
+      #            operation is the element URL with the name of the operation
+      #            appended
+      #
+      # This also defines a helper method like show_instance_url that returns
+      # the URL to this operation (in request context)
+      def operation(name, opts = {}, &block)
+        raise DuplicateOperationException if @operations[name]
+        @operations[name] = Operation.new(self, name, opts, &block)
+      end
+
+      def generate
+        operations.values.each { |op| op.generate }
+        app = ::Sinatra::Application
+        collname = name # Work around Ruby's weird scoping/capture
+        app.send(:define_method, "#{name.to_s.singularize}_url") do |id|
+            url_for "/api/#{collname}/#{id}", :full
+        end
+
+        if index_op = operations[:index]
+          app.send(:define_method, "#{name}_url") do
+            url_for index_op.path.gsub(/\/\?$/,''), :full
+          end
+        end
+      end
+
+      def add_feature_params(features)
+        features.each do |f|
+          f.operations.each do |fop|
+            if cop = operations[fop.name]
+              fop.params.each_key do |k|
+                if cop.params.has_key?(k)
+                  raise DuplicateParamException, "Parameter '#{k}' for operation #{fop.name} defined by collection #{@name} and by feature #{f.name}"
+                else
+                  cop.params[k] = fop.params[k]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def collections
+      @collections ||= {}
+    end
+
+    # Create a new collection. NAME should be the pluralized name of the
+    # collection.
+    #
+    # Adds a helper method #{name}_url which returns the URL to the :index
+    # operation on this collection.
+    def collection(name, &block)
+      raise DuplicateCollectionException if collections[name]
+      return unless driver.has_collection?(name.to_sym)
+      collections[name] = Collection.new(name, &block)
+      collections[name].add_feature_params(driver.features(name))
+      collections[name].generate
+    end
+
+    # Generate a root route for API docs
+    get '/api/docs\/?' do
+      respond_to do |format|
+        format.html { haml :'docs/index' }
+        format.xml { haml :'docs/index' }
+      end
+    end
+
+  end
+
+  module RabbitHelper
+    def query_url(url, params)
+      return url if params.nil? || params.empty?
+      url + "?#{URI.escape(params.collect{|k,v| "#{k}=#{v}"}.join('&'))}"
+    end
+
+    def entry_points
+      collections.values.inject([]) do |m, coll|
+        url = url_for coll.operations[:index].path, :full
+        m << [ coll.name, url ]
+      end
+    end
+  end
+
+  register Rabbit
+  helpers RabbitHelper
+end
+
+class String
+  # Rails defines this for a number of other classes, including Object
+  # see activesupport/lib/active_support/core_ext/object/blank.rb
+  def blank?
+      self !~ /\S/
+  end
+
+  # Title case.
+  #
+  #   "this is a string".titlecase
+  #   => "This Is A String"
+  #
+  # CREDIT: Eliazar Parra
+  # Copied from facets
+  def titlecase
+    gsub(/\b\w/){ $`[-1,1] == "'" ? $& : $&.upcase }
+  end
+
+  def pluralize
+    self + "s"
+  end
+
+  def singularize
+    self.gsub(/s$/, '')
+  end
+
+  def underscore
+      gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+  end
+end

data/lib/sinatra/respond_to.rb

@@ -0,0 +1,238 @@
+# 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 Sinatra
+  module RespondTo
+
+    class MissingTemplate < Sinatra::NotFound; end
+
+    # Define all MIME types you want to support here.
+    # This conversion table will be used for auto-negotiation
+    # with browser in sinatra when no 'format' parameter is specified.
+
+    SUPPORTED_ACCEPT_HEADERS = {
+      :xml => [
+        'text/xml',
+        'application/xml'
+      ],
+      :html => [
+        'text/html',
+        'application/xhtml+xml'
+      ],
+      :json => [
+        'application/json'
+      ]
+    }
+
+    # We need to pass array of available response types to
+    # best_media_type method
+    def accept_to_array
+      SUPPORTED_ACCEPT_HEADERS.keys.collect do |key|
+        SUPPORTED_ACCEPT_HEADERS[key]
+      end.flatten
+    end
+
+    # Then, when we get best media type for response, we need
+    # to know which format to choose
+    def lookup_format_from_mime(mime)
+      SUPPORTED_ACCEPT_HEADERS.keys.each do |format|
+        return format if SUPPORTED_ACCEPT_HEADERS[format].include?(mime)
+      end
+    end
+
+    def self.registered(app)
+
+      app.helpers RespondTo::Helpers
+
+      app.before do
+
+        # Skip development error image and static content
+        next if self.class.development? && request.path_info =~ %r{/__sinatra__/.*?.png}
+        next if options.static? && options.public? && (request.get? || request.head?) && static_file?(request.path_info)
+
+        # Remove extension from URI
+        # Extension will be available as a 'extension' method (extension=='txt')
+       
+        extension request.path_info.match(/\.([^\.\/]+)$/).to_a.first
+
+        # If ?format= is present, ignore all Accept negotiations because
+        # we are not dealing with browser
+        if request.params.has_key? 'format'
+          format params['format'].to_sym
+        end
+        
+        # Let's make a little exception here to handle
+        # /api/instance_states[.gv/.png] calls
+        if extension.eql?('gv')
+          format :gv
+        elsif extension.eql?('png')
+          format :png
+        end
+
+        # Get Rack::Accept::Response object and find best possible
+        # mime type to output.
+        # This negotiation works fine with latest rest-client gem:
+        #
+        # RestClient.get 'http://localhost:3001/api', {:accept => :json } =>
+        # 'application/json'
+        # RestClient.get 'http://localhost:3001/api', {:accept => :xml } =>
+        # 'application/xml'
+        #
+        # Also browsers like Firefox (3.6.x) and Chromium reporting
+        # 'application/xml+xhtml' which is recognized as :html reponse
+        # In browser you can force output using ?format=[format] parameter.
+
+        rack_accept = env['rack-accept.request']
+
+        if rack_accept.media_type.to_s.strip.eql?('Accept:')
+          format :xml
+        else
+          format lookup_format_from_mime(rack_accept.best_media_type(accept_to_array))
+        end
+
+      end
+
+      app.class_eval do
+        # This code was copied from respond_to plugin
+        # http://github.com/cehoffman/sinatra-respond_to
+        # MIT License
+        alias :render_without_format :render
+        def render(*args, &block)
+          assumed_layout = args[1] == :layout
+          args[1] = "#{args[1]}.#{format}".to_sym if args[1].is_a?(::Symbol)
+          render_without_format *args, &block
+        rescue Errno::ENOENT => e
+          raise MissingTemplate, "#{args[1]}.#{args[0]}" unless assumed_layout
+          raise e
+        end
+        private :render
+      end
+
+      # This code was copied from respond_to plugin
+      # http://github.com/cehoffman/sinatra-respond_to
+      app.configure :development do |dev|
+        dev.error MissingTemplate do
+          content_type :html, :charset => 'utf-8'
+          response.status = request.env['sinatra.error'].code
+
+          engine = request.env['sinatra.error'].message.split('.').last
+          engine = 'haml' unless ['haml', 'builder', 'erb'].include? engine
+
+          path = File.basename(request.path_info)
+          path = "root" if path.nil? || path.empty?
+
+          format = engine == 'builder' ? 'xml' : 'html'
+
+          layout = case engine
+                   when 'haml' then "!!!\n%html\n  %body= yield"
+                   when 'erb' then "<html>\n  <body>\n    <%= yield %>\n  </body>\n</html>"
+                   end
+
+          layout = "<small>app.#{format}.#{engine}</small>\n<pre>#{escape_html(layout)}</pre>"
+
+          (<<-HTML).gsub(/^ {10}/, '')
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <style type="text/css">
+            body { text-align:center;font-family:helvetica,arial;font-size:22px;
+              color:#888;margin:20px}
+            #c {margin:0 auto;width:500px;text-align:left;}
+            small {float:right;clear:both;}
+            pre {clear:both;text-align:left;font-size:70%;width:500px;margin:0 auto;}
+            </style>
+          </head>
+          <body>
+            <h2>Sinatra can't find #{request.env['sinatra.error'].message}</h2>
+            <img src='/__sinatra__/500.png'>
+            <pre>#{request.env['sinatra.error'].backtrace.join("\n")}</pre>
+            <div id="c">
+              <small>application.rb</small>
+              <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  respond_to do |wants|\n    wants.#{format} { #{engine} :#{path} }\n  end\nend</pre>
+            </div>
+          </body>
+          </html>
+          HTML
+        end
+
+      end
+    end
+
+    module Helpers
+
+      # This code was copied from respond_to plugin
+      # http://github.com/cehoffman/sinatra-respond_to
+      def self.included(klass)
+        klass.class_eval do
+          alias :content_type_without_save :content_type
+          def content_type(*args)
+            content_type_without_save *args
+            @_format = args.first.to_sym
+            response['Content-Type']
+          end
+        end
+      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
+
+
+      # Extension holds trimmed extension. This is extra usefull
+      # when you want to build original URI (with extension)
+      # You can simply call "#{request.env['REQUEST_URI']}.#{extension}"
+      def extension(val=nil)
+        @_extension ||= val
+        @_extension
+      end
+      
+      # This helper will holds current format. Helper should be
+      # accesible from all places in Sinatra
+      def format(val=nil)
+        @_format ||= val
+        @_format
+      end
+
+      def respond_to(&block)
+        wants = {}
+        
+        def wants.method_missing(type, *args, &handler)
+          self[type] = handler
+        end
+        
+        # Set proper content-type and encoding for
+        # text based formats
+        if [:xml, :gv, :html, :json].include?(format)
+          content_type format, :charset => 'utf-8'
+        end
+        yield wants
+        # Raise this error if requested format is not defined
+        # in respond_to { } block.
+        raise MissingTemplate if wants[format].nil?
+
+        wants[format].call
+      end
+
+    end
+
+  end
+end