auto_response 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1ffff50cd0255268c8bf7006a4bbf1ce1a8358a
-  data.tar.gz: ab2d9bea2a0260fc4b439af40326da5fb7e0df5b
+  metadata.gz: ee5883eec73a27b407746617b71425860d071f19
+  data.tar.gz: 2cd5a5ca6ec272a54eb829cbd250c6470e0f99b5
 SHA512:
-  metadata.gz: 43be67ddb064d306b793eedd23f27a9810d833657103c2618312d2d4e2742e240d2799643f48a379509e6605dc349ece4084c0acac4e087ececb3c31dc855743
-  data.tar.gz: 50ce17a96b9d3e5ff68506f73a0d640e927425f83e16ae90ac4738f4aac21c63dd690d346e5ac98b3161578c3c0fc7dd728ebb42ddc075026a9beaa7db4f5243
+  metadata.gz: ee950fc92e636d6171856b38688ba16c9b0dad2e22cee76354cf818c2897bf3c4879dacaf419f362c25ff3909ccc832deea1d20356c133f84d59ea229dc3ccfa
+  data.tar.gz: 0674a3690d01b43a0c42e252a12537729328e310239f3a4570142f05a0098ea33ac16f82eaa666fccc21150dc257908725cd1e3784e9df6b79db6cdf82d00be4

data/Gemfile

@@ -1,9 +1,10 @@
-source :rubygems
+source 'http://ruby.taobao.org'
 gem 'listen'
 gem 'colorize'
-gem 'sinatra'
-gem 'haml'
 gem 'daemons'
+gem 'rb-inotify', '~> 0.9'
+gem 'string_utf8'
+gem 'ptools'
 
 group :test do
   gem 'test-unit'

data/Gemfile.lock

@@ -1,20 +1,16 @@
 GEM
-  remote: http://rubygems.org/
+  remote: http://ruby.taobao.org/
   specs:
     colorize (0.5.8)
     daemons (1.1.9)
+    ffi (1.9.0)
     gem-this (0.3.7)
-    haml (3.1.7)
     listen (0.6.0)
-    rack (1.4.1)
-    rack-protection (1.3.2)
-      rack
-    sinatra (1.3.3)
-      rack (~> 1.3, >= 1.3.6)
-      rack-protection (~> 1.2)
-      tilt (~> 1.3, >= 1.3.3)
+    ptools (1.2.2)
+    rb-inotify (0.9.0)
+      ffi (>= 0.5.0)
+    string_utf8 (0.1)
     test-unit (2.5.3)
-    tilt (1.3.3)
 
 PLATFORMS
   ruby
@@ -23,7 +19,8 @@ DEPENDENCIES
   colorize
   daemons
   gem-this
-  haml
   listen
-  sinatra
+  ptools
+  rb-inotify (~> 0.9)
+  string_utf8
   test-unit

data/bin/ar

@@ -1,6 +1,17 @@
 #!/usr/bin/env ruby
-require 'daemons'
 
-START_SCRIPT = File.dirname(__FILE__) + '/start_ar.rb'
+## compatible with Ruby 1.8
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.expand_path(path.to_str, File.dirname(caller[0]))
+    end
+  end
+end
+
+require 'daemons'
+require_relative '../lib/auto_response'
 
-Daemons.run START_SCRIPT
+Daemons.run_proc 'auto_response', :backtrace => true do
+  AutoResp::AutoResponder.new.start
+end

data/lib/ar/har.rb

@@ -0,0 +1,133 @@
+require 'json'
+require 'cgi'
+require 'string/utf8'
+
+module AutoResp
+
+  class HAR
+    
+    class << self
+
+      def sessions_to_har( sessions )
+        har = {
+          :log => {
+            :version => '1.2',
+            :creator => {
+              :name     => 'auto_response',
+              :version  => AutoResp::VERSION,
+              :comment  => 'proxied by auto_response'
+            },
+            :pages => []
+          }
+        }
+        har[:log][:entries] = sessions.map do |session|
+          session_to_entry session
+        end
+        JSON.fast_generate har
+      end
+
+      def session_to_entry( session )
+        req, res, info = *session
+        {
+          pageref:   nil,
+          startedDateTime:  info[:start],
+          time:     info[:end].to_i - info[:start].to_i,
+          request:  request_data( req ),
+          response: response_data( res ),
+          cache:    cache_data( req, res ),
+
+          #FIXME: add timing feature
+          timings: {
+            blocked:  0,
+            dns:      -1,
+            connect:  15,
+            send:     20,
+            wait:     38,
+            receive:  12,
+            ssl:      -1,
+            comment: ""
+          },
+
+          serverIPAddress: req.host,
+          #NOT implemented
+          connection: '',
+          comment:    info[:matched] ? 'x-auto-response' : nil
+        }
+      end
+
+      def request_data( req )
+        {
+          method:       req.request_method,
+          url:          req.unparsed_uri,
+          httpVersion:  req.http_version,
+          cookies:      req.cookies.map {|c| cookie_data( c ) },
+          headers:      req.header.map { |h| header_data( h ) },
+          queryString:  CGI.parse(req.query_string || ''),
+          #TODO: parse post data
+          postData: {},
+          headersSize:  0,
+          bodySize:     (req.body ? req.content_length : 0),
+          comment:      nil
+        }
+      end
+
+      def cookie_data( cookie )
+        {
+          name:     cookie.name,
+          value:    cookie.value,
+          path:     cookie.path,
+          domain:   cookie.domain,
+          expires:  cookie.expires,
+          #FIXME: check httponly
+          httpOnly: nil,
+          secure:   cookie.secure,
+          comment: nil
+        }
+      end
+
+      def header_data( header )
+        name, value = *header
+        value = value.join("\n") if value.is_a?(Array)
+        {
+          name:   name,
+          value:  value,
+          comment: nil
+        }
+      end
+
+      def response_data( res )
+        body = res.body
+        body.utf8!
+        body = '**raw data**' unless body.valid_encoding?
+        {
+          status:       res.status,
+          statusText:   res.message,
+
+          httpVersion:  res.http_version,
+          cookies:      res.cookies.map {|c| 
+            cookie_data( WEBrick::Cookie.parse_set_cookie c) },
+          headers:      res.header.map {|h| header_data(h) },
+          content:      body,
+
+          #FIXME
+          redirectURL:  '',
+          headerSize:   160,
+
+          bodySize:     res.content_length,
+          comment: nil
+        }
+      end
+
+      def cache_data( req, res )
+        {
+          #FIXME
+          beforeRequest: nil,
+          afterRequest: nil
+        }
+      end
+
+    end
+
+  end
+
+end

data/lib/ar/proxy_server.rb

@@ -0,0 +1,171 @@
+require 'webrick/httpproxy'
+require 'logger'
+require 'ptools'
+
+require_relative 'rule_manager'
+require_relative 'parser'
+
+module AutoResp
+
+  class ProxyServer < WEBrick::HTTPProxyServer
+    
+    include Parser
+    attr_reader :sessions
+
+    def initialize(core, config={})
+      @core = core
+      super(config.update({
+        :AccessLog  => [],
+        :Logger     => WEBrick::Log.new("/dev/null")
+      }))
+      @sessions = []
+      @ar_logger = config[:logger] || Logger.new
+    end
+
+    def service(req, res)
+      logger.info "[#{req.unparsed_uri}]"
+      info = { start: Time.now }
+
+      before_filters.each do |block|
+        if block.call( req, res ) == false
+          super req, res
+          return
+        end
+      end
+
+      header, body, status = find_auto_res(req.unparsed_uri)
+      res.status = status if status
+
+      if @rule
+
+        logger.debug "match".ljust(8)   << ": #{req.unparsed_uri}"
+        logger.debug "header".ljust(8)  << ": #{header}"
+        logger.debug "body".ljust(8)    << ": \n#{body}"
+        logger.debug "-"*50
+
+        res['x-auto-response-condition']  = @rule.first.to_s
+        res['x-auto-response-with']       = @rule.last.to_s
+        if header
+          header.each do |k,v|
+            v = v.join("\n") if v.respond_to?(:join)
+            res[k] = v
+          end
+        end
+        res.body = body
+        info[:matched] = true
+      else
+        super(req, res)
+      end
+
+      info[:end] = Time.now
+      sessions << [req, res, info]
+    end
+
+    def before_filters
+      @before_filters ||= []
+    end
+
+    def before_filter(&block)
+      logger.info "add before_filter".green
+      before_filters << block
+    end
+
+    def clear_before_filters
+      @before_filters.clear
+    end
+
+    def find_auto_res(url)
+      rule = @core.rules.find do |condition, map_to|
+        matched? url, condition
+      end
+          
+      @rule = rule
+      if rule
+        condition, handlers = *rule
+        handlers.each {|proc| proc.call if proc.respond_to?(:call) }
+        fetch(handlers.last, condition, url)
+      end
+    end
+
+    def matched?( url, rule )
+      trim_url(rule) === trim_url(url)
+    end
+
+    def fetch(txt, declare, uri)
+
+      case txt
+      when nil
+        Net::HTTP.get_response(URI(uri)) do |res|
+          return [res.to_hash, res.read_body, res.code]
+        end
+      when Proc
+        if Regexp === declare
+          mtc = uri.match(declare) 
+          fetch( txt.call(*mtc), declare, uri )
+        else
+          fetch( txt.call, declare, uri )
+        end
+      when String
+        if goto = redirect_path(txt)
+          if is_uri?(goto)
+            Net::HTTP.get_response(URI(goto)) do |res|
+              return [res.to_hash, res.read_body, res.code]
+            end
+          else
+            file = File.expand_path( goto )
+            if File.exist?(file)
+              content = IO.read file
+              if File.binary? file
+                return [nil, content, 200]
+              else
+                return parse(content)
+              end
+            end
+          end
+        else
+          parse(txt)
+        end
+      when Fixnum
+        [{}, "", txt]
+      when Array
+        [txt[1], txt[2], txt[0]]
+      end
+    end
+
+    private
+    def redirect_path(t)
+      if is_single_line?(t)
+        (t.match(/^=GOTO=> (\S.*?)\s*$/) || [] )[1]
+      end
+    end
+
+    def is_uri?(txt)
+      /^[A-Za-z][A-Za-z0-9+\-\.]*:\/\/.+/ =~ txt
+    end
+
+    def header_hash(header)
+      h = header.to_hash
+      h.each do |n,v|
+        h[n] = v.join if Array === v
+      end
+    end
+
+    def trim_url(url)
+      if url.is_a? String
+        url.sub(/\/$/, '')
+      else
+        url
+      end
+    end
+
+    def is_single_line?(text)
+      text.count("\n") < 2
+    end
+
+    def logger
+      @ar_logger
+    end
+
+  end
+
+end

data/lib/ar/rule_dsl.rb

@@ -12,5 +12,9 @@ module AutoResp
     def goto(url)
       add_handler '=GOTO=> ' << url
     end
+
+    def delay(sec)
+      add_handler( lambda { |*args| sleep sec; nil } )
+    end
   end
 end

data/lib/ar/rule_manager.rb

@@ -19,7 +19,8 @@ module AutoResp
 
     def add_handler( handler )
       if @last_rule
-        rules[@last_rule] = handler
+        rules[@last_rule] ||= []
+        rules[@last_rule] << handler
       end
     end
 

data/lib/ar/session_viewer.rb

@@ -1,22 +1,27 @@
-require 'sinatra/base'
-require 'haml'
+require 'webrick/httpserver'
+require 'ar/har'
 
 module AutoResp
 
-  class SessionViewer < Sinatra::Base
+  class SessionViewer
 
-    class << self
-      attr_accessor :proxy_server
+    def initialize( proxy_server )
+      @proxy_server = proxy_server
     end
 
-    set :views, File.join(settings.root, 'viewer/tmpl')
-
-    get '/' do
-      haml :index
-    end
-
-    before('/') do
-      @sessions = SessionViewer.proxy_server.sessions.dup
+    def run
+      root = File.expand_path('./viewer', File.dirname(__FILE__))
+      server = WEBrick::HTTPServer.new({
+        :BindAddress  => '0.0.0.0',
+        :Port         => 9090,
+        :AccessLog    => [],
+        :Logger       => WEBrick::Log.new("/dev/null"),
+        :DocumentRoot => root
+      })
+      server.mount_proc '/sessions.har' do |req, res|
+        res.body = HAR.sessions_to_har( @proxy_server.sessions )
+      end
+      server.start
     end
 
   end

data/lib/ar/version.rb

@@ -0,0 +1,3 @@
+module AutoResp
+  VERSION = '0.1.8'
+end