goliath 0.9.0

data/lib/goliath/plugins/latency.rb

@@ -0,0 +1,33 @@
+module Goliath
+  module Plugin
+    # Report latency information about the EventMachine reactor to the log file.
+    #
+    # @example
+    #  plugin Goliath::Plugin::Latency
+    #
+    class Latency
+      # Called by the framework to initialize the plugin
+      #
+      # @param port [Integer] Unused
+      # @param config [Hash] The server configuration data
+      # @param status [Hash] A status hash
+      # @param logger [Log4R::Logger] The logger
+      # @return [Goliath::Plugin::Latency] An instance of the Goliath::Plugin::Latency plugin
+      def initialize(port, config, status, logger)
+        @status = status
+        @config = config
+        @logger = logger
+
+        @last = Time.now.to_f
+      end
+
+      # Called automatically to start the plugin
+      def run
+        EM.add_periodic_timer(1) do
+          @logger.info "LATENCY: #{Time.now.to_f - @last}"
+          @last = Time.now.to_f
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/default_mime_type.rb

@@ -0,0 +1,30 @@
+require 'rack/mime'
+require 'rack/respond_to'
+
+module Goliath
+  module Rack
+    # Does some basic cleanup / handling of the HTTP_ACCEPT header.
+    # This will remove gzip, deflate, compressed and identity. If
+    # there are no values left the header will be set to \*/\*.
+    #
+    # @example
+    #   use Goliath::Rack::DefaultMimeType
+    #
+    class DefaultMimeType
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        accept = env['HTTP_ACCEPT'] || ''
+        accept = accept.split(/\s*,\s*/)
+        accept.delete_if { |a| a =~ /gzip|deflate|compressed|identity/ }
+        accept = accept.join(", ")
+
+        env['HTTP_ACCEPT'] = accept
+        env['HTTP_ACCEPT'] = '*/*' if env['HTTP_ACCEPT'] == ''
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/goliath/rack/default_response_format.rb

@@ -0,0 +1,33 @@
+module Goliath
+  module Rack
+    class DefaultResponseFormat
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        async_cb = env['async.callback']
+        env['async.callback'] = Proc.new do |status, headers, body|
+          async_cb.call(post_process(status, headers, body))
+        end
+
+        status, headers, body = @app.call(env)
+        post_process(status, headers, body)
+      end
+
+      def post_process(status, headers, body)
+        return [status, headers, body] if body.respond_to?(:to_ary)
+
+        new_body = []
+        if body.respond_to?(:each)
+          body.each { |chunk| new_body << chunk }
+        else
+          new_body << body
+        end
+        new_body.collect! { |item| item.to_s }
+
+        [status, headers, new_body.flatten]
+      end
+    end
+  end
+end

data/lib/goliath/rack/formatters/html.rb

@@ -0,0 +1,90 @@
+require 'rack'
+
+module Goliath
+  module Rack
+    module Formatters
+      # A simple HTML formatter. This doesn't try to be fancy and just turns
+      # Hashes into tables, Arrays into ordered lists and strings are output
+      # as HTML escaped strings.
+      #
+      # @example
+      #   use Goliath::Rack::Formatters::HTML
+      class HTML
+        # Called by the framework to create the formatter.
+        #
+        # @param app The application
+        # @return [Goliath::Rack::Formatters::HTML] The HTML formatter
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          async_cb = env['async.callback']
+          env['async.callback'] = Proc.new do |status, headers, body|
+            async_cb.call(post_process(status, headers, body))
+          end
+
+          status, headers, body = @app.call(env)
+          post_process(status, headers, body)
+        end
+
+        def post_process(status, headers, body)
+          body = [to_html(body, false)] if html_response?(headers)
+          [status, headers, body]
+        end
+
+        def html_response?(headers)
+          headers['Content-Type'] =~ %r{^text/html}
+        end
+
+        def to_html(content, fragment=true)
+          html_string = ''
+          html_string += html_header unless fragment
+
+          html_string += case(content.class.to_s)
+          when "Hash" then hash_to_html(content)
+          when "Array" then array_to_html(content)
+          when "String" then string_to_html(content)
+          else string_to_html(content)
+          end
+
+          html_string += html_footer unless fragment
+          html_string
+        end
+
+        def string_to_html(content)
+          ::Rack::Utils.escape_html(content.to_s)
+        end
+
+        def hash_to_html(content)
+          html_string = "<table>\n"
+          if content.key?('meta')
+            html_string += "<tr><td>meta</td><td>\n"
+            html_string += to_html(content['meta'])
+            html_string += "</td></tr>\n"
+            content.delete('meta')
+          end
+
+          content.each_pair { |key, value| html_string += "<tr><td>#{to_html(key)}</td><td>#{to_html(value)}</td></tr>\n" }
+          html_string += "</table>\n"
+          html_string
+        end
+
+        def array_to_html(content)
+          html_string = '<ol>\n'
+          content.each { |value| html_string += "<li>#{to_html(value)}</li>\n" }
+          html_string +="</ol>\n"
+          html_string
+        end
+
+        def html_header
+          "<html><body>"
+        end
+
+        def html_footer
+          "</body></html>"
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/formatters/json.rb

@@ -0,0 +1,42 @@
+require 'multi_json'
+
+module Goliath
+  module Rack
+    module Formatters
+      # A JSON formatter. Uses MultiJson so you can use the JSON
+      # encoder that is right for your project.
+      #
+      # @example
+      #   use Goliath::Rack::Formatters::JSON
+      class JSON
+        # Called by the framework to create the formatter.
+        #
+        # @return [Goliath::Rack::Formatters::JSON] The JSON formatter.
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          async_cb = env['async.callback']
+          env['async.callback'] = Proc.new do |status, headers, body|
+            async_cb.call(post_process(status, headers, body))
+          end
+
+          status, headers, body = @app.call(env)
+          post_process(status, headers, body)
+        end
+
+        def post_process(status, headers, body)
+          if json_response?(headers)
+            body = [MultiJson.encode(body)]
+          end
+          [status, headers, body]
+        end
+
+        def json_response?(headers)
+          headers['Content-Type'] =~ %r{^application/(json|javascript)}
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/formatters/xml.rb

@@ -0,0 +1,90 @@
+require 'rack'
+
+module Goliath
+  module Rack
+    module Formatters
+      # A XML formatter. Attempts to convert your data into
+      # an XML document.
+      #
+      # @example
+      #   use Goliath::Rack::Formatters::XML
+      class XML
+        # Called by the framework to create the formatter.
+        #
+        # @return [Goliath::Rack::Formatters::XML] The XML formatter.
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          async_cb = env['async.callback']
+          env['async.callback'] = Proc.new do |status, headers, body|
+            async_cb.call(post_process(status, headers, body))
+          end
+
+          status, headers, body = @app.call(env)
+          post_process(status, headers, body)
+        end
+
+        def post_process(status, headers, body)
+          body = [to_xml(body, false)] if xml_response?(headers)
+          [status, headers, body]
+        end
+
+        def xml_response?(headers)
+          headers['Content-Type'] =~ %r{^application/xml}
+        end
+
+        def to_xml(content, fragment=true, root='results', item='item')
+          xml_string = ''
+          xml_string += xml_header(root) unless fragment
+
+          xml_string += case(content.class.to_s)
+          when "Hash" then hash_to_xml(content, root, item)
+          when "Array" then array_to_xml(content, root, item)
+          when "String" then string_to_xml(content)
+          else string_to_xml(content)
+          end
+
+          xml_string += xml_footer(root) unless fragment
+          xml_string
+        end
+
+        def string_to_xml(content)
+          ::Rack::Utils.escape_html(content.to_s)
+        end
+
+        def hash_to_xml(content, root='results', item='item')
+          xml_string = ''
+          if content.key?('meta')
+            xml_string += xml_item('meta', content['meta'], root)
+            content.delete('meta')
+          end
+
+          content.each_pair { |key, value| xml_string += xml_item(key, value, root) }
+          xml_string
+        end
+
+        def array_to_xml(content, root='results', item='item')
+          xml_string = ''
+          content.each { |value| xml_string += xml_item(item, value, root) }
+          xml_string
+        end
+
+        def xml_header(root)
+          "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
+          "<#{root} xmlns:opensearch='http://a9.com/-/spec/opensearch/1.1/'\n" +
+          "         xmlns:postrank='http://www.postrank.com/xsd/2007-11-30/postrank'>\n"
+        end
+
+        def xml_footer(root)
+          "</#{root}>"
+        end
+
+        def xml_item(key, value, root)
+          "<#{key}>#{to_xml(value, true, root)}</#{key}>\n"
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/heartbeat.rb

@@ -0,0 +1,23 @@
+module Goliath
+  module Rack
+    # A heartbeat mechanism for the server. This will add a _/status_ endpoint
+    # that returns status 200 and content OK when executed.
+    #
+    # @example
+    #  use Goliath::Rack::Heartbeat
+    #
+    class Heartbeat
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env['PATH_INFO'] == '/status'
+          [200, {}, 'OK']
+        else
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/jsonp.rb

@@ -0,0 +1,38 @@
+module Goliath
+  module Rack
+    # A middleware to wrap the response into a JSONP callback.
+    #
+    # @example
+    #  use Goliath::Rack::JSONP
+    #
+    class JSONP
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        async_cb = env['async.callback']
+
+        env['async.callback'] = Proc.new do |status, headers, body|
+          async_cb.call(post_process(env, status, headers, body))
+        end
+        status, headers, body = @app.call(env)
+        post_process(env, status, headers, body)
+      end
+
+      def post_process(env, status, headers, body)
+        return [status, headers, body] unless env.params['callback']
+
+        response = ""
+        if body.respond_to?(:each)
+          body.each { |s| response << s }
+        else
+          response = body
+        end
+
+        [status, headers, ["#{env.params['callback']}(#{response})"]]
+      end
+    end
+  end
+end
+

data/lib/goliath/rack/params.rb

@@ -0,0 +1,30 @@
+require 'rack/utils'
+
+module Goliath
+  module Rack
+    # A middle ware to parse params. This will parse both the
+    # query string parameters and the body and place them into
+    # the _params_ hash of the Goliath::Env for the request.
+    #
+    # @example
+    #  use Goliath::Rack::Params
+    #
+    class Params
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env['params'] = retrieve_params(env)
+        @app.call(env)
+      end
+
+      def retrieve_params(env)
+        params = {}
+        params.merge!(::Rack::Utils.parse_query(env['QUERY_STRING']))
+        params.merge!(::Rack::Utils.parse_query(env['rack.input'].read)) unless env['rack.input'].nil?
+        params
+      end
+    end
+  end
+end

data/lib/goliath/rack/render.rb

@@ -0,0 +1,66 @@
+require 'rack/mime'
+require 'rack/respond_to'
+
+module Goliath
+  module Rack
+    # The render middleware will set the Content-Type of the response
+    # based on the provided HTTP_ACCEPT headers.
+    #
+    # @example
+    #  use Goliath::Rack::Render
+    #
+    class Render
+      include ::Rack::RespondTo
+
+      def initialize(app, types = nil)
+        @app = app
+        ::Rack::RespondTo.media_types = [types].flatten if types
+      end
+
+      def call(env)
+        async_cb = env['async.callback']
+
+        env['async.callback'] = Proc.new do |status, headers, body|
+          async_cb.call(post_process(env, status, headers, body))
+        end
+
+        status, headers, body = @app.call(env)
+        post_process(env, status, headers, body)
+      end
+
+      def post_process(env, status, headers, body)
+        ::Rack::RespondTo.env = env
+
+        # the respond_to block is what actually triggers the
+        # setting of selected_media_type, so it's required
+
+        respond_to do |format|
+          format.json { body }
+          format.html { body }
+          format.xml { body }
+          format.rss { body }
+          format.js { body }
+        end
+
+        extra = { 'Content-Type' => get_content_type(env),
+                  'Server' => 'PostRank Goliath API Server',
+                  'Vary' => [headers.delete('Vary'), 'Accept'].compact.join(',') }
+
+        [status, extra.merge(headers), body]
+      end
+
+      def get_content_type(env)
+        fmt = env.params['format']
+        fmt = fmt.last if fmt.is_a?(Array)
+
+        type = if fmt.nil? || fmt =~ /^\s*$/
+          ::Rack::RespondTo.selected_media_type
+        else
+          ::Rack::RespondTo::MediaType(fmt)
+        end
+
+        "#{type}; charset=utf-8"
+      end
+    end
+  end
+end