carbon-copy 0.0.2

data/.gitignore

@@ -0,0 +1 @@
+.request_cache/

data/README.md

@@ -0,0 +1,24 @@
+# Carbon Copy - Easily cache them REST calls
+
+We created Carbon Copy to allow for quick front end (or back end) development by
+caching REST responses. We also wanted it to be easy and quick.
+
+### How it works
+
+Install the gem
+
+    gem install carbon-copy
+
+Run the server with a specified port
+
+    carbon-copy -p 8989
+
+Alter your REST calls on the front-end to pipe them locally through carbon-copy
+
+    $.get('http://localhost:8989/slow.server.com/resource')
+
+On the first run, the requests will be cached in the `.request_cache` directory
+in the same path as where you called the server. On subsequent requests, the
+calls will pull from that cache instead of contacting the server.
+
+You can restart the cache at any time by deleting the specific cache files.

data/bin/carbon-copy

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'carbon-copy'
+
+server = CarbonCopy::CacheServer.new
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Carbon Copy: Cache them RESTs"
+  opts.on("-p", "--port Port", "Port to run server") do |v|
+    server.run(v)
+  end
+end
+opts.parse!
+
+uri = ARGV.shift
+
+if uri.to_s.strip.empty?
+  puts opts
+  exit 1
+end

data/carbon-copy.gemspec

@@ -0,0 +1,17 @@
+$:.push File.expand_path("../lib", __FILE__)  
+require 'carbon-copy'
+
+Gem::Specification.new do |gem|
+  gem.authors = ["Kevin Webster"]
+  gem.email   = ["me@kdoubleyou.com"]
+
+  gem.description = "easily cache them REST calls"
+  gem.summary     = "REST cache"
+  gem.homepage    = 'https://github.com/rabidpraxis/carbon-copy'
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- spec/*`.split("\n")
+  gem.name          = "carbon-copy"
+  gem.require_paths = ["lib"]
+  gem.version       = CarbonCopy::VERSION
+  gem.executables   = ['carbon-copy']
+end

data/lib/carbon-copy.rb

@@ -0,0 +1,6 @@
+require 'carbon-copy/cache_server'
+require 'carbon-copy/http_cacher'
+
+module CarbonCopy
+  VERSION = '0.0.2'
+end

data/lib/carbon-copy/cache_server.rb

@@ -0,0 +1,71 @@
+require 'socket'
+require 'open-uri'
+require 'openssl'
+require 'carbon-copy/http_cacher'
+
+module CarbonCopy
+  class CacheServer
+
+    def run(port)
+      webserver = TCPServer.new('127.0.0.1', port)
+      puts "Running Carbon Copy on localhost port #{port}"
+      while (session = webserver.accept)
+        Thread.new(session, &method(:handle))
+      end
+    end
+
+    def parse_request(session)
+      request = session.readline
+
+      parsed = {}
+      #---  Initial host/uri information  -------------------------------------
+      parsed[:verb]    = request[/^\w+/]
+      parsed[:url]     = request[/^#{parsed[:verb]}\s+\/(\S+)/, 1]
+      parsed[:host]    = request[/^#{parsed[:verb]}\s+\/([^\/ ]+)/, 1]
+      parsed[:version] = request[/HTTP\/(1\.\d)\s*$/, 1]
+      parsed[:uri]     = request[/^#{parsed[:verb]}\s+\/#{parsed[:host]}(\S+)\s+HTTP\/#{parsed[:version]}/, 1] || '/'
+
+      uri = URI::parse(parsed[:uri])
+      parsed[:request_str] = "#{parsed[:verb]} #{uri.path}?#{uri.query} HTTP/#{parsed[:version]}\r"
+
+      #---  Header and final response text  -----------------------------------
+      parsed[:headers] = parse_headers(session)
+      
+      #---  Update header info  -----------------------------------------------
+      parsed[:headers]["Host"]   = parsed[:host]
+
+      parsed[:header_str] = parsed[:headers].map{|a, b| "#{a}: #{b}"}.join("\r\n")
+      parsed[:response] = "#{parsed[:request_str]}\n#{parsed[:header_str]}\r\n\r\n"
+
+      parsed
+    end
+    
+    def parse_headers(request)
+      header = {}
+      unless request.eof?
+        loop do
+          line = request.readline
+          if line.strip.empty?
+            break
+          end
+
+          /^(\S+): ([^\r\n]+)/.match(line)
+          header[$1] = $2
+        end
+      end
+      header
+    end
+
+    def handle(session)
+      begin
+        req = parse_request(session)
+        resp = HTTPCacher.new.connect(req)
+        session.write(resp)
+        session.close
+      rescue => e
+        p e.message
+        p e.backtrace
+      end
+    end
+  end
+end

data/lib/carbon-copy/http_cacher.rb

@@ -0,0 +1,91 @@
+require 'digest/md5'
+
+module CarbonCopy
+  class HTTPCacher
+    attr_reader :base_dir
+
+    def initialize(base_dir = Dir.pwd)
+      @base_dir = base_dir
+    end
+
+    #--------------------------------------------------------------------------
+    # Setup cache directory
+    #--------------------------------------------------------------------------
+    def cache_dir
+      "#{base_dir}/.request_cache"
+    end
+
+    #--------------------------------------------------------------------------
+    # Determine final path
+    #--------------------------------------------------------------------------
+    def path(parsed)
+      uri = ( parsed[:uri] == '/' ) ? '' : parsed[:uri].gsub("\/", "_")
+      hash = Digest::MD5.new << parsed[:header_str]
+      #---  Cache directory structure  ----------------------------------------
+      """
+        #{cache_dir}/
+          #{parsed[:host]}/
+            #{parsed[:verb].downcase}
+            #{uri}_
+            #{hash}
+      """.gsub(/\n|\s/, '')
+    end
+
+    #--------------------------------------------------------------------------
+    # Ensure cached directories are created
+    #--------------------------------------------------------------------------
+    def verify_cached_dir(parsed)
+      Dir.mkdir(cache_dir) unless File.exists?(cache_dir)
+      host_cache = "#{cache_dir}/#{parsed[:host]}"
+      Dir.mkdir(host_cache) unless File.exists?(host_cache)
+    end
+
+    def get_response(parsed)
+      a = TCPSocket.new(parsed[:host], 80)
+      a.write(parsed[:response])
+
+      #---  Pull request data  ------------------------------------------------
+      content_len = nil
+      buff = ""
+      loop do
+        line = a.readline
+        buff += line
+        if line =~ /^Content-Length:\s+(\d+)\s*$/
+          content_len = $1.to_i
+        end
+        break if line.strip.empty?
+      end
+
+      #---  Pull response  ----------------------------------------------------
+      if content_len
+        buff += a.read(content_len)
+      else
+        loop do
+          if a.eof? || line = a.readline || line.strip.empty?
+            break
+          end
+          buff += line
+        end
+      end
+      a.close
+
+      buff
+    end
+
+    def connect(parsed)
+      verify_cached_dir(parsed)
+      cached_path = path(parsed)
+
+      if File.exists?(cached_path) && !File.zero?(cached_path)
+        puts "Getting file #{cached_path} from cache"
+        IO.read( cached_path )
+      else
+        resp = get_response(parsed)
+        File.open( cached_path, 'w' ) do |f|
+          f.puts resp
+        end
+        resp
+      end
+    end
+  end
+end

data/spec/cache_server_spec.rb

@@ -0,0 +1,101 @@
+require File.expand_path('../../lib/carbon-copy', __FILE__)
+require 'open-uri'
+require 'net/http'
+
+describe CarbonCopy::CacheServer do
+  describe '#parse_headers' do
+    let(:rs) { CarbonCopy::CacheServer.new }
+    
+    it 'should parse easy header strings' do
+      st = StringIO.new
+      st << "TestHeader: Header Result"
+      st << "\r\n\r\n"
+      st.rewind
+      rs.parse_headers(st).should eq({"TestHeader" => "Header Result"})
+    end
+
+    it 'should parse multi-line headers' do
+      st = StringIO.new
+      st << "TestHeader: Header Result\n"
+      st << "TestHeaders: Header Result"
+      st << "\r\n\r\n"
+      st.rewind
+      rs.parse_headers(st).should eq({
+        "TestHeader" => "Header Result",
+        "TestHeaders" => "Header Result"
+      })
+    end
+  end
+
+  describe '#parse_request' do
+    let(:rs) { CarbonCopy::CacheServer.new }
+    let(:req) { rs.parse_request(request) }
+    
+    describe 'host with path' do
+      let(:request) { 
+        req = StringIO.new << "GET /apple.com/google/face/ HTTP/1.1\n"
+        req.rewind 
+        req
+      }
+
+      it 'verb' do
+        req[:verb].should eq("GET")
+      end
+
+      it 'url with path' do
+        req[:url].should eq('apple.com/google/face/')
+      end
+
+      it 'version' do
+        req[:version].should eq('1.1')
+      end
+
+      it 'host' do
+        req[:host].should eq('apple.com')
+      end
+
+      it 'uri' do
+        req[:uri].should eq('/google/face/')
+      end
+
+      it 'request_str' do
+        req[:request_str].should eq("GET /google/face/? HTTP/1.1\r")
+      end
+    end
+
+    describe 'just host' do
+      let(:request) { 
+        req = StringIO.new << "GET /apple.com HTTP/1.1\n"
+        req.rewind 
+        req
+      }
+      it 'host' do
+        req[:host].should eq('apple.com')
+      end
+
+      it 'uri' do
+        req[:uri].should eq('/')
+      end
+    end
+
+  end
+
+  describe '#handle' do
+    before(:all) do
+      Thread.new do
+        CarbonCopy::CacheServer.new.run(7979)
+      end
+    end
+
+    it 'caches google.com simple get request' do
+      url = 'www.apple.com'
+      o_req = get("http://#{url}").body
+      req   = get("http://localhost:7979/#{url}").body
+      req.should eq(o_req)
+    end
+  end
+end
+
+def get(url)
+  Net::HTTP.get_response(URI.parse(url))
+end

data/spec/http_cacher_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../lib/carbon-copy', __FILE__)
+require 'digest/md5'
+
+describe CarbonCopy::HTTPCacher do
+  let(:cacher) { CarbonCopy::HTTPCacher.new }
+  let(:parsed) {
+    {
+      verb: 'GET',
+      url: 'gist.github.com/74107',
+      host: 'gist.github.com',
+      version: '1.1',
+      uri: '/74107',
+      header_str: 'Test Header: Test Result'
+    }
+  }
+  it 'should have path with url' do
+    hash = Digest::MD5.new << parsed[:header_str]
+    cacher.path(parsed).should match(/\.request_cache\/gist\.github\.com\/get_74107_#{hash}/)
+  end
+
+  it 'should reflect no path' do
+    hash = Digest::MD5.new << parsed[:header_str]
+    parsed[:url] = 'gist.github.com'
+    parsed[:uri] = '/'
+    cacher.path(parsed).should match(/\.request_cache\/gist\.github\.com\/get_#{hash}/)
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: carbon-copy
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Kevin Webster
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-02 00:00:00.000000000 Z
+dependencies: []
+description: easily cache them REST calls
+email:
+- me@kdoubleyou.com
+executables:
+- carbon-copy
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README.md
+- bin/carbon-copy
+- carbon-copy.gemspec
+- lib/carbon-copy.rb
+- lib/carbon-copy/cache_server.rb
+- lib/carbon-copy/http_cacher.rb
+- spec/cache_server_spec.rb
+- spec/http_cacher_spec.rb
+homepage: https://github.com/rabidpraxis/carbon-copy
+licenses: []
+post_install_message: 
+rdoc_options: []
+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: REST cache
+test_files:
+- spec/cache_server_spec.rb
+- spec/http_cacher_spec.rb
+has_rdoc: