ruby sinatra 内部机制（二）

基础知识：

1.ruby的proc

ruby的proc的一般使用过程如下：

>> p=Proc.new{|item| p item}
=> #<Proc:0x000000010e446060@(irb):9>
>> p.call("6")
"6"

 

proc是通过call进行调度的，也就是说proc是可以响应call的。

 

2. rack的中间件的概念

   我个人感觉rack中间件类似代理，包裹了endpoint，在完成处理后，中间件再将被包裹的endpoint返回。

    一个简单的rack中间件如下：

MyApp = proc do |env|
    [200, {'Content-Type' => 'text/plain'}, ['ok']]
    end
class MyMiddleware
    def initialize(app)
	@app = app 
    end
    def call(env)
	if env['PATH_INFO'] == '/' 
	    @app.call(env)
	else
	    [404, {'Content-Type' => 'text/plain'}, ['not ok']]
	end 
    end
end
# this is the actual configuration
use MyMiddleware
run MyApp

 通过执行 rackup -p 4567 -s thin启动，访问4567端口后curl 127.0.0.1:4567/ab，返回not ok。从这里我们可以看到MyMiddleware作为中间件，处理非法请求。

 

那么sinatra和中间件又有神马关系呢？

    sinatra既可以作为endpoint（被中间件包裹的app），也可以作为中间件过滤处理请求。

    sinatra的所有请求的入口是call，从而知道每次call都会去调用prototype，在引入@prototype时，就引入了rack的中间件。同样，根据上面的例子，sinatra支持使用use来引入其他的中间件。

当一个请求到达后，则所有的before过滤器会被触发，而在处理请求后，所有的after都会被触发，除非before、after有特定的路径限制。

      # The prototype instance used to process requests.
      def prototype
        @prototype ||= new
      end

      # Create a new instance without middleware in front of it.
      alias new! new unless method_defined? :new!

      # Create a new instance of the class fronted by its middleware
      # pipeline. The object is guaranteed to respond to #call but may not be
      # an instance of the class new was called on.
      def new(*args, &bk)
        build(Rack::Builder.new, *args, &bk).to_app
      end

      # Creates a Rack::Builder instance with all the middleware set up and
      # an instance of this class as end point.
      def build(builder, *args, &bk)
        setup_default_middleware builder
        setup_middleware builder
        builder.run new!(*args, &bk)
        builder
      end

      def call(env)
        synchronize{protype.call(env)}
      end

 

使用rack的中间件 （保存为config.ru）

require 'sinatra' 
require 'rack'
# A handy middleware that ships with Rack
# and sets the X-Runtime header 
use Rack::Runtime
get('/') { 'Hello world!' }

 在启动访问后

curl 127.0.0.1:4567 -vv

* About to connect() to 127.0.0.1 port 4567 (#0)
*   Trying 127.0.0.1... connected
* Connected to 127.0.0.1 (127.0.0.1) port 4567 (#0)
> GET / HTTP/1.1
> User-Agent: curl/7.21.4 (universal-apple-darwin11.0) libcurl/7.21.4 OpenSSL/0.9.8r zlib/1.2.5
> Host: 127.0.0.1:4567
> Accept: */*
> 
< HTTP/1.1 200 OK
< X-Frame-Options: sameorigin
< X-XSS-Protection: 1; mode=block
< Content-Length: 12
< Content-Type: text/html;charset=utf-8
< X-Runtime: 0.000396


< Connection: keep-alive
< Server: thin 1.5.0 codename Knife
< 
* Connection #0 to host 127.0.0.1 left intact
* Closing connection #0
Hello world!

sinatra自己作为中间件 （保存为config.ru）

require 'rubygems'
require 'sinatra/base'
MyApp = proc do |env|
    [200, {'Content-Type' => 'text/plain'}, ['ok']]
    end
class MyMiddlewareSinatra < Sinatra::Base
    before do
      if env['PATH_INFO'] != '/' 
	halt "not good"
      end	
    end
end
# this is the actual configuration
use MyMiddlewareSinatra
run MyApp

 利用rackup -s thin -p 4567启动后访问/abc,返回not good

 

 

 

分发原则

在sinatra作为endpoint的时候，每一个请求生成一个对应的实例。而当sinatra作为中间件运行时，则是所有的请求都对应一个实例。

在sinatra作为app处理请求的时候，调用的如下代码：

 # The prototype instance used to process requests.
      def prototype
        @prototype ||= new
      end
      def call(env)
        synchronize { prototype.call(env) }
      end

 而在作为中间件调用的如下代码

 # Rack call interface.
    def call(env)
      dup.call!(env)
    end
    def call!(env) # :nodoc:
      @env      = env
      @request  = Request.new(env)
      @response = Response.new
      @params   = indifferent_params(@request.params)
      template_cache.clear if settings.reload_templates
      force_encoding(@params)

      @response['Content-Type'] = nil
      invoke { dispatch! }
      invoke { error_block!(response.status) }

      unless @response['Content-Type']
        if Array === body and body[0].respond_to? :content_type
          content_type body[0].content_type
        else
          content_type :html
        end
      end

      @response.finish
    end