em-couchdb-request 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in em-couchdb-request.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Louie Zhao
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Em::Couchdb::Request
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'em-couchdb-request'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install em-couchdb-request
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/em-couchdb-request.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'em-couchdb-request/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "em-couchdb-request"
+  gem.version       = EventMachine::Couchdb::VERSION
+  gem.authors       = ["Louie Zhao"]
+  gem.email         = ["louie.zhao@gmail.com"]
+  gem.description   = %q{EventMachine based, async CouchDB request client}
+  gem.summary       = %q{EventMachine based, async CouchDB request client}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  
+  gem.add_dependency "json"
+  gem.add_dependency "em-http-request"
+  gem.add_development_dependency "rspec"
+end

data/lib/em-couchdb-request/base.rb

@@ -0,0 +1,53 @@
+module EventMachine
+  module Couchdb
+    
+    class Base
+      
+      attr_reader :connect_options, :request_options
+      
+      REQUEST_OPTIONS = {
+        :head => {
+          'content-type' => 'application/json'
+        }
+      }
+      
+      def log(msg, start_at=Time.now)
+        span = "%8.2f" % ((Time.now - start_at) * 1000)
+        puts "#{Time.now.strftime("%X")}\t#{span}\t#{msg}"
+      end
+      
+      protected
+        
+      def base_uri
+        raise NotImplementedError
+      end
+      
+      def new_http_request(opts={}, &callback)
+        start_at = Time.now
+        
+        url = opts.delete :url
+        method = opts.delete(:method) || :get
+
+        request_options = REQUEST_OPTIONS.merge(@request_options || {})
+        
+        http = EventMachine::HttpRequest.new("#{base_uri}/#{url}", @connect_options).send method, request_options.merge(opts)
+          
+        http.callback {
+          resp = JSON.load(http.response) rescue {}
+          callback.call resp
+        }
+          
+        http.errback {
+          log "#{http.error || 'ERROR'}:\tunable to #{method} #{url}", start_at
+        }
+        
+        http
+      end
+      
+      def paramize(opts)
+        opts.collect{ |k, v| "#{k}=#{v}" }.join('&')
+      end
+    end
+    
+  end
+end

data/lib/em-couchdb-request/database.rb

@@ -0,0 +1,50 @@
+module EventMachine
+  module Couchdb
+
+    class Database < Base
+      
+      attr_reader :name
+      
+      def initialize(uri, name, opts={})
+        @uri = uri
+        @name = name
+        @connect_options = opts[:connect_options] || {}
+        @request_options = opts[:request_options] || {}
+      end
+      
+      def base_uri
+        [@uri, @name].join('/')
+      end
+      
+      def all_docs(&callback)
+        new_http_request :url => "_all_docs", &callback
+      end
+      
+      def doc(doc_id, &callback)
+        new_http_request :url => doc_id, &callback
+      end
+      
+      def save_doc(doc, &callback)
+        method = doc['id'] ? :put : :post
+        new_http_request :url => doc['id'], :method => method, :body => JSON.dump(doc), &callback
+      end
+      
+      def delete_doc(doc, &callback)
+        new_http_request :url => "#{doc['id']}?rev=#{doc['rev']}", :method => :delete, &callback
+      end
+      
+      def changes(opts, &stream)
+        http = new_http_request(:url => "_changes?#{paramize(opts)}") {}
+
+        http.stream { |chunk|
+          data = JSON.load(chunk) rescue {}
+          stream.call data
+        }
+        
+        http
+      end
+      
+    end
+    
+  end
+end

data/lib/em-couchdb-request/load_testing/agent.rb

@@ -0,0 +1,145 @@
+module EventMachine
+  module Couchdb
+    module LoadTesting
+
+      class KeyboardHandler < EM::Connection
+        include EM::Protocols::LineText2
+
+        def initialize(project)
+          @project = project
+        end
+
+        def receive_line(data)
+          @project.lock = false
+        end
+      end
+  
+      class Agent
+        DEFAULT_OPTIONS = {
+          :content_size => 1024 * 1,    # size of random bytes written to a random document in the database
+          :push_interval => 20,         # interval between PUSH
+          :poll_interval => 0.001,      # interval between generating POLL connections - control the creating speed
+          :poll_max_count => 2500,      # count of the total POLL connections
+          :poll_bulk_count => 500,      # size of a POLL GROUP - that is created continously (step by POLL_INTERVAL)
+          :poll_bulk_interval => 1200   # interval between POLL GROUP (or continue by pressing any key)
+        }
+        
+        # lock to disable creating new poll connection
+        attr_accessor :lock
+    
+        def initialize(uri, name, opts={})
+          @server = EventMachine::Couchdb::Server.new uri, opts
+          @db = @server.em_database(name)
+          @docs = []
+
+          @max_id = 0
+          @count = 0
+          @lock = false
+          
+          @options = DEFAULT_OPTIONS.merge(opts[:agent_options])
+        end
+    
+        def push
+          EM.run {
+            @db.all_docs { |resp|
+              @docs = resp["rows"].collect{ |row| row["id"] }
+            }
+        
+            puts ">> Start to push to #{@db.base_uri} every #{@options[:push_interval]} seconds ..."
+        
+            EM.add_periodic_timer(@options[:push_interval]) {
+              #
+              # --- why get the doc first before updating ---
+              #
+              # To update an existing document, you also issue a PUT request.
+              # In this case, the JSON body must contain a _rev property, which lets CouchDB know which revision the edits are based on.
+              # If the revision of the document currently stored in the database doesn't match, then a 409 conflict error is returned.
+              begin
+                start_at = Time.now
+                @db.doc(@docs.sample) { |resp|
+                  # set the new content
+                  resp[:random_bytes] = SecureRandom.hex(@options[:content_size])
+                  # update doc and record the latest revision
+                  @db.save_doc(resp) { |resp|
+                    @db.log "PUSH\t#{@options[:content_size]}\t#{resp["rev"]}", start_at
+                  }
+                }
+              rescue
+                @db.log "PUSH\t#{@options[:content_size]}\t#{resp["rev"]}", start_at
+              end
+            }
+          }
+        end
+    
+        def poll
+          # http://eventmachine.rubyforge.org/docs/EPOLL.html
+          EM.epoll
+      
+          EM.run {
+            EM.open_keyboard(KeyboardHandler, self)
+            
+            @server.get_db(@db.name) { |resp|
+              # ensure to get something for feedback when connection
+              seq = resp["update_seq"] - 1
+
+              # auto continue for each POLL_BULK_INTERVAL
+              b_timer = nil
+              if @options[:poll_bulk_interval] > 0
+                b_timer = EM.add_periodic_timer(@options[:poll_bulk_interval]) {
+                  @lock = false
+                }
+              end
+              
+              puts ">> Start to poll from #{@db.base_uri} (since #{seq}) every #{@options[:poll_interval]} seconds ..."
+          
+              timer = EM.add_periodic_timer(@options[:poll_interval]) {
+                new_poll_request(:seq => seq) unless @lock
+
+                if @max_id % @options[:poll_bulk_count] == 0
+                  @lock = true 
+                end
+            
+                if @max_id >= @options[:poll_max_count]
+                  timer.cancel
+                  b_timer.try(:cancel)
+                end
+              }
+            }
+          }
+        end
+    
+        protected
+    
+        def new_poll_request(opts={})
+          # simulate 'AUTO INCREMENT ID' for index
+          @count += 1
+          @max_id += 1
+          index = @max_id
+          start_at = Time.now
+
+          # http://wiki.apache.org/couchdb/HTTP%5Fdatabase%5FAPI#Changes
+          # heartbeat - overrides any timeout to keep the feed alive indefinitely.
+          # num - help to debug
+          http = @db.changes({:feed => 'continuous', :heartbeat => 600000, :since => opts[:seq], :num => index}) { |chunk|
+            # {"seq"=>76, "id"=>"eventmachine_couchdb_document", "changes"=>[{"rev"=>"40-084b145e56f8f1edd2d4cd94b8a01561"}]}
+            rev = (chunk['changes'] || [{}]).last['rev']
+            @db.log "[#{index}]\t#{@count}\tPOLL\t#{rev}", start_at
+            start_at = Time.now
+          }
+            
+          http.callback {
+            @count -= 1
+            @db.log "[#{index}]\t#{@count}\tE_PO\t#{http.response}", start_at
+            EM.stop if @count == 0
+          }
+            
+          http.errback {
+            @count -= 1
+            @db.log "[#{index}]\t#{@count}\tF_PO\t#{http.error || 'ERROR'}", start_at
+            EM.stop if @count == 0
+          }
+        end
+      end
+    end
+  end
+end

data/lib/em-couchdb-request/server.rb

@@ -0,0 +1,55 @@
+module EventMachine
+  module Couchdb
+    
+    class Server < Base
+
+      attr_reader :uri
+
+      def initialize(uri, opts={})
+        @uri = uri
+        @connect_options = opts[:connect_options] || {}
+        @request_options = opts[:request_options] || {}
+      end
+      
+      def em_database(db_name)
+        Database.new @uri, db_name, {:connect_options => @connect_options, :request_options => @request_options}
+      end
+      
+      # Async http request
+        
+      def all_dbs(&callback)
+        new_http_request :url => "_all_dbs", &callback
+      end
+      
+      def get_db(db_name, &callback)
+        new_http_request :url => db_name, &callback
+      end
+
+      def create_db(db_name, &callback)
+        new_http_request :url => db_name, :method => :put, &callback
+      end
+      
+      def delete_db(db_name, &callback)
+        new_http_request :url => db_name, :method => :delete, &callback
+      end
+      
+      def ensure_db(db_name, &callback)
+        get_db(db_name) { |resp|
+          if resp['db_name']
+            callback.call
+          else
+            create_db(db_name, &callback)
+          end
+        }
+      end
+        
+      protected
+        
+      def base_uri
+        @uri
+      end
+
+    end
+    
+  end
+end

data/lib/em-couchdb-request/version.rb

@@ -0,0 +1,5 @@
+module EventMachine
+  module Couchdb
+    VERSION = "0.0.1"
+  end
+end

data/lib/em-couchdb-request.rb

@@ -0,0 +1,8 @@
+require "json"
+require "eventmachine"
+require "em-http-request"
+
+require "em-couchdb-request/version"
+require "em-couchdb-request/base"
+require "em-couchdb-request/server"
+require "em-couchdb-request/database"

data/spec/database_spec.rb

@@ -0,0 +1,92 @@
+require 'helper'
+
+describe EventMachine::Couchdb do
+
+  server = EventMachine::Couchdb::Server.new('http://127.0.0.1:5984')
+  
+  document = {
+    :time => Time.now
+  }
+
+  context "database" do
+    it "should create/get/delete document" do
+      EventMachine.run {
+        server.ensure_db(DB_NAME_PRFIX) {
+          db = server.em_database(DB_NAME_PRFIX)
+          db.save_doc(document) { |resp|
+            # {"ok"=>true, "id"=>"03399b2af07128fd8bba5650f301f97f", "rev"=>"1-5f68969911f890fe17b3c440b6e6f517"}
+            resp['ok'].should == true
+            doc_id = resp['id']
+            db.all_docs { |resp|
+              # {"total_rows"=>2, "offset"=>0, "rows"=>[{"id"=>"03399b2af07128fd8bba5650f3032057", "key"=>"03399b2af07128fd8bba5650f3032057", "value"=>{"rev"=>"1-bdf934324ba35521452df4abb4d92e30"}}, {"id"=>"eventmachine_couchdb_document", "key"=>"eventmachine_couchdb_document", "value"=>{"rev"=>"16-09f0db6392d6595615ae36bbdc9cc5d0"}}]} to include "03399b2af07128fd8bba5650f3032057"
+              resp["rows"].collect{ |row| row["id"] }.should include(doc_id)
+              db.doc(doc_id) { |resp|
+                # {"_id"=>"03399b2af07128fd8bba5650f301f97f", "_rev"=>"1-5f68969911f890fe17b3c440b6e6f517", "time"=>"2012-11-29 17:36:00 +0800"}
+                resp[:time] = Time.now
+                db.save_doc(resp) { |resp|
+                  # {"ok"=>true, "id"=>"03399b2af07128fd8bba5650f301f97f", "rev"=>"2-7e493efb649ace136d0f23c59a089f3d"}
+                  resp['ok'].should == true
+                  db.delete_doc(resp) { |resp|
+                    # {"ok"=>true, "id"=>"03399b2af07128fd8bba5650f301f97f", "rev"=>"3-9de477509c9e66189f33bd7fae9b17db"}
+                    resp['ok'].should == true
+                    EventMachine.stop
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    end
+    
+    it "should get continuous changes" do
+      latest_rev = nil
+      check_times = 0
+      
+      EventMachine.run {
+        server.ensure_db(DB_NAME_PRFIX) {
+          db = server.em_database(DB_NAME_PRFIX)
+          
+          # Get database update_seq and fire the continous poll conncetion to wait for changes
+          server.get_db(DB_NAME_PRFIX) { |resp|
+            seq = resp["update_seq"]
+            db.changes({:feed => 'continuous', :since => seq}) { |chunk|
+              # {"seq"=>76, "id"=>"eventmachine_couchdb_document", "changes"=>[{"rev"=>"40-084b145e56f8f1edd2d4cd94b8a01561"}]}
+              if rev = (chunk['changes'].first['rev'] rescue nil)
+                rev.should == latest_rev
+                EventMachine.stop if (check_times += 1) == 4
+              end
+            }
+          }
+          
+          EventMachine.add_periodic_timer(0.5) do
+            #
+            # --- why get the doc first before updating ---
+            #
+            # To update an existing document, you also issue a PUT request.
+            # In this case, the JSON body must contain a _rev property, which lets CouchDB know which revision the edits are based on.
+            # If the revision of the document currently stored in the database doesn't match, then a 409 conflict error is returned.
+            
+            db.doc(DOC_ID_PREFIX) { |resp|
+              # set to create the document if not exist
+              if resp['error'] == 'not_found'
+                resp = document
+                resp['id'] = DOC_ID_PREFIX
+              end
+              
+              # set the new content
+              resp[:time] = Time.now
+              
+              # update doc and record the latest revision
+              db.save_doc(resp) { |resp|
+                latest_rev = resp['rev']
+              }
+            }
+          end
+        }
+      }
+    end
+        
+  end
+  
+end

data/spec/helper.rb

@@ -0,0 +1,4 @@
+require 'em-couchdb-request'
+
+DB_NAME_PRFIX = "eventmachine_couchdb_database"
+DOC_ID_PREFIX = "eventmachine_couchdb_document"

data/spec/server_spec.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+describe EventMachine::Couchdb do
+
+  context "server" do
+    server = EventMachine::Couchdb::Server.new('http://127.0.0.1:5984')
+
+    it "should create/get/delete database" do
+      db_name = "#{DB_NAME_PRFIX}_#{Time.now.to_i}"
+      
+      EventMachine.run {
+        server.create_db(db_name) { |resp|
+          resp['ok'].should == true
+          server.all_dbs { |resp|
+            resp.should include(db_name)
+            server.get_db(db_name) { |resp|
+              resp['update_seq'].should == 0
+              server.delete_db(db_name) { |resp|
+                resp['ok'].should == true
+                EventMachine.stop  
+              }
+            }
+          }
+        }
+      }
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: em-couchdb-request
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Louie Zhao
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: EventMachine based, async CouchDB request client
+email:
+- louie.zhao@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- em-couchdb-request.gemspec
+- lib/em-couchdb-request.rb
+- lib/em-couchdb-request/base.rb
+- lib/em-couchdb-request/database.rb
+- lib/em-couchdb-request/load_testing/agent.rb
+- lib/em-couchdb-request/server.rb
+- lib/em-couchdb-request/version.rb
+- spec/database_spec.rb
+- spec/helper.rb
+- spec/server_spec.rb
+homepage: ''
+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: EventMachine based, async CouchDB request client
+test_files:
+- spec/database_spec.rb
+- spec/helper.rb
+- spec/server_spec.rb