yhuiche (鲁笔)

Rack 中间件简单理解及例子

yhuiche — Sat, 13 Aug 2016 17:25:59 +0800

注：这里是根据网上的常见的 rack 例子更改

rack 版本

Rack 为使用 Ruby 开发 web 应用提供了一个最小的模块化和可修改的接口。用可能最简单的方式来包装 HTTP 请求和响应，它为 web 服务器，web 框架和中间件的 API 进行了统一并提纯到了单一的方法调用。
测试中 rack gem 版本为 1.6.4

示例代码

module Rack
  class A
    def initialize(app)
      @app = app            # @app: Rack::B
      @header_name = "X-A"
    end

    def call(env)
      start_time = Time.now
      status, headers, body = @app.call(env)  #  Rack::B 实例调用 call
      request_time = Time.now - start_time

      if !headers.has_key?(@header_name)
        headers[@header_name] = "%0.6f" % request_time
      end

      [status, headers, body]
    end
  end

  class B
    def initialize(app)
      @app = app          # @app: Rack::C
      @header_name = "X-test"
    end

    def call(env)
      status, headers, body = @app.call(env)   #  Rack::C 实例调用 call

      if !headers.has_key?(@header_name)
        headers[@header_name] = 'yyyyyy'
      end

      [status, headers, body+['aaaaaa']]
    end
  end

  class C
    def call(env)
      [200, {'Content-Type' => 'text/plain'}, ['hello world!']]
    end
  end
end

use Rack::A
use Rack::B

run Rack::C.new

为了探究中间件的加载运行过程，这里用 A、B、C 顺序来定义 class
实际运行的代码存在打印语句，后面有打印结果
其中 Rack::C 就相当于 Rails App
A、B 则相当于中间件
A、B、C 都为 rack app
通过实例变量@app实现 rack app 一种嵌套结构
文件命名为 ~/test/config.ru
call 方法统一返回格式，每次返回结果都会在内层返回的结果上做处理后返回结果给外层的调用

运行打印结果

运行命名下面名，然后用浏览器访问本地 9292 端口http://localhost:9292
cd ~/test
rackup

~/test $ rackup

new B  -------------
@app: #<Rack::C:0x007fa4b2ad4298>
------------------------------
new A-------------
@app: #<Rack::B:0x007fa4b2ad41f8>
------------------------------

Thin web server (v1.6.3 codename Protein Powder)
Maximum connections set to 1024
Listening on localhost:9292, CTRL+C to stop

A call -------------
@app: #<Rack::B:0x007fa4b2ad41f8>
------------------------------
B call ----------------
@app: #<Rack::C:0x007fa4b2ad4298>
------------------------------
C call ----------
#<Rack::C:0x007fa4b2ad4298>
------------------------------
127.0.0.1 - - [08/Aug/2016:00:57:19 +0800] "GET / HTTP/1.1" 200 - 0.0041

A call -------------
@app: #<Rack::B:0x007fa4b2ad41f8>
------------------------------
B call ----------------
@app: #<Rack::C:0x007fa4b2ad4298>
------------------------------
C call ----------
#<Rack::C:0x007fa4b2ad4298>
------------------------------
127.0.0.1 - - [08/Aug/2016:00:57:20 +0800] "GET /favicon.ico HTTP/1.1" 200 - 0.0006

可以看到在 class Rack::A 中，@app为 class Rack::B 的一个实例；而在 class Rack::B 中，@app则为 Rack::C。
在接受到浏览器的访问后，调用了中间件的 call 方法，这里有点类似于递归的调法。从代码及返回结果可以看出，是 Rack::A 中的 call 方法先被调用，然后是 Rack::B 中的，最后是 Rack::C 中的。返回是顺序刚好相反，先是 Rack::C 中的 call 方法先执行完，然后是 Rack::B，最后是 Rack::A。
这段日志有两个访问记录，一个是 http://localhost:9292 主体，一个是网站收藏图标 favicon.ico

浏览器查看到的部分数据

HTTP/1.1 200 OK
Content-Type: text/plain
X-test: yyyyyy
X-A: 0.000032
Transfer-Encoding: chunked
Connection: close
Server: thin

浏览器页面看到的结果

hello world!aaaaaa

这里看到的是浏览器中查看到了部分数据
可以看出 rack 默认的 web 服务器是 thin
X-text、X-A 为 call 方法中返回的部分数据
页面看到的东西则为 call 方法中返回的 body 部分

rails s 启动过程

yhuiche — Fri, 29 Aug 2014 21:00:03 +0800

1) 命令 rails s 
    windows) 这里会执行 RUBY_PATH/bin/rails.bat 文件
             之后将执行权交给 'RUBY_PATH/bin/rails'

    linux) 这里会执行 'RUBY_PATH/bin/rails'

    跳转) 在 RUBY_PATH/bin/rails 中
        load Gem.bin_path('railties', 'rails', version)
    -->>这里将跳转的railties(gem)目录中 'RAILTIES_PATH/bin/rails'


2) railties(gem)
    bin/rails)
    在 RAILTIES_PATH/bin/rails 有
        require "rails/cli"
            (require 文件后会执行文件代码，文件中class、module的代码其实只是定义作用，所以本文中并不是所有的require语句都会提示跳转)
    -->>这里将跳转交到 "RAILTIES_PATH/lib/rails/cli.rb"

    lib/cli)
    在 RAILTIES_PATH/lib/rails/cli.rb 中有
        Rails::ScriptRailsLoader.exec_script_rails!
    -->>这里将跳转交到 'RAILTIES_PATH/lib/script_rails_loader.rb' , 方法 'exec_script_rails!'

    lib/script_rails_loader)
    在 RAILTIES_PATH/lib/script_rails_loader.rb 中
    调用方法   
        exec_script_rails! 
    其中的
        exec RUBY, SCRIPT_RAILS, *ARGV if in_rails_application?
        # 这里会跳转到rails项目(需要运行的rails项目) APP_ROOT_PATH/script/rails
        # exec 将以命令行的方式运行其接受的参数，并跳出当前脚本
        # RUBY 及 RUBY_PATH/bin/ruby
        # SCRIPT_RAILS 为 script/rails (注：'rails s'在APP所在目录执行)
    -->>这里会跳转到rails项目 'APP_ROOT_PATH/script/rails'


3)  APP
    在 'APP_ROOT_PATH/script/rails' 中有
        APP_PATH = File.expand_path('../../config/application',  __FILE__)
        require File.expand_path('../../config/boot',  __FILE__)
        require 'rails/commands'
        # 设置了 APP_PATH
        # 加载 bundle 
        # 跳转到  "RAILTIES_PATH/lib/rails/commands.rb"
    -->>跳转到 "RAILTIES_PATH/lib/rails/commands.rb"


4) RAILTIES_PATH/lib/rails/commands
    在 "RAILTIES_PATH/lib/rails/commands.rb" 中
        when 'server'
          Dir.chdir(File.expand_path('../../', APP_PATH)) unless File.exists?(File.expand_path("config.ru"))

          require 'rails/commands/server'
          Rails::Server.new.tap { |server|
            require APP_PATH
            Dir.chdir(Rails.application.root)
            server.start
          }
        # Rails::Server 继承与 Rack::Server，这里(server.start)跳转到了rack
        # def tap
        #   yield self
        #   self
        # end 
    -->>跳转到 'RAILTIES_PATH/lib/rails/commands/server.rb' Rails::Server (rack的一个子类)，执行方法 new, start


5) Rails::Server 执行方法 new, start
    这里主要加载rack middleware(中间件)，加载 APP_PATH/config.ru 文件，将APP::Application(要启动的rails项目的 Application类)加载到rack
    在 'RAILTIES_PATH/lib/rails/commands/server.rb' 中
        # def start
        server.run wrapped_app, options, &blk
        # Rails::Server 继承与 Rack::Server
        # a) wrapped_app 加载了APP::Application以及中间件
        # b) 这里 server 其实就是Webrick或者Thin等服务

        a) wrapped_app 加载了APP::Application以及中间件
        def wrapped_app
          @wrapped_app ||= build_app app
        end

        def build_app(app)
          middleware[options[:environment]].reverse_each do |middleware|
            middleware = middleware.call(self) if middleware.respond_to?(:call)
            next unless middleware
            klass = middleware.shift
            app = klass.new(app, *middleware)
          end
          app
        end
        # 这里主要是中间件的加载过程。rack中，中间件的定义例如
        # class Runtime
        #     def initialize(app, name = nil)
        #       @app = app
        #       ....
        #     end
        #     def call(env)
        #       status, headers, body = @app.call(env)
        #       ...
        #       end
        #     ...
        # end
        # 这里的 app 参数传进去的其实就是一个中间件或者 APP::Application。即中间件形成了一个嵌套的结构，这个结构在展开（调用call方法）的时候是跟方便的,

        def app
            app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
            ...
        end
        # 这里options[:config]指向config.ru文件
        # 在 Rack::Builder.parse_file 中有
        # app = eval "Rack::Builder.new {\n" + cfgfile + "\n}.to_app",TOPLEVEL_BINDING, config, 0
        # cfgfile 为 config.ru文件 的具体类容
        # 在 Rack::Builder 中有
        # def initialize(default_app = nil,&block)
        #   @use, @map, @run = [], nil, default_app
        #   instance_eval(&block) if block_given?
        # end
        # def run(app)
        #   @run = app
        # end
        # 在config.ru中有
        # run APP::Application
        # 这里就将APP::Application加载都了rack中

        b) 这里 server 其实就是Webrick或者Thin等服务
        在Rack::Server中有
        def server
          @_server ||= Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
        end
        # 跟踪在Rack::Handler中有
        # # def default
        # begin
        #   Rack::Handler::Thin
        # rescue LoadError
        #   Rack::Handler::WEBrick
        # end
        # rack 中缺省的服务选择的事Thin，但在rails中没有加载thin的gem，所以会使用webrick。如果要使用thin，在gemfile中添加thin的gem即可
    -->> 这里会跳转到 Rack::Handler::Thin 'RACK_PATH/lib/rack/handler/thin.rb'（本文使用thin），执行方法run，


6) Rack::Handler::Thin 执行方法run
    在Rack::Handler::Thin中有
        def self.run(app, options={})
          server = ::Thin::Server.new(options[:Host] || '0.0.0.0',
                                      options[:Port] || 8080,
                                      app)
          yield server if block_given?
          server.start
        end
        # 可以看到这里调用了::Thin::Server的方法new、start
        # 这里 app 参数包含了APP::Application,以及中间件
    -->> 这里会跳转到 Thin::Server 'THIN_PATH/lib/thin/server.rb',执行方法new、start


7) Thin::Server ,执行方法new、start
    在Thin::Server中有
        # def initialize(*args, &block)
        args.each do |arg|
          case arg
          when Fixnum, /^\d+$/ then port    = arg.to_i
          when String          then host    = arg
          when Hash            then options = arg
          else
            @app = arg if arg.respond_to?(:call)
          end
        end
        @backend = select_backend(host, port, options)
        @backend.server = self

        # def start
        @backend.start { setup_signals if @setup_signals }
        # 可以看做 @app 是上面（6）中传过来的参数，包含了APP::Application,以及中间件
        # 这里将 Thin::Server的实例绑到了@backend中，及将app绑定到了@backend中
        # 跟踪 select_backend 有
        # Backends::TcpServer.new(host, port) # rails 启动时select_backend会返回该值
    -->>这里会跳转到 Backends::TcpServer 'THIN_PATH/lib/thin/backends/tcp_server.rb',执行start


8) Backends::TcpServer ,执行start
    Backends::TcpServer 继承了 Base(Thin::Backends::Base)
    在 Thin::Backends::Base 中有
        def start
          @stopping = false
          starter   = proc do
            connect
            yield if block_given?
            @running = true
          end

          # Allow for early run up of eventmachine.
          if EventMachine.reactor_running?
            starter.call
          else
            @started_reactor = true
            EventMachine.run(&starter)
          end
        end
        def initialize_connection(connection)
          connection.backend                 = self
          connection.app                     = @server.app
          connection.comm_inactivity_timeout = @timeout
          connection.threaded                = @threaded
          ...
        end
        # 这里调用了connect方法，该方法在Backends::TcpServer中有定义
        # def connect
        #   @signature = EventMachine.start_server(@host, @port, Connection, &method(:initialize_connection))
        # end
        # 这里Connection是 Thin::Connection,'THIN_PATH/lib/thin/connection.rb'
        # 这里生成了一个Connection实例，绑定了上面传过来的app。并将Connection实例传给了EventMachine
        # 这里可以看出，thin使用了 EventMachine,EventMachine是一个基于Reactor设计模式的、用于网络编程和并发编程的事件驱动框架。
        # 最后的启动交给了EventMachine，由EventMachine完成启动。
        # EventMachine比较底层了，可以对消息进行接收与回复，下面是一个例子


9) EventMachine 例子
    require 'eventmachine'

    Str = <<Eos
<!DOCTYPE html>
<html>
  <head>
      <title>hello, eventmachine </title>
  </head>
  <body>
    <h1 style='color:#ff0000'>hello, eventmachine </h1>
  </body>
</html>
Eos
    class Pass < EventMachine::Connection
      def receive_data data
        p data
        send_data Str
        close_connection_after_writing
      end
    end
    def test hh
      p 111111111111111
      p hh
    end

    EM.run do
      EM.start_server('0.0.0.0',10001,Pass,&method(:test))
    end
    # 这个例子可以通过浏览器访问 http://127.0.0.1:10001
    # 每次收到消息后，都会执行 receive_data
    # 由 send_data 回复信息

EventMachine 参考 http://wonderflow.info/wp-content/uploads/2013/07/EventMachine%E5%85%A5%E9%97%A8.pdf

URL 中 %400 错误

yhuiche — Mon, 28 Jul 2014 23:44:38 +0800

在 url 如果存在%（此处不是 url 编码后产生的%），rails 在解析 url 时会抛出 error。这个问题有没有很好的解决方案。

json.erb 文件，用 ajax 访问返回值格式不对

yhuiche — Mon, 17 Feb 2014 11:15:03 +0800

json.erb 文件，用 ajax 访问返回值格式不对，返回的怎么是 text，而不是 json？

devise 用户锁定

yhuiche — Wed, 22 Jan 2014 10:51:39 +0800

最近在使用 devise，遇到了点问题，如何直接锁定一个用户，使之不能登陆。

Rails 如何将 HTML 转换成 PDF?

yhuiche — Tue, 15 Oct 2013 16:41:08 +0800

我在 rails 中使用 wkhtmltopdf 将 html 文件转换成 pdf 文件，能够很好地转换，但是发现有一两秒的生成时间，速度不够理想。有没有更加快速的方法？？

ror+mongodb 中的中 filed 类型

yhuiche — Tue, 19 Feb 2013 17:25:12 +0800

我在做一个东西，用的是 ror+mongodb，其中一个 class 中有个 filed 的类型不确定，这个类型要根据初始化时传入的参数的类型而定。我弄晕了还是没搞定。。跪求各位救命啊啊啊。。。本来打算用下面这个思路的，但是从数据库用出来后类型总是 Hash，而不是我要的类型。。

class Abc 
  include Mongoid::Document
  field :value 
    def initialize(attrs = nil, options = nil)
      value_type = 'Monetary'
        self.value = eval(value_type).new attrs[:value]
        end
    end
end