RubyGems - webmachine - Versions diffs - 1.1.0 → 1.2.0 - Diffend - OSS supply chain security and management platform

webmachine 1.1.0 → 1.2.0

Files changed (36) hide show

data/Gemfile +5 -4
data/README.md +25 -2
data/examples/debugger.rb +7 -0
data/examples/logging.rb +41 -0
data/lib/webmachine/adapters.rb +1 -1
data/lib/webmachine/adapters/hatetepe.rb +5 -1
data/lib/webmachine/adapters/lazy_request_body.rb +7 -7
data/lib/webmachine/adapters/mongrel.rb +27 -12
data/lib/webmachine/adapters/rack.rb +42 -6
data/lib/webmachine/adapters/reel.rb +91 -23
data/lib/webmachine/adapters/webrick.rb +12 -6
data/lib/webmachine/application.rb +1 -0
data/lib/webmachine/cookie.rb +1 -1
data/lib/webmachine/dispatcher.rb +7 -1
data/lib/webmachine/events.rb +179 -0
data/lib/webmachine/events/instrumented_event.rb +19 -0
data/lib/webmachine/response.rb +1 -1
data/lib/webmachine/streaming/io_encoder.rb +5 -1
data/lib/webmachine/trace.rb +18 -0
data/lib/webmachine/trace/fsm.rb +4 -1
data/lib/webmachine/trace/listener.rb +12 -0
data/lib/webmachine/version.rb +1 -1
data/spec/spec_helper.rb +11 -0
data/spec/support/adapter_lint.rb +125 -0
data/spec/support/test_resource.rb +73 -0
data/spec/webmachine/adapters/hatetepe_spec.rb +2 -2
data/spec/webmachine/adapters/mongrel_spec.rb +6 -51
data/spec/webmachine/adapters/rack_spec.rb +22 -155
data/spec/webmachine/adapters/reel_spec.rb +59 -7
data/spec/webmachine/adapters/webrick_spec.rb +7 -13
data/spec/webmachine/cookie_spec.rb +1 -1
data/spec/webmachine/decision/helpers_spec.rb +10 -0
data/spec/webmachine/events_spec.rb +58 -0
data/spec/webmachine/request_spec.rb +41 -0
data/webmachine.gemspec +1 -1
metadata +63 -24

data/Gemfile CHANGED Viewed

@@ -1,6 +1,6 @@
 require 'rbconfig'
-source :rubygems
+source 'https://rubygems.org'
 gemspec
@@ -8,10 +8,11 @@ gem 'bundler'
 group :webservers do
   gem 'mongrel',  '~> 1.2.beta', :platform => [:mri, :rbx]
   if RUBY_VERSION >= '1.9'
-    gem 'reel',   '>= 0.1.0', :platform => [:ruby_19, :jruby]
-    gem 'nio4r'
+    gem 'reel', '~> 0.3.0', :platform => [:ruby_19, :ruby_20, :jruby]
   end
   gem 'hatetepe', '~> 0.5'
 end
@@ -29,7 +30,7 @@ group :guard do
 end
 group :docs do
-  platform :mri do
+  platform :mri_19, :mri_20 do
     gem 'redcarpet'
   end
 end

data/README.md CHANGED Viewed

@@ -179,14 +179,16 @@ for an example of how to enable the debugger.
 ## Documentation & Finding Help
 * [API documentation](http://rubydoc.info/gems/webmachine/frames/file/README.md)
+* [Mailing list](mailto:webmachine.rb@librelist.com)
 * IRC channel #webmachine on freenode
 ## Related libraries
 * [irwebmachine](https://github.com/robgleeson/irwebmachine) - IRB/Pry debugging of Webmachine applications
 * [webmachine-test](https://github.com/bernd/webmachine-test) - Helpers for testing Webmachine applications
-- [webmachine-linking](https://github.com/petejohanson/webmachine-linking) - Helpers for linking between Resources, and Web Linking
-- [webmachine-sprockets](https://github.com/lgierth/webmachine-sprockets) - Integration with Sprockets assets packaging system
+* [webmachine-linking](https://github.com/petejohanson/webmachine-linking) - Helpers for linking between Resources, and Web Linking
+* [webmachine-sprockets](https://github.com/lgierth/webmachine-sprockets) - Integration with Sprockets assets packaging system
+* [webmachine-actionview](https://github.com/rgarner/webmachine-actionview) - Integration of some Rails-style view conventions into Webmachine
 ## LICENSE
@@ -196,6 +198,27 @@ LICENSE for details.
 ## Changelog
+### 1.2.0
+1.2.0 is a major feature release that adds the Events instrumentation
+framework, support for Websockets in Reel adapter and a bunch of bugfixes.
+Added Justin McPherson and Hendrik Beskow as contributors. Thank you
+for your contributions!
+* Websockets support in Reel adapter.
+* Added `Events` framework implementing ActiveSupport::Notifications
+  instrumentation API.
+* Linked mailing list and related library in README.
+* Fixed operator precedence in `IOEncoder#each`.
+* Fixed typo in Max-Age cookie attribute.
+* Allowed attributes to be set in a `Cookie`.
+* Fixed streaming in Rack adapter from Fiber that is expected
+  to block
+* Added a more comprehensive adapter test suite and fixed various bugs
+  in the existing adapters.
+* Webmachine::LazyRequestBody no longer double-buffers the request
+  body and cannot be rewound.
 ### 1.1.0 January 12, 2013
 1.1.0 is a major feature release that adds the Reel and Hatetepe

data/examples/debugger.rb CHANGED Viewed

@@ -20,7 +20,14 @@ class MyTracedResource < Webmachine::Resource
   end
 end
+class MyTracer
+  def call(name, payload)
+    puts "MyTracer #{name} #{payload.inspect}"
+  end
+end
 # Webmachine::Trace.trace_store = :pstore, "./trace"
+# Webmachine::Trace.trace_listener = [Webmachine::Trace::Listener.new, MyTracer.new]
 TraceExample = Webmachine::Application.new do |app|
   app.routes do

data/examples/logging.rb ADDED Viewed

@@ -0,0 +1,41 @@
+require 'webmachine'
+require 'time'
+require 'logger'
+class HelloResource < Webmachine::Resource
+  def to_html
+    "<html><head><title>Hello from Webmachine</title></head><body>Hello, world!</body></html>\n"
+  end
+end
+class LogListener
+  def call(*args)
+    handle_event(Webmachine::Events::InstrumentedEvent.new(*args))
+  end
+  def handle_event(event)
+    request = event.payload[:request]
+    resource = event.payload[:resource]
+    code = event.payload[:code]
+    puts "[%s] method=%s uri=%s code=%d resource=%s time=%.4f" % [
+      Time.now.iso8601, request.method, request.uri.to_s, code, resource,
+      event.duration
+    ]
+  end
+end
+Webmachine::Events.subscribe('wm.dispatch', LogListener.new)
+App = Webmachine::Application.new do |app|
+  app.routes do
+    add_route [], HelloResource
+  end
+  app.configure do |config|
+    config.adapter = :WEBrick
+    config.adapter_options = {:AccessLog => [], :Logger => Logger.new('/dev/null')}
+  end
+end
+App.run

data/lib/webmachine/adapters.rb CHANGED Viewed

@@ -6,7 +6,7 @@ module Webmachine
   # application servers.
   module Adapters
     autoload :Mongrel,  'webmachine/adapters/mongrel'
-		autoload :Reel,     'webmachine/adapters/reel'
+    autoload :Reel,     'webmachine/adapters/reel'
     autoload :Hatetepe, 'webmachine/adapters/hatetepe'
   end
 end

data/lib/webmachine/adapters/hatetepe.rb CHANGED Viewed

@@ -30,10 +30,14 @@ module Webmachine
         EM.epoll
         EM.synchrony do
           ::Hatetepe::Server.start(options)
-          trap("INT") { EM.stop }
+          trap("INT") { shutdown }
         end
       end
+      def shutdown
+        EM.stop
+      end
       def call(request, &respond)
         response = Webmachine::Response.new
         dispatcher.dispatch(convert_request(request), response)

data/lib/webmachine/adapters/lazy_request_body.rb CHANGED Viewed

@@ -11,7 +11,12 @@ module Webmachine
       # Converts the body to a String so you can work with the entire
       # thing.
       def to_s
-        @value ? @value.join : @request.body
+        @request.body
+      end
+      # Converts the body to a String and checks if it is empty.
+      def empty?
+        to_s.empty?
       end
       # Iterates over the body in chunks. If the body has previously
@@ -20,12 +25,7 @@ module Webmachine
       # @yield [chunk]
       # @yieldparam [String] chunk a chunk of the request body
       def each
-        if @value
-          @value.each {|chunk| yield chunk }
-        else
-          @value = []
-          @request.body {|chunk| @value << chunk; yield chunk }
-        end
+        @request.body {|chunk| yield chunk }
       end
     end # class RequestBody
   end # module Adapters

data/lib/webmachine/adapters/mongrel.rb CHANGED Viewed

@@ -18,14 +18,20 @@ module Webmachine
           :host => configuration.ip,
           :dispatcher => dispatcher
         }.merge(configuration.adapter_options)
-        config = ::Mongrel::Configurator.new(defaults) do
+        @config = ::Mongrel::Configurator.new(defaults) do
           listener do
             uri '/', :handler => Webmachine::Adapters::Mongrel::Handler.new(defaults[:dispatcher])
           end
           trap("INT") { stop }
           run
         end
-        config.join
+        @config.join
+      end
+      def shutdown
+        # The second argument tells mongrel to block until all listeners are shut down.
+        # This causes the mongrel tests to be very slow, but faster methods cause errors.
+        @config.stop(false, true) if @config
       end
       # A Mongrel handler for Webmachine
@@ -51,11 +57,12 @@ module Webmachine
             wres.status = response.code.to_i
             wres.send_status(nil)
-            response.headers.each { |k, vs|
-              vs.split("\n").each { |v|
+            response.headers.each do |k, vs|
+              [*vs].each do |v|
                 wres.header[k] = v
-              }
-            }
+              end
+            end
             wres.header['Server'] = [Webmachine::SERVER_STRING, "Mongrel/#{::Mongrel::Const::MONGREL_VERSION}"].join(" ")
             wres.send_header
@@ -64,16 +71,24 @@ module Webmachine
               wres.write response.body
               wres.socket.flush
             when Enumerable
-              Webmachine::ChunkedBody.new(response.body).each { |part|
-                wres.write part
-                wres.socket.flush
-              }
+              # This might be an IOEncoder with a Content-Length, which shouldn't be chunked.
+              if response.headers["Transfer-Encoding"] == "chunked"
+                Webmachine::ChunkedBody.new(response.body).each do |part|
+                  wres.write part
+                  wres.socket.flush
+                end
+              else
+                response.body.each do |part|
+                  wres.write part
+                  wres.socket.flush
+                end
+              end
             else
               if response.body.respond_to?(:call)
-                Webmachine::ChunkedBody.new(Array(response.body.call)).each { |part|
+                Webmachine::ChunkedBody.new(Array(response.body.call)).each do |part|
                   wres.write part
                   wres.socket.flush
-                }
+                end
               end
             end
           ensure

data/lib/webmachine/adapters/rack.rb CHANGED Viewed

@@ -31,16 +31,23 @@ module Webmachine
     #     MyApplication.run
     #
     class Rack < Adapter
+      # Used to override default Rack server options (useful in testing)
+      DEFAULT_OPTIONS = {}
       # Start the Rack adapter
       def run
-        options = {
+        options = DEFAULT_OPTIONS.merge({
           :app => self,
           :Port => configuration.port,
           :Host => configuration.ip
-        }.merge(configuration.adapter_options)
+        }).merge(configuration.adapter_options)
-        ::Rack::Server.start(options)
+        @server = ::Rack::Server.new(options)
+        @server.start
+      end
+      def shutdown
+        @server.server.shutdown if @server
       end
       # Handles a Rack-based request.
@@ -59,7 +66,7 @@ module Webmachine
         response.headers['Server'] = [Webmachine::SERVER_STRING, "Rack/#{::Rack.version}"].join(" ")
-        rack_status = response.code
+        rack_status  = response.code
         rack_headers = response.headers.flattened("\n")
         rack_body = case response.body
                     when String # Strings are enumerable in ruby 1.8
@@ -68,16 +75,45 @@ module Webmachine
                       if response.body.respond_to?(:call)
                         Webmachine::ChunkedBody.new(Array(response.body.call))
                       elsif response.body.respond_to?(:each)
-                        Webmachine::ChunkedBody.new(response.body)
+                        # This might be an IOEncoder with a Content-Length, which shouldn't be chunked.
+                        if response.headers["Transfer-Encoding"] == "chunked"
+                          Webmachine::ChunkedBody.new(response.body)
+                        else
+                          response.body
+                        end
                       else
                         [response.body.to_s]
                       end
                     end
-        rack_res = ::Rack::Response.new(rack_body, rack_status, rack_headers)
+        rack_res = RackResponse.new(rack_body, rack_status, rack_headers)
         rack_res.finish
       end
+      class RackResponse
+        def initialize(body, status, headers)
+          @body    = body
+          @status  = status
+          @headers = headers
+        end
+        def finish
+          @headers['Content-Type'] ||= 'text/html' if rack_release_enforcing_content_type
+          @headers.delete('Content-Type')          if response_without_body
+          [@status, @headers, @body]
+        end
+        protected
+        def response_without_body
+          ::Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? @status
+        end
+        def rack_release_enforcing_content_type
+          ::Rack.release < '1.5'
+        end
+      end
       # Wraps the Rack input so it can be treated like a String or
       # Enumerable.
       # @api private

data/lib/webmachine/adapters/reel.rb CHANGED Viewed

@@ -4,40 +4,108 @@ require 'webmachine/headers'
 require 'webmachine/request'
 require 'webmachine/response'
 require 'webmachine/dispatcher'
-require 'webmachine/chunked_body'
+require 'webmachine/adapters/lazy_request_body'
+require 'set'
 module Webmachine
   module Adapters
     class Reel < Adapter
       def run
-        options = {
+        @options = {
           :port => configuration.port,
           :host => configuration.ip
         }.merge(configuration.adapter_options)
-        server = ::Reel::Server.supervise(options[:host], options[:port], &method(:process))
-        trap("INT"){ server.terminate; exit 0 }
-        sleep
+        if extra_verbs = configuration.adapter_options[:extra_verbs]
+          @extra_verbs = Set.new(extra_verbs.map(&:to_s).map(&:upcase))
+        else
+          @extra_verbs = Set.new
+        end
+        @server = ::Reel::Server.supervise(@options[:host], @options[:port], &method(:process))
+        # FIXME: this will no longer work on Ruby 2.0. We need Celluloid.trap
+        trap("INT") { @server.terminate; exit 0 }
+        Celluloid::Actor.join(@server)
+      end
+      def shutdown
+        @server.terminate! if @server
       end
       def process(connection)
-        while wreq = connection.request
-          header = Webmachine::Headers[wreq.headers.dup]
-          host_parts = header.fetch('Host').split(':')
-          path_parts = wreq.url.split('?')
-          requri = URI::HTTP.build({}.tap do |h|
-            h[:host] = host_parts.first
-            h[:port] = host_parts.last.to_i if host_parts.length == 2
-            h[:path] = path_parts.first
-            h[:query] = path_parts.last if path_parts.length == 2
-          end)
-          request = Webmachine::Request.new(wreq.method.to_s.upcase,
-                                            requri,
-                                            header,
-                                            LazyRequestBody.new(wreq))
-          response = Webmachine::Response.new
-          @dispatcher.dispatch(request,response)
-          connection.respond ::Reel::Response.new(response.code, response.headers, response.body)
+        while request = connection.request
+          # Users of the adapter can configure a custom WebSocket handler
+          if request.is_a? ::Reel::WebSocket
+            if handler = @options[:websocket_handler]
+              handler.call(request)
+            else
+              # Pretend we don't know anything about the WebSocket protocol
+              # FIXME: This isn't strictly what RFC 6455 would have us do
+              request.respond :bad_request, "WebSockets not supported"
+            end
+            next
+          end
+          # Optional support for e.g. WebDAV verbs not included in Webmachine's
+          # state machine. Do the "Railsy" thing and handle them like POSTs
+          # with a magical parameter
+          if @extra_verbs.include?(request.method)
+            method = "POST"
+            param  = "_method=#{request.method}"
+            uri    = request_uri(request.url, request.headers, param)
+          else
+            method = request.method
+            uri    = request_uri(request.url, request.headers)
+          end
+          wm_headers  = Webmachine::Headers[request.headers.dup]
+          wm_request  = Webmachine::Request.new(method, uri, wm_headers,
+                                                LazyRequestBody.new(request))
+          wm_response = Webmachine::Response.new
+          @dispatcher.dispatch(wm_request, wm_response)
+          fixup_headers(wm_response)
+          fixup_callable_encoder(wm_response)
+          request.respond ::Reel::Response.new(wm_response.code,
+                                               wm_response.headers,
+                                               wm_response.body)
+        end
+      end
+      def request_uri(path, headers, extra_query_params = nil)
+        host_parts = headers.fetch('Host').split(':')
+        path_parts = path.split('?')
+        uri_hash = {host: host_parts.first, path: path_parts.first}
+        uri_hash[:port]  = host_parts.last.to_i if host_parts.length == 2
+        uri_hash[:query] = path_parts.last      if path_parts.length == 2
+        if extra_query_params
+          if uri_hash[:query]
+            uri_hash[:query] << "&#{extra_query_params}"
+          else
+            uri_hash[:query] = extra_query_params
+          end
+        end
+        URI::HTTP.build(uri_hash)
+      end
+      def fixup_headers(response)
+        response.headers.each do |key, value|
+          if value.is_a?(Array)
+            response.headers[key] = value.join(", ")
+          end
+        end
+      end
+      def fixup_callable_encoder(response)
+        if response.body.is_a?(Streaming::CallableEncoder)
+          response.body = [response.body.call]
         end
       end
     end