goliath 0.9.1 → 0.9.2

data/examples/rasterize/rasterize_and_shorten.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+$: << File.dirname(__FILE__)+'/../../lib'
+require File.dirname(__FILE__)+'/rasterize'
+
+require 'goliath'
+require 'em-synchrony/em-http'
+require 'postrank-uri'
+
+#
+# Aroundware: while the Rasterize API is processing, this uses http://is.gd to
+# generate a shortened link, stuffing it in the header. Both requests happen
+# simultaneously.
+#
+class ShortenURL < Goliath::Synchrony::MultiReceiver
+  SHORTENER_URL_BASE = 'http://is.gd/create.php'
+
+  def pre_process
+    target_url = PostRank::URI.clean(env.params['url'])
+    shortener_request = EM::HttpRequest.new(SHORTENER_URL_BASE).aget(:query => { :format => 'simple', :url => target_url })
+    enqueue :shortener, shortener_request
+  end
+
+  def post_process
+    if successes[:shortener]
+      headers['X-Shortened-URI'] = successes[:shortener].response
+    end
+    [status, headers, body]
+  end
+end
+
+class RasterizeAndShorten < Rasterize
+  use Goliath::Rack::Params
+  use Goliath::Rack::Validation::RequestMethod, %w(GET)
+  use Goliath::Rack::Validation::RequiredParam, {:key => 'url'}
+  #
+  use Goliath::Rack::AsyncAroundware, ShortenURL
+end

data/examples/stream.rb

@@ -21,7 +21,7 @@ class Stream < Goliath::API
   def response(env)
     i = 0
     pt = EM.add_periodic_timer(1) do
-      env.stream_send("#{i} ")
+      env.stream_send("#{i}\n")
       i += 1
     end
 
@@ -32,6 +32,6 @@ class Stream < Goliath::API
       env.stream_close
     end
 
-    [200, {}, Goliath::Response::STREAMING]
+    streaming_response(202, {'X-Stream' => 'Goliath'})
   end
 end

data/examples/template.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+$:<< '../lib' << 'lib'
+
+# A simple dashboard for goliath
+# See
+#   examples/views              -- templates
+#   examples/public             -- static files
+#   examples/config/template.rb -- configuration
+#
+# The templating is based on, but not as fancy-pants as, Sinatra's. Notably,
+# your template's extension must match the engine (foo.markdown, not foo.md)
+
+require 'tilt'
+# use bluecloth as default markdown renderer
+require 'bluecloth'
+Tilt.register 'markdown', Tilt::BlueClothTemplate
+require 'yajl/json_gem'
+
+require 'goliath'
+require 'goliath/rack/templates'
+require 'goliath/plugins/latency'
+
+class Template < Goliath::API
+  include Goliath::Rack::Templates      # render templated files from ./views
+
+  use(Rack::Static,                     # render static files from ./public
+            :root => Goliath::Application.app_path("public"),
+            :urls => ["/favicon.ico", '/stylesheets', '/javascripts', '/images'])
+
+  plugin Goliath::Plugin::Latency       # ask eventmachine reactor to track its latency
+
+  def recent_latency
+    Goliath::Plugin::Latency.recent_latency
+  end
+
+  def response(env)
+    case env['PATH_INFO']
+    when '/'         then [200, {}, haml(:root)]
+    when '/debug'    then [200, {}, haml(:debug)]
+    when '/oops'     then [200, {}, haml(:no_such_template)] # will 500
+    when '/joke'     then
+      [200, {}, markdown(:joke, :locals => {:title => "HERE IS A JOKE"})]
+    when '/erb_me'   then
+      [200, {}, markdown(:joke, :layout_engine => :erb, :locals => {:title => "HERE IS A JOKE"})]
+    else                  raise Goliath::Validation::NotFoundError
+    end
+  end
+end

data/examples/test_rig.rb

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+$:<< '../lib' << 'lib'
+
+require 'goliath'
+
+#
+# A test endpoint that will:
+# * with 'delay' parameter, take the given time to respond
+# * with 'drop' parameter, drop connection before responding
+# * with 'fail' parameter, raise an error of the given type (eg 400 raises a BadRequestError)
+# * with 'echo_status', 'echo_headers', or 'echo_body' parameter, replace the given component directly.
+#
+
+# If the delay param is given, sleep for that many seconds
+#
+# Note that though this is non-blocking, the call chain does *not* proceed in parallel
+class Delay
+  include Goliath::Rack::AsyncMiddleware
+
+  def post_process(env, status, headers, body)
+    if delay = env.params['delay']
+      delay = [0, [delay.to_f, 5].min].max
+      EM::Synchrony.sleep(delay)
+      body.merge!(:delay => delay, :actual => (Time.now.to_f - env[:start_time]))
+    end
+    [status, headers, body]
+  end
+end
+
+# if the middleware_failure parameter is given, raise an error causing that
+# status code
+class MiddlewareFailure
+  include Goliath::Rack::AsyncMiddleware
+
+  def call(env)
+    if code = env.params['fail']
+      raise Goliath::Validation::Error.new(code.to_i, "Middleware error #{code}")
+    end
+    super
+  end
+end
+
+# if the drop_pre  parameter is given, close the connection before headers are sent
+# This works, but probably does awful awful things to Goliath's innards
+class DropConnection
+  include Goliath::Rack::AsyncMiddleware
+
+  def call(env)
+    if env.params['drop'].to_s == 'true'
+      env.logger.info "Dropping connection"
+      env.stream_close
+      [0, {}, '']
+    else
+      super
+    end
+  end
+end
+
+# if echo_status, echo_headers or echo_body are given, blindly substitute their
+# value, clobbering whatever was there.
+#
+# If you are going to use echo_headers you probably need to use a JSON post body:
+#   curl -v -H "Content-Type: application/json" --data-ascii '{"echo_headers":{"X-Question":"What is brown and sticky"},"echo_body":{"answer":"a stick"}}' 'http://127.0.0.1:9001/'
+#
+class Echo
+  include Goliath::Rack::AsyncMiddleware
+
+  def post_process env, status, headers, body
+    if env.params['echo_status']
+      status = env.params['echo_status'].to_i
+    end
+    if env.params['echo_headers']
+      headers = env.params['echo_headers']
+    end
+    if env.params['echo_body']
+      body = env.params['echo_body']
+    end
+    [status, headers, body]
+  end
+end
+
+# Rescue validation errors and send them up the chain as normal non-200 responses
+class ExceptionHandler
+  include Goliath::Rack::AsyncMiddleware
+  include Goliath::Rack::Validator
+
+  def call(env)
+    begin
+      super
+    rescue Goliath::Validation::Error => e
+      validation_error(e.status_code, e.message)
+    end
+  end
+end
+
+class TestRig < Goliath::API
+  use Goliath::Rack::Tracer             # log trace statistics
+  use Goliath::Rack::Params             # parse & merge query and body parameters
+  #
+  use Goliath::Rack::DefaultMimeType    # cleanup accepted media types
+  use Goliath::Rack::Render, 'json'     # auto-negotiate response format
+  #
+  use ExceptionHandler                  # turn raised errors into HTTP responses
+  use MiddlewareFailure                 # make response fail if 'fail' param
+  use DropConnection                    # drop connection if 'drop' param
+  use Echo                              # replace status, headers or body if 'echo_status' etc given
+  use Delay                             # make response take X seconds if 'delay' param
+
+  def on_headers(env, headers)
+    env['client-headers'] = headers
+  end
+
+  def response(env)
+    query_params = env.params.collect { |param| param.join(": ") }
+    query_headers = env['client-headers'].collect { |param| param.join(": ") }
+
+    headers = {
+      "Special" => "Header",
+      "Params"  => query_params.join("|"),
+      "Path"    => env[Goliath::Request::REQUEST_PATH],
+      "Headers" => query_headers.join("|"),
+      "Method"  => env[Goliath::Request::REQUEST_METHOD]}
+    [200, headers, headers.dup]
+  end
+end

data/examples/valid.rb

@@ -5,10 +5,12 @@ require 'goliath'
 
 class Valid < Goliath::API
   use Goliath::Rack::Params
-  use Goliath::Rack::ValidationError
-
   use Goliath::Rack::Validation::RequiredParam, {:key => 'test'}
 
+  # If you are using Golaith version <=0.9.1 you need to use Goliath::Rack::ValidationError
+  # to prevent the request from remaining open after an error occurs
+  #use Goliath::Rack::ValidationError
+
   def response(env)
     [200, {}, 'OK']
   end

data/examples/views/debug.haml

@@ -0,0 +1,4 @@
+%h1 Debug
+
+%pre
+  = JSON.pretty_generate(env)

data/examples/views/joke.markdown

@@ -0,0 +1,13 @@
+# Pirate Joke
+
+Pirate walks into a bar with a steering wheel half-in, half-out of his pants.
+
+
+Bartender says 
+
+    "Hey Pirate, What's With The Steering Wheel?"
+
+
+Pirate says 
+
+    "Arr, I dunno matey -- but it's drivin' me nuts!"

data/examples/views/layout.erb

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title><%= title || 'Goliath' %></title>
+  </head>
+  <body lang='en'>
+    <h1 id='title'><%= title || 'Goliath' %> - I AM ERB</h1>
+
+<%= yield %>
+
+  </body>
+</html>

data/examples/views/layout.haml

@@ -0,0 +1,39 @@
+- title ||= 'Goliath'
+!!! 5
+%html
+  %head
+    %meta{ :charset => "utf-8" }/
+    %meta{ :content => "IE=edge,chrome=1", "http-equiv" => "X-UA-Compatible" }/
+
+    %title= title
+    <link href="data:image/x-icon;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQEAYAAABPYyMiAAAABmJLR0T///////8JWPfcAAAACXBIWXMAAABIAAAASABGyWs+AAAAF0lEQVRIx2NgGAWjYBSMglEwCkbBSAcACBAAAeaR9cIAAAAASUVORK5CYII=" rel="icon" type="image/x-icon" />
+    %link{ :href => "/stylesheets/style.css", :rel => "stylesheet", :type => "text/css", :media => "all" }
+
+  %body{ :lang => 'en' }
+    #header-container
+      %header.wrapper
+        %h1#title
+          == <a href="/">#{title}</a>
+
+        %nav
+          %ul.menu
+            %li.item
+              <a href="/">Home</a>
+            %li.item
+              <a href="/debug">Debug</a>
+            %li &nbsp;
+
+    #main.wrapper{ :role => 'main' }
+      != yield
+
+    #footer-container
+      %footer.wrapper
+        .copyright
+          %p Copyright &copy; #{Time.now.strftime("%Y")}
+
+    %script{ :src => "http://ajax.googleapis.com/ajax/libs/jquery/1.4.4/jquery.min.js", :type => "text/javascript" }/
+    :javascript
+      !window.jQuery && document.write(unescape('%3Cscript src="/javascripts/jquery.min.js"%3E%3C/script%3E'))
+
+    /
+      haml layout

data/examples/views/root.haml

@@ -0,0 +1,28 @@
+%h2 Routes
+
+%ul
+  %li <a href="/joke">Tell me a joke</a>
+  %li <a href="/erb_me">Tell me a joke, but with a boring .erb layout</a>
+  %li <a href="/debug">debug info</a>
+  %li <a href="/oops">Template missing</a>
+
+%h2 Dashboard
+
+%table.vertical
+  %tr
+    %th  Script
+    %td= $0
+  %tr
+    %th  Server Port
+    %td= env['SERVER_PORT']
+  %tr
+    %th  Latency
+    %td= recent_latency
+  %tr
+    %th  Request took
+    %td= (Time.now.to_f - env[:start_time]).round(3)
+  %tr
+    %th  Config
+    %td
+      %pre
+        = "\n"+JSON.pretty_generate(env.config)

data/goliath.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>=1.9.2'
 
-  s.add_dependency 'eventmachine', '>= 1.0.0.beta.1'
+  s.add_dependency 'eventmachine', '>= 1.0.0.beta.3'
   s.add_dependency 'em-synchrony', '>= 0.3.0.beta.1'
   s.add_dependency 'http_parser.rb'
   s.add_dependency 'log4r'
@@ -24,7 +24,9 @@ Gem::Specification.new do |s|
   s.add_dependency 'rack-respond_to'
   s.add_dependency 'async-rack'
   s.add_dependency 'multi_json'
+  s.add_dependency 'http_router', '~> 0.8.9'
 
+  s.add_development_dependency 'rake', '0.8.7'
   s.add_development_dependency 'rspec', '>2.0'
   s.add_development_dependency 'nokogiri'
   s.add_development_dependency 'em-http-request', '>= 1.0.0.beta.1'
@@ -34,10 +36,15 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'multipart_body'
   s.add_development_dependency 'amqp', '>=0.7.1'
 
+  s.add_development_dependency 'tilt', '>=1.2.2'
+  s.add_development_dependency 'haml', '>=3.0.25'
   s.add_development_dependency 'yard'
   s.add_development_dependency 'bluecloth'
 
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- spec/*`.split("\n")
+  ignores = File.readlines(".gitignore").grep(/\S+/).map {|s| s.chomp }
+  dotfiles = [".gemtest", ".gitignore", ".rspec", ".yardopts"]
+
+  s.files = Dir["**/*"].reject {|f| File.directory?(f) || ignores.any? {|i| File.fnmatch(i, f) } } + dotfiles
+  s.test_files = s.files.grep(/^spec\//)
   s.require_paths = ['lib']
 end

data/lib/goliath.rb

@@ -1,38 +1,2 @@
-require 'eventmachine'
-require 'http/parser'
-require 'async_rack'
-require 'stringio'
-
-require 'goliath/version'
-require 'goliath/goliath'
-require 'goliath/runner'
-require 'goliath/server'
-require 'goliath/constants'
-require 'goliath/connection'
-require 'goliath/request'
-require 'goliath/response'
-require 'goliath/headers'
-require 'goliath/http_status_codes'
-
-require 'goliath/rack/default_response_format'
-require 'goliath/rack/heartbeat'
-require 'goliath/rack/params'
-require 'goliath/rack/render'
-require 'goliath/rack/default_mime_type'
-require 'goliath/rack/tracer'
-require 'goliath/rack/validation_error'
-require 'goliath/rack/formatters/json'
-require 'goliath/rack/formatters/html'
-require 'goliath/rack/formatters/xml'
-require 'goliath/rack/jsonp'
-
-require 'goliath/rack/validation/request_method'
-require 'goliath/rack/validation/required_param'
-require 'goliath/rack/validation/required_value'
-require 'goliath/rack/validation/numeric_range'
-require 'goliath/rack/validation/default_params'
-require 'goliath/rack/validation/boolean_value'
-
 require 'goliath/api'
-
 require 'goliath/application'

data/lib/goliath/api.rb

@@ -1,5 +1,9 @@
+require 'http_router'
+require 'goliath/goliath'
 require 'goliath/response'
 require 'goliath/request'
+require 'goliath/rack'
+require 'goliath/validation'
 
 module Goliath
   # All Goliath APIs subclass Goliath::API. All subclasses _must_ override the
@@ -15,19 +19,33 @@ module Goliath
   #  end
   #
   class API
+    include Goliath::Constants
+    include Goliath::Rack::Validator
+
     class << self
+      # Catches the userland class which inherits the Goliath API
+      #
+      # In case of further subclassing, the very last class encountered is used.
+      def inherited(subclass)
+        Goliath::Application.app_class = subclass.name if defined?(Goliath::Application)
+      end
+
       # Retrieves the middlewares defined by this API server
       #
       # @return [Array] array contains [middleware class, args, block]
       def middlewares
         @middlewares ||= []
-        @middlewares.unshift([::Goliath::Rack::DefaultResponseFormat, nil, nil])
-        @middlewares.unshift([::Rack::ContentLength, nil, nil])
 
-        if Goliath.dev?
-           reloader = @middlewares.detect {|mw| mw.first == ::Rack::Reloader}
-           @middlewares.unshift([::Rack::Reloader, 0, nil]) if !reloader
-         end
+        unless @loaded_default_middlewares
+          @middlewares.unshift([::Goliath::Rack::DefaultResponseFormat, nil, nil])
+          @middlewares.unshift([::Rack::ContentLength, nil, nil])
+
+          if Goliath.dev? && !@middlewares.detect {|mw| mw.first == ::Rack::Reloader}
+            @middlewares.unshift([::Rack::Reloader, 0, nil])
+          end
+
+          @loaded_default_middlewares = true
+        end
 
         @middlewares
       end
@@ -44,8 +62,16 @@ module Goliath
       # @param name [Class] The middleware class to use
       # @param args Any arguments to pass to the middeware
       # @param block A block to pass to the middleware
-      def use(name, args = nil, &block)
+      def use(name, *args, &block)
         @middlewares ||= []
+
+        if name == Goliath::Rack::Render
+          [args].flatten.each do |type|
+            type = Goliath::Rack::Formatters.const_get type.upcase
+            @middlewares << [type, nil, nil]
+          end
+        end
+
         @middlewares << [name, args, block]
       end
 
@@ -69,11 +95,15 @@ module Goliath
 
       # Returns the router maps configured for the API
       #
-      # @return [Array] array contains [path, block]
+      # @return [Array] array contains [path, klass, block]
       def maps
         @maps ||= []
       end
 
+      def maps?
+        !maps.empty?
+      end
+
       # Specify a router map to be used by the API
       #
       # @example
@@ -81,10 +111,53 @@ module Goliath
       #    run Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["Version 0.1"]] }
       #  end
       #
-      # @param name [String] The URL path to map
+      # @example
+      #  map '/user/:id', :id => /\d+/ do
+      #    # params[:id] will be a number
+      #    run Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["Loading user #{params[:id]}"]] }
+      #  end
+      #
+      # @param name [String] The URL path to map.
+      #   Optional parts are supported via <tt>(.:format)</tt>, variables as <tt>:var</tt> and globs via <tt>*remaining_path</tt>.
+      #   Variables can be validated by supplying a Regexp.
+      # @param klass [Class] The class to retrieve the middlewares from
       # @param block The code to execute
-      def map(name, &block)
-        maps.push([name, block])
+      def map(name, *args, &block)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        klass = args.first
+        if klass && block_given?
+          raise "Can't provide class and block to map"
+        end
+        maps.push([name, klass, opts, block])
+      end
+
+      [:get, :post, :head, :put, :delete].each do |http_method|
+        class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{http_method}(name, *args, &block)
+          opts = args.last.is_a?(Hash) ? args.pop : {}
+          klass = args.first
+          opts[:conditions] ||= {}
+          opts[:conditions][:request_method] = [#{http_method == :get ? "'HEAD', 'GET'" : http_method.to_s.upcase.inspect}]
+          map(name, klass, opts, &block)
+        end
+        EOT
+      end
+
+      def router
+        unless @router
+          @router = HttpRouter.new
+          @router.default(proc{ |env|
+            @router.routes.last.dest.call(env)
+          })
+        end
+        @router
+      end
+
+      # Use to define the 404 routing logic. As well, define any number of other paths to also run the not_found block.
+      def not_found(*other_paths, &block)
+        app = ::Rack::Builder.new(&block).to_app
+        router.default(app)
+        other_paths.each {|path| router.add(path).to(app) }
       end
     end
 
@@ -107,7 +180,7 @@ module Goliath
     #
     # @return [Goliath::Env] The current environment data for the request
     def env
-      Thread.current[Goliath::Constants::GOLIATH_ENV]
+      Thread.current[GOLIATH_ENV]
     end
 
     # The API will proxy missing calls to the env object if possible.
@@ -128,32 +201,42 @@ module Goliath
       end
     end
 
+    # @param name [Symbol] The method to check if we respond to it.
+    # @return [Boolean] True if the API's method_missing responds to the method
+    def respond_to_missing?(name, *)
+      env.respond_to? name
+    end
+
     # {#call} is executed automatically by the middleware chain and will setup
     # the environment for the {#response} method to execute. This includes setting
-    # up a new Fiber, handing any execptions thrown from the API and executing
+    # up a new Fiber, handing any exceptions thrown from the API and executing
     # the appropriate callback method for the API.
     #
     # @param env [Goliath::Env] The request environment
     # @return [Goliath::Connection::AsyncResponse] An async response.
     def call(env)
-      Fiber.new {
-        begin
-          Thread.current[Goliath::Constants::GOLIATH_ENV] = env
-          status, headers, body = response(env)
+      begin
+        Thread.current[GOLIATH_ENV] = env
+        status, headers, body = response(env)
 
+        if status
           if body == Goliath::Response::STREAMING
-            env[Goliath::Constants::STREAM_START].call(status, headers)
+            env[STREAM_START].call(status, headers)
           else
-            env[Goliath::Constants::ASYNC_CALLBACK].call([status, headers, body])
+            env[ASYNC_CALLBACK].call([status, headers, body])
           end
+        end
 
-        rescue Exception => e
-          env.logger.error(e.message)
-          env.logger.error(e.backtrace.join("\n"))
+      rescue Goliath::Validation::Error => e
+        env[RACK_EXCEPTION] = e
+        env[ASYNC_CALLBACK].call(validation_error(e.status_code, e.message))
 
-          env[Goliath::Constants::ASYNC_CALLBACK].call([400, {}, {:error => e.message}])
-        end
-      }.resume
+      rescue Exception => e
+        env.logger.error(e.message)
+        env.logger.error(e.backtrace.join("\n"))
+        env[RACK_EXCEPTION] = e
+        env[ASYNC_CALLBACK].call(validation_error(500, e.message))
+      end
 
       Goliath::Connection::AsyncResponse
     end
@@ -168,7 +251,35 @@ module Goliath
     # @return [Array] Array contains [Status code, Headers Hash, Body]
     def response(env)
       env.logger.error('You need to implement response')
-      [400, {}, {:error => 'No response implemented'}]
+      raise Goliath::Validation::InternalServerError.new('No response implemented')
+    end
+
+    # Helper method for streaming response apis.
+    #
+    # @param status_code [Integer] The status code to return (200 by default).
+    # @param headers [Hash] Headers to return.
+    def streaming_response(status_code = 200, headers = {})
+      [status_code, headers, Goliath::Response::STREAMING]
+    end
+
+    # Helper method for chunked transfer streaming response apis
+    #
+    # Chunked transfer streaming is transparent to all clients (it's just as
+    # good as a normal response), but allows an aware client to begin consuming
+    # the stream even as it's produced.
+    #
+    # * http://en.wikipedia.org/wiki/Chunked_transfer_encoding
+    # * http://developers.sun.com/mobility/midp/questions/chunking/
+    # * http://blog.port80software.com/2006/11/08/
+    #
+    # @param status_code [Integer] The status code to return.
+    # @param headers [Hash] Headers to return. The Transfer-Encoding=chunked
+    #   header is set for you.
+    #
+    # If you are using chunked streaming, you must use
+    # env.chunked_stream_send and env.chunked_stream_close
+    def chunked_streaming_response(status_code = 200, headers = {})
+      streaming_response(status_code, headers.merge(Goliath::Response::CHUNKED_STREAM_HEADERS))
     end
   end
 end