watercooling 0.0.2 → 0.0.3

data/README.md

@@ -2,7 +2,7 @@
 
 Asynchronous webhook queueing with skinny daemon support.
 
-Inspired by @progriums Hookah and Watercoolr (http://watercoolr.nuklei.com/).
+Inspired by Watercoolr (http://watercoolr.nuklei.com/) and @progrium's Hookah.
 
 # Installing
 
@@ -15,7 +15,7 @@ From source:
     rake build
     sudo rake install
 
-# Start
+# Starting
 
 Start as a regular server:
 
@@ -25,20 +25,32 @@ Start as a daemon:
 
     watercooling start -d
 
-# Use
+# Using
 
-Send out a webhook to be asynchronous queued and sent.
+Required param:
 
-The _url param is required. All other params are optional.
+* _url [webhook end destination]
+
+Optional params:
+
+* _callback [url for POST request on SUCCESS]
+* _errback [url for POST request on FAILURE]
+
+Example:
     
-    → POST /dispatch { '_url':'http://www.postbin.org/1jp87ds', 'param1':'value1', etc.. }
+    → POST /dispatch { '_url':'http://www.postbin.org/1jp87ds', '_callback':'http://callbackaddress.com', '_errback':'http://errbackaddress.com', etc.. }
     
 # Todo
 
 * pub/sub support
+* true evented support
 * web interface
 * application configuration
-* success and error callbacks
+* <del>success and error callbacks</del>
+
+# Helping
+
+Help me make this a better product. Contact me at linuxsable@gmail.com.
 
 # Copyright
 

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/watercooling/models/webhook.rb

@@ -4,6 +4,8 @@ class Webhook
   property :id, Serial
   property :queued, Boolean, :default => false
   property :url, String
+  property :callback, String
+  property :errback, String
   property :sent, Boolean, :default => false
   property :sent_at, DateTime
   property :send_error, String

data/lib/watercooling/postbin.rb

@@ -4,5 +4,5 @@ require 'rest-client'
 url = "http://localhost:2003"
 
 puts "sending webhook"
-resp = RestClient.post(url + '/dispatch', :_url => ARGV[0], :test_param1 => 'test1', :test_param2 => 'test2')
+resp = RestClient.post(url + '/dispatch', :_url => ARGV[0], :test_param1 => 'test1', :_callback => ARGV[0], :_errback => ARGV[0])
 puts resp

data/lib/watercooling/webhook_queue.rb

@@ -9,10 +9,12 @@ class WebhookQueue
     EM.add_periodic_timer(1) {
       send_current_webhooks
     }
+    puts "Watercoolr is cooling..."
   end
   
-  # Loop through all pending messages and send them.
-  # Allow a max retry of @@retries
+private
+  
+  # Currently this method is blocking.
   def send_current_webhooks
     queued_webhooks = Webhook.all(:queued => true, :sent => false)
     queued_webhooks.each do |webhook|
@@ -20,21 +22,54 @@ class WebhookQueue
       while trys > 0
         num_tries = 4 - trys
         begin
-          # Grab all the webhook params and send em
-          params = {}
-          webhook.params.each { |param| params[param.name] = param.value }
-          response = HTTPClient.post(webhook.url, JSON.generate(params))
+          send_webhook(webhook)
           webhook.update!(:sent => true, :sent_at => Time.now, :queued => false, :send_num_tries => num_tries)
+          callback(webhook)
           break
         rescue => e
           trys -= 1
-          sleep 1
           if trys == 0
             # Failed to send. Take it off the queue and log error.
             webhook.update!(:sent => false, :queued => false, :send_error => e, :send_num_tries => num_tries)
+            errback(webhook)
           end
         end
       end
     end
   end
+  
+  # Fire off the webhook
+  def send_webhook(webhook)
+    params = {}
+    webhook.params.each { |param| params[param.name] = param.value }
+    HTTPClient.post(webhook.url, params)
+  end
+  
+  # Send a POST back to user on SUCCESS if callback url supplied
+  def callback(webhook)
+    return false if webhook.callback.nil?
+    operation = proc {
+      HTTPClient.post(webhook.callback,
+        :status         => 'OK',
+        :id             => webhook.id,
+        :sent_at        => webhook.sent_at.to_time.to_i,
+        :send_num_tries => webhook.send_num_tries
+      )
+    }
+    EM.defer(operation)
+  end
+  
+  # Send a POST back to user on ERROR if errback url supplied
+  def errback(webhook)
+    return false if webhook.errback.nil?
+    operation = proc {
+      HTTPClient.post(webhook.errback, 
+        :status         => 'FAIL',
+        :id             => webhook.id,
+        :send_error     => webhook.send_error,
+        :send_num_tries => webhook.send_num_tries
+      )
+    }
+    EM.defer(operation)
+  end
 end

data/lib/watercooling.rb

@@ -20,8 +20,12 @@ require File.dirname(__FILE__) + '/watercooling/models/param'
 class Watercooling < Sinatra::Base
   # Database config
   configure :production, :development do
-    db = "sqlite3:///#{Dir.pwd}/lib/watercooling.sqlite3"
-    DataMapper.setup(:default, db)
+    db_path = "#{ENV['HOME']}/.watercooling"
+    if !File.exist?(db_path)
+      puts "Creating directory \"#{ENV['HOME']}/.watercooling\"."
+      FileUtils.mkdir(db_path)
+    end
+    DataMapper.setup(:default, 'sqlite3:///' + db_path + '/database.sqlite3')
   end
 
   configure :test do
@@ -39,7 +43,7 @@ class Watercooling < Sinatra::Base
   end
   
   configure do
-    # Fire up the message queue
+    # Fire up the webhook queue
     Thread.new do
       until EM.reactor_running?
         sleep 1
@@ -57,27 +61,31 @@ class Watercooling < Sinatra::Base
     erb :index
   end
   
-  # Accept a webhook with a special field of _url to be queued to be sent out.
+  # Accept a webhook with a special to be queued to be sent out
   post '/dispatch' do
     content_type :json
     response = false
-    
+
     if params[:_url]
-      if webhook = Webhook.create(:queued => true, :url => params[:_url])
-        params.each do |key, value|
-          unless key == '_url'
-            response = webhook.params.create(:name => key, :value => value)
-          end
+      webhook = Webhook.create(
+        :queued   => true,
+        :url      => params[:_url],
+        :callback => params[:_callback],
+        :errback  => params[:_errback]
+      )
+      
+      meta_params = ['_url', '_callback', '_errback']
+      params.each do |key, value|
+        unless meta_params.include?(key)
+          response = webhook.params.create(:name => key, :value => value)
         end
-      else
-        fail_reason = "Couldn't queue webhook."
       end
     else
       fail_reason = '_url post param required.'
     end
     
     if response
-      { :status => 'OK' }.to_json
+      { :status => 'OK', :id => webhook.id }.to_json
     else
       { :status => 'FAIL', :reason => fail_reason }.to_json
     end

data/spec/watercooling_spec.rb

@@ -7,19 +7,34 @@ URL = 'http://localhost:2003'
 # address of your app before running the tests.
 describe "watercooling" do
   it "should add webhook" do
-    response = RestClient.post(URL + '/dispatch', :_url => 'http://google.com', :test_param => 'test')
+    response = RestClient.post(URL + '/dispatch',
+      :_url => 'http://google.com',
+      :_callback => 'http://google.com',
+      :_errback => 'http://google.com',
+      :test_param => 'test'
+    )
     JSON.parse(response)['status'].should == 'OK'
   end
   
   it "should fail if _url is missing" do
-    response = RestClient.post(URL + '/dispatch', :url => 'http://google.com', :test_param => 'test')
+    response = RestClient.post(URL + '/dispatch',
+      :url => 'http://google.com',
+      :_callback => 'http://google.com',
+      :_errback => 'http://google.com',
+      :test_param => 'test'
+    )
     JSON.parse(response)['status'].should == 'FAIL'
   end
   
   it "should add webhook to queue" do
     _url = 'http://asdf.com'
     
-    RestClient.post(URL + '/dispatch', :_url => _url, :test_param => 'test')
+    response = RestClient.post(URL + '/dispatch',
+      :_url => _url,
+      :_callback => 'http://google.com',
+      :_errback => 'http://google.com',
+      :test_param => 'test'
+    )
     webhook = Webhook.first(:url => _url)
     webhook.id.should > 0
     

data/watercooling.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{watercooling}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["@_ty"]
-  s.date = %q{2010-09-01}
+  s.date = %q{2010-09-12}
   s.default_executable = %q{watercooling}
   s.description = %q{Asynchronous webhook queueing with skinny daemon support.}
   s.email = %q{linuxsable@gmail.com}

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: watercooling
 version: !ruby/object:Gem::Version 
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - "@_ty"
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-01 00:00:00 -07:00
+date: 2010-09-12 00:00:00 -07:00
 default_executable: watercooling
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,6 +26,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 13
         segments: 
         - 1
         - 2
@@ -76,6 +78,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -84,6 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"