auto_response 0.1.0

data/Gemfile

@@ -0,0 +1,12 @@
+source :rubygems
+gem 'listen'
+gem 'colorize'
+gem 'daemons'
+
+group :test do
+  gem 'test-unit'
+end
+
+group :development do
+  gem 'gem-this'
+end

data/Gemfile.lock

@@ -0,0 +1,16 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    colorize (0.5.8)
+    daemons (1.1.9)
+    listen (0.6.0)
+    test-unit (2.5.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  colorize
+  daemons
+  listen
+  test-unit

data/bin/ar

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require 'daemons'
+
+START_SCRIPT = File.dirname(__FILE__) + '/start_ar.rb'
+
+Daemons.run START_SCRIPT

data/bin/start_ar.rb

@@ -0,0 +1,5 @@
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'autoresponse'
+
+AutoResp::AutoResponder.new.start

data/lib/ar/parser.rb

@@ -0,0 +1,50 @@
+module AutoResp
+
+  module Parser
+
+    require 'net/http'
+    
+    def parse( str )
+
+      headers, body = {}, []
+      to_find_header, body_start = true, false
+
+      str.lines.each_with_index do |line, idx|
+        if to_find_header and not body_start
+          if line =~ /^\s*$/
+            if idx == 0
+              to_find_header = false
+              body << line
+            else
+              body_start = true
+              body = []
+            end
+          else
+            body << line
+            name, value = parse_header_item(line)
+            if name
+              headers[name] = value
+            else
+              to_find_header = false
+            end
+          end
+        else
+          body << line
+        end
+      end
+
+      headers = nil unless to_find_header and body_start
+      res_body = body.join
+
+      [headers, res_body]
+    end
+
+    def parse_header_item(str)
+      mtc = str.match /^\s*(\S+)\s*:\s*(\S.*)$/
+      [mtc[1], mtc[2]] if mtc
+    end
+
+
+  end
+
+end

data/lib/ar/proxyserver.rb

@@ -0,0 +1,102 @@
+require 'webrick/httpproxy'
+require 'webrick/log'
+
+require_relative 'rule_manager'
+require_relative 'parser'
+
+module AutoResp
+
+  class ProxyServer < WEBrick::HTTPProxyServer
+    
+    include Parser
+
+    def initialize(core, config={})
+      @core = core
+      super(config.update({
+        :AccessLog  => [],
+        :Logger     => WEBrick::Log.new("/dev/null")
+      }))
+    end
+
+    def service(req, res)
+      header, body, status = find_auto_res(req.unparsed_uri)
+      res.status = status if status
+
+      if header or body
+        puts "match".ljust(8)   << ": #{req.unparsed_uri}"
+        puts "header".ljust(8)  << ": #{header}"
+        puts "body".ljust(8)    << ": \n#{body}"
+        puts "-"*50
+        res.header.merge!(header || {})
+        res.body = body
+      else
+        super(req, res)
+      end
+    end
+
+    def find_auto_res(url)
+      @core.rules.find do |tar, map|
+        if trim_url(tar) === trim_url(url)
+          return fetch(map, tar, url)
+        end
+      end
+    end
+
+    def fetch(txt, declare, uri)
+
+      case txt
+      when Proc
+        mtc = uri.match(declare) if Regexp === declare
+        fetch( txt.call(*mtc), declare, uri )
+      when String
+        if goto = redirect_path(txt)
+          if is_uri?(goto)
+            Net::HTTP.get_response(URI(goto)) do |res|
+              return [nil, res.body]
+            end
+          elsif File.exist?(goto)
+            return parse(IO.read(goto))
+          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
+
+  end
+
+end

data/lib/ar/rule_dsl.rb

@@ -0,0 +1,16 @@
+module AutoResp
+
+  module RuleDSL
+    def url(target, &block)
+      add_rule(target, &block);
+    end
+
+    def r(resp)
+      add_handler( resp )
+    end
+
+    def goto(url)
+      add_handler '=GOTO=> ' << url
+    end
+  end
+end

data/lib/ar/rule_manager.rb

@@ -0,0 +1,45 @@
+require_relative 'rule_dsl'
+
+module AutoResp
+
+  class RuleManager
+
+    include RuleDSL
+
+    def initialize
+    end
+
+    def rules
+      @rules ||= {}
+    end
+
+    def clear
+      @rules.clear
+    end
+
+    def add_handler( handler )
+      if @last_rule
+        rules[@last_rule] = handler
+      end
+    end
+
+    def add_rule(*args, &block)
+      @last_rule = target = args.first
+      case target
+      when Hash
+        @last_rule = target.keys.first
+        rules.merge! target
+      when String
+        rules[target] = args[1]
+      when Regexp
+        if block_given?
+          rules[target] = block
+        else
+          rules[target] = args[1]
+        end
+      end
+    end
+
+  end
+
+end

data/lib/autoresponse.rb

@@ -0,0 +1,118 @@
+require 'xmlrpc/httpserver'
+require 'open-uri'
+require 'fileutils'
+require 'listen'
+require 'colorize'
+
+require_relative 'ar/proxyserver'
+require_relative 'ar/rule_manager'
+require_relative 'ar/parser'
+
+module AutoResp
+
+
+  class AutoResponder
+
+    ARHOME = "#{ENV["HOME"]}/.auto_response"
+    RULES = "#{ARHOME}/rules"
+
+    def initialize(config={})
+      @config = config
+      @rule_manager = RuleManager.new
+      init_autoresponse_home
+      init_proxy_server
+      load_rules
+      monitor_rules_change
+    end
+    
+    protected
+    def init_autoresponse_home
+      unless File.exist?(RULES)
+        pwd = File.expand_path('..', File.dirname(__FILE__))
+        FileUtils.mkdir_p(ARHOME) 
+        FileUtils.cp "#{pwd}/rules.sample", RULES
+      end
+    end
+
+    protected
+    def init_proxy_server
+      @server = ProxyServer.new(
+        self,
+        :BindAddress  => @config[:host] || '0.0.0.0',
+        :Port         => @config[:port] || 9000
+      )
+      trap('INT') { stop_and_exit }
+    end
+
+    public
+    def start
+      @thread = Thread.new { @server.start }
+      @thread.join
+    end
+
+    def stop_and_exit
+      stop
+      exit
+    end
+
+    def stop
+      puts "\nshuting down"
+      @server.shutdown
+      @thread.kill
+    end
+
+    def add_rule(*args, &block)
+      case args.first
+      when Hash
+        rules.merge! args.first
+      when String
+        rules[args[0]] = args[1]
+      when Regexp
+        if block_given?
+          rules[args[0]] = block
+        else
+          rules[args[0]] = args[1]
+        end
+      end
+    end
+
+    def rules
+      @rule_manager.rules
+    end
+
+    def clear_rules
+      rules.clear
+    end
+
+    private
+    def load_rules(path=nil)
+      path ||= @config[:rule_config]
+      path ||= "#{ARHOME}/rules"
+      if File.readable?(path)
+        @rule_manager.instance_eval File.read(path)
+      end
+      log_rules
+    end
+
+    def log_rules
+      puts "mapping rules:"
+      rules.each do |n,v|
+        puts n.to_s.ljust(30).green << "=> #{v}"
+      end
+    end
+
+    def monitor_rules_change
+      listener = Listen.to(ARHOME)
+      listener.change { reload_rules }
+      Thread.new { listener.start }
+    end
+
+    def reload_rules
+      @rule_manager.clear
+      load_rules
+    end
+
+  end
+
+end
+

data/readme.md

@@ -0,0 +1,87 @@
+# AutoResponse - HTTP debugging tool for Linux and Mac
+
+## What's auto_response for?
+
+[Fiddler](http://www.fiddler2.com) is the favor tool of many web developers for debugging HTTP web apps. However it is only available on Windows. AutoResponse ports the most used feature of fiddler, 'auto respond', to Linux and Mac world.
+
+Auto_response acts as a proxy server like Fiddler does, allowing you to modify the content of HTTP response.
+
+## Quick start
+
+1. Install and run
+
+        gem install 'auto_response'
+        ar start
+
+        ar status #check server status
+        ar stop   #stop proxy server
+
+2. Set your browser proxy to 'http://127.0.0.1:9000'
+3. Edit the configuration file to modify the urls you want change the response.
+
+    By default, the configuration file is located at:
+    `$HOME/.auto_response/rules`
+
+## Response rules
+
+~~~ruby
+# Examples:
+ 
+# just respond with status number
+url "http://www.catchme.com"
+r 404
+
+# if you want to respond all requests with url 
+# equals "http://www.1688.com" with "Hello world!" :
+url "http://www.1688.com" 
+r "Hello world" 
+
+# or you can respond with Array
+url "http://china.alibaba.com"
+r [200, {}, "Got replaced"] #[status, header, body]
+
+# if you want to respond these requests with a file:
+# this url will be responded with content of somefile.txt
+# you can set headers and body in 'somefile.txt'
+url "http://www.yousite.com" 
+goto "/home/youruser/somefile.txt"
+
+# redirect to another url
+url "http://www.targetsite.com" 
+goto "http://www.real-request-target.com/test.html"
+
+# respond with text setting headers
+url "http://www.target-site.com/target-url"
+r <<-RESP
+    Test-Msg      : http-header-example
+    header-server : Auto-Responder
+    Content-Type  : text/html; charset=utf-8
+
+    <!Doctype html>
+    <html><body><h1>Hello world!</h1></body></html>
+  RESP
+
+# match with regexp
+url %r{http://pnq\.cc}
+r "Any request made to pnq.cc will be responded with this message."
+
+# regular expression and params
+url %r{http://anysite\.cc(.*)} do |uri, path|
+  <<-RESP
+    Content-Type  : text/html; charset=utf-8
+
+    <style>
+      body { font-size: 50pt; }
+      em { color: #ff7300; }
+      small { color: #ccc; }
+    </style>
+
+    With regular expression, you can do more powerful things.  <br/> 
+    You're requesting <em>#{path}</em> <br/>
+    <small>Server time is #{Time.now} now. </small>
+    RESP
+end
+~~~
+
+## TODO:
+* GUI monitor showing sessions

data/rules.sample

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+# This is the AutoResponse rule config file
+# using ruby syntax
+
+# Examples:
+ 
+# if you want to respond all requests with url 
+# equals "http://www.1688.com" with "Hello world!" :
+url "http://www.1688.com" 
+r "Hello world" 
+
+# or you can respond with Array
+url "http://china.alibaba.com"
+r [200, {}, "Got replaced"] #[status, header, body]
+
+# if you want to respond these requests with a file:
+url "http://www.yousite.com" 
+goto "/home/youruser/somefile.txt"
+
+# on Windows:
+url "http://www.another-site.com" 
+goto "C:/Program\ Files/proj/test.txt"
+
+# if you want to respond with another remote url:
+url "http://www.targetsite.com" 
+goto "http://www.real-request-target.com/test.html"
+
+# you can set response headers in the returned string
+# e.g.
+url "http://www.target-site.com/target-url"
+r <<-RESP
+    Test-Msg      : http-header-example
+    header-server : Auto-Responder
+    Content-Type  : text/html; charset=utf-8
+
+    <!Doctype html>
+    <html><body><h1>Hello world!</h1></body></html>
+  RESP
+
+# just respond with status number
+url "http://www.catchme.com"
+r 404
+
+# Example of using regexp
+url %r{http://pnq\.cc}
+r "Any request made to pnq.cc will be responded with this message."
+
+# Regular expression and params
+url %r{http://anysite\.cc(.*)} do |uri, path|
+  <<-RESP
+    Content-Type  : text/html; charset=utf-8
+
+    <style>
+      body { font-size: 50pt; }
+      em { color: #ff7300; }
+      small { color: #ccc; }
+    </style>
+
+    With regular expression, you can do more powerful things.  <br/> 
+    You're requesting <em>#{path}</em> <br/>
+    <small>Server time is #{Time.now} now. </small>
+    RESP
+end

data/test/all-test.rb

@@ -0,0 +1,32 @@
+gem 'test-unit'
+require 'test/unit'
+require 'test/unit/testsuite'
+require 'test/unit/ui/console/testrunner'
+
+require_relative 'respond_with_file_test'
+require_relative 'respond_with_string_test'
+require_relative 'respond_with_url_test'
+require_relative 'respond_with_array_test'
+require_relative 'respond_with_number_test'
+require_relative 'match_with_reg_test'
+require_relative 'response_text_parser_test'
+
+class ALLTests < Test::Unit::TestSuite
+
+  def self.suite
+    tests = Test::Unit::TestSuite.new
+
+    tests << ParserTest.suite
+    tests << TestRespondWithString.suite
+    tests << TestRespondWithFile.suite
+    tests << TestRespondWithURL.suite
+    tests << TestRespondWithArray.suite
+    tests << TestRespondWithStatusCode.suite
+    tests << TestMatchWithReg.suite
+    
+    tests
+  end
+end
+
+
+Test::Unit::UI::Console::TestRunner.run( ALLTests )

data/test/fixture/hello_world.txt

@@ -0,0 +1 @@
+Hello world!

data/test/fixture/passwd

@@ -0,0 +1,3 @@
+root:x:0:0:root:/root:/bin/bash
+daemon:x:1:1:daemon:/usr/sbin:/bin/sh
+bin:x:2:2:bin:/bin:/bin/sh

data/test/helper.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+require 'net/http'
+require_relative '../lib/autoresponse'
+
+FIXTURE = File.expand_path("fixture", File.dirname(__FILE__))
+
+module ARProxyTest
+
+  def setup
+    @ar = start_proxy_server('127.0.0.1', 8764)
+    @req = Net::HTTP::Proxy('127.0.0.1', 8764)
+  end
+
+  def start_proxy_server(host, port)
+    @ar = AutoResp::AutoResponder.new :host => host, :port => port
+    Thread.new {
+      @ar.start 
+      @ar.clear_rules
+    }
+    sleep 0.1
+    @ar
+  end
+
+  def teardown
+    stop_proxy_server
+  end
+
+  def stop_proxy_server
+    @ar.stop
+  end
+  
+end

data/test/match_with_reg_test.rb

@@ -0,0 +1,19 @@
+require_relative 'helper'
+
+class TestMatchWithReg < Test::Unit::TestCase
+
+  include ARProxyTest
+
+  def test_with_parts
+    @ar.add_rule %r(http://books.cc/(.*)/(.*)) do |uri, cat, page|
+      "cat: #{cat}; page: #{page}"
+    end
+    @req.start('books.cc') do |http|
+      http.request_get('/books/1') do |res|
+        assert_equal 'cat: books; page: 1', res.body
+        assert_equal "200", res.code
+      end
+    end
+  end
+
+end

data/test/respond_with_array_test.rb

@@ -0,0 +1,29 @@
+require_relative 'helper'
+
+class TestRespondWithArray < Test::Unit::TestCase
+
+  include ARProxyTest
+
+  def test_respond_with_good_status_array
+    @ar.add_rule 'http://www.test.com/' => [200, nil, 'test']
+    @req.start('www.test.com') do |http|
+      http.request_get('/') do |res|
+        assert_equal( nil, res.header["test"])
+        assert_equal 'test', res.body
+        assert_equal "200", res.code
+      end
+    end
+  end
+
+  def test_respond_with_404_status_array
+    @ar.add_rule 'http://www.1688.com' => [404, nil, 'test']
+    @req.start('www.1688.com') do |http|
+      http.request_get('/') do |res|
+        assert_equal( nil, res.header["test"])
+        assert_equal 'test', res.body
+        assert_equal "404", res.code
+      end
+    end
+  end
+
+end

data/test/respond_with_file_test.rb

@@ -0,0 +1,16 @@
+require_relative 'helper'
+
+class TestRespondWithFile < Test::Unit::TestCase
+
+  include ARProxyTest
+
+  def test_respond_with_simple_file
+    @ar.add_rule 'http://www.test.com/' => "=GOTO=> #{FIXTURE}/passwd"
+    @req.start('www.test.com') do |http|
+      http.request_get('/') do |res|
+        assert_equal IO.read("#{FIXTURE}/passwd"), res.body
+      end
+    end
+  end
+
+end

data/test/respond_with_number_test.rb

@@ -0,0 +1,25 @@
+require_relative 'helper'
+
+class TestRespondWithStatusCode < Test::Unit::TestCase
+
+  include ARProxyTest
+
+  def test_respond_with_500
+    @ar.add_rule 'http://www.163.com/' => 500
+    @req.start('www.163.com') do |http|
+      http.request_get('/') do |res|
+        assert_equal "500", res.code
+      end
+    end
+  end
+
+  def test_respond_with_404
+    @ar.add_rule 'http://www.163.com' => 404
+    @req.start('www.163.com') do |http|
+      http.request_get('/') do |res|
+        assert_equal "404", res.code
+      end
+    end
+  end
+
+end

data/test/respond_with_string_test.rb

@@ -0,0 +1,39 @@
+require_relative 'helper'
+
+class TestRespondWithString < Test::Unit::TestCase
+
+  include ARProxyTest
+
+  def test_respond_with_simple_string
+    @ar.add_rule 'http://www.test.com/' => 'test'
+    @req.start('www.test.com') do |http|
+      http.request_get('/') do |res|
+        assert_equal( nil, res.header["test"])
+        assert_equal 'test', res.body
+      end
+    end
+  end
+
+  def test_respond_uri_without_slash_with_simple_string
+    @ar.add_rule 'http://www.1688.com' => 'test'
+    @req.start('www.1688.com') do |http|
+      http.request_get('/') do |res|
+        assert_equal( nil, res.header["test"])
+        assert_equal 'test', res.body
+      end
+    end
+  end
+
+  def test_respond_with_header_and_body
+    response = %Q(server: autoresponder\nname: hello\n  \ntest)
+    @ar.add_rule 'http://www.1688.com/test' => response
+    @req.start('www.1688.com') do |http|
+      http.request_get('/test') do |res|
+        assert_equal( "autoresponder", res.header["server"])
+        assert_equal( "hello", res.header["name"])
+        assert_equal 'test', res.body
+      end
+    end
+  end
+
+end

data/test/respond_with_url_test.rb

@@ -0,0 +1,18 @@
+require_relative 'helper'
+
+class TestRespondWithURL < Test::Unit::TestCase
+
+  include ARProxyTest
+
+  def test_respond_with_simple_file
+    @ar.add_rule 'http://www.test.com/' => '=GOTO=> http://www.1688.com/crossdomain.xml'
+    @req.start('www.test.com') do |http|
+      http.request_get('/') do |res|
+        open("http://www.1688.com/crossdomain.xml") do |file|
+          assert_equal file.read, res.read_body
+        end
+      end
+    end
+  end
+
+end

data/test/response_text_parser_test.rb

@@ -0,0 +1,38 @@
+require_relative 'helper'
+
+class ParserTest < Test::Unit::TestCase
+
+  include AutoResp::Parser
+
+  def test_parse_only_body
+    headers, body = parse("test")
+    assert_equal nil, headers
+    assert_equal "test", body
+  end
+
+  def test_parse_only_header
+    headers, body = parse("test: good\n\n")
+    assert_equal({"test" => "good"}, headers)
+    assert body.empty?
+  end
+
+  def test_parse_header
+    headers, body = parse("test: good\n\ncontent")
+    assert_equal({"test"=>"good"}, headers)
+    assert_equal "content", body
+  end
+
+  def test_first_line_empty
+    headers, body = parse("  \ntest: good\n\ncontent")
+    assert_equal nil, headers
+    assert_equal "  \ntest: good\n\ncontent", body
+  end
+
+  def test_empty_line_in_middle
+    response = %Q(server: autoresponder\ntest: hello\n  \ntest)
+    headers, body = parse(response)
+    assert_equal({"server" => "autoresponder", "test" => "hello"}, headers)
+    assert_equal "test", body
+  end
+
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: auto_response
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- qhwa,,,
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-23 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: qhwa@163.com
+executables:
+- ar
+- start_ar.rb
+extensions: []
+extra_rdoc_files:
+- readme.md
+files:
+- readme.md
+- rules.sample
+- Gemfile
+- Gemfile.lock
+- bin/start_ar.rb
+- bin/ar
+- test/all-test.rb
+- test/response_text_parser_test.rb
+- test/respond_with_number_test.rb
+- test/respond_with_url_test.rb
+- test/respond_with_string_test.rb
+- test/respond_with_array_test.rb
+- test/fixture/passwd
+- test/fixture/hello_world.txt
+- test/respond_with_file_test.rb
+- test/helper.rb
+- test/match_with_reg_test.rb
+- lib/autoresponse.rb
+- lib/ar/parser.rb
+- lib/ar/proxyserver.rb
+- lib/ar/rule_manager.rb
+- lib/ar/rule_dsl.rb
+homepage: http://yoursite.example.com
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- readme.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: What this thing does
+test_files: []