bbrowning-deltacloud-core 0.0.4-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,273 @@
+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(&block)
+        op = self
+        @control = Proc.new do
+          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