komrade-client 1.0.0

data/lib/komrade.rb

@@ -0,0 +1,36 @@
+require 'uri'
+
+module Komrade
+  extend self
+  Error = Class.new(StandardError)
+
+  def env(key)
+    ENV[key]
+  end
+
+  def env!(key)
+    env(key) || raise(Error, "Komrade requires #{key} be set in the ENV.")
+  end
+
+  def url
+    URI.parse(env!("KOMRADE_URL"))
+  end
+
+  def log(data)
+    result = nil
+    if data.key?(:measure)
+      data[:measure].insert(0, "komrade.")
+    end
+    if block_given?
+      start = Time.now
+      result = yield
+      data.merge!(val: (Time.now - start))
+    end
+    data.reduce(out=String.new) do |s, tup|
+      s << [tup.first, tup.last].join("=") << " "
+    end
+    $stdout.puts(out)
+    return result
+  end
+
+end

data/lib/komrade/http_helpers.rb

@@ -0,0 +1,74 @@
+require 'json'
+require 'net/http'
+require 'komrade'
+require 'komrade/rate_limiter'
+
+module Komrade
+  module HttpHelpers
+    MAX_RETRY = 4
+
+    def put(path, body)
+      make_request(Net::HTTP::Put.new(path), body)
+    end
+
+    def get(path)
+      make_request(Net::HTTP::Get.new(path))
+    end
+
+    def delete(path)
+      make_request(Net::HTTP::Delete.new(path))
+    end
+
+    def make_request(req, body=nil)
+      req.basic_auth(Komrade.url.user, Komrade.url.password)
+      if body
+        begin
+          req.content_type = 'application/json'
+          req.body = JSON.dump(body)
+        rescue JSON => e
+          raise(ArgumentError,
+            "Komrade is unable to convert enqueue payload to JSON.\n" +
+            "payload=#{body}\n")
+        end
+      end
+      attempts = 0
+      while attempts < MAX_RETRY
+        begin
+          resp = nil
+          RateLimiter.limiter(req.path, 10, 1) do
+            resp = http.request(req)
+          end
+          if (Integer(resp.code) / 100) == 2
+            return JSON.parse(resp.body)
+          end
+        rescue Net::HTTPError => e
+          next
+        rescue RateLimiter::Unavailable
+          sleep(0.5)
+        ensure
+          attempts += 1
+        end
+      end
+      case req.class
+      when Net::HTTP::Delete
+        raise(Komrade::Error, "Unable to delete work from Komrade.")
+      when Net::HTTP::Put
+        raise(Komrade::Error, "Unable to send work to Komrade.")
+      when Net::HTTP::Get
+        raise(Komrade::Error, "Unable to get work from Komrade.")
+      default
+        raise(Komrade::Error, "Unable to communicate with Komrade.")
+      end
+    end
+
+    def http
+      @http ||= Net::HTTP.new(Komrade.url.host, Komrade.url.port).tap do |h|
+        if Komrade.url.scheme == 'https'
+          h.use_ssl = true
+          h.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+      end
+    end
+
+  end
+end

data/lib/komrade/queue.rb

@@ -0,0 +1,25 @@
+require 'securerandom'
+require 'komrade'
+require 'komrade/http_helpers'
+
+module Komrade
+  module Queue
+    extend self
+    extend HttpHelpers
+
+    def enqueue(method, *args)
+      SecureRandom.uuid.tap do |id|
+        put("/jobs/#{id}", method: method, args: args)
+      end
+    end
+
+    def dequeue(opts={})
+      limit = opts[:limit] || 1
+      get("/jobs?limit=#{limit}")
+    end
+
+    def remove(id)
+      delete("/jobs/#{id}")
+    end
+  end
+end

data/lib/komrade/rate_limiter.rb

@@ -0,0 +1,55 @@
+module Komrade
+  module RateLimiter
+    extend self
+
+    Unavailable = Class.new(Komrade::Error)
+
+    def limits
+      @limits ||= {counts: Hash.new(0), timestamps: Hash.new(0)}
+    end
+
+    def breaks
+      @breaks ||= {counts: Hash.new(0), timestamps: Hash.new(0)}
+    end
+
+    def stamp(data, attr, bucket)
+      timestamp = Time.now.to_i / bucket
+      data[:counts][attr] = 0 unless data[:timestamps][attr] == timestamp
+      timestamp
+    end
+
+    def increment(data, attr, timestamp)
+      data[:timestamps][attr] = timestamp
+      data[:counts][attr] += 1
+    end
+
+    def check(data, attr, value, &blk)
+      if value == 0 || data[:counts][attr] < value
+        yield
+      else
+        raise(Unavailable, attr)
+      end
+    end
+
+    def limiter(attr, value, bucket, &blk)
+      timestamp = stamp(limits, attr, bucket)
+      increment(limits, attr, timestamp)
+      check(limits, attr, value) do
+        yield
+      end
+    end
+
+    def breaker(attr, value, bucket, &blk)
+      timestamp = stamp(breaks, attr, bucket)
+      check(breaks, attr, value) do
+        begin
+          yield
+        rescue => e
+          increment(breaks, attr, timestamp)
+          raise
+        end
+      end
+    end
+
+  end
+end

data/lib/komrade/tasks.rb

@@ -0,0 +1,18 @@
+require 'komrade/worker'
+
+task :environment
+
+namespace :komrade do
+  desc "Start a new worker."
+  task :work  => :environment do
+    trap('INT') {exit}
+    trap('TERM') {@worker.stop}
+    @worker = Komrade::Worker.new
+    @worker.start
+  end
+
+  desc "Returns the number of jobs in the (default or QUEUE) queue"
+  task :count => :environment do
+    $stdout.puts(Komrade::Worker.new.queue.count)
+  end
+end

data/lib/komrade/worker.rb

@@ -0,0 +1,63 @@
+require 'komrade/queue'
+
+module Komrade
+  class Worker
+
+    def initialize(args={})
+      @running = true
+    end
+
+    # Start a loop and work jobs indefinitely.
+    # Call this method to start the worker.
+    # This is the easiest way to start working jobs.
+    def start
+      work while @running
+    end
+
+    # Call this method to stop the worker.
+    # The worker may not stop immediately if the worker
+    # is sleeping.
+    def stop
+      @running = false
+    end
+
+    # This method will lock a job & evaluate the code defined by the job.
+    # Also, this method will make the best attempt to delete the job
+    # from the queue before returning.
+    def work
+      jobs = Queue.dequeue
+      until jobs.empty?
+        job = jobs.pop
+        begin
+          call(job["payload"])
+        rescue => e
+          handle_failure(job, e)
+        ensure
+          Queue.remove(job["id"])
+          log(:at => "remove-job", :job => job["id"])
+        end
+      end
+    end
+
+    # Each job includes a method column. We will use ruby's eval
+    # to grab the ruby object from memory. We send the method to
+    # the object and pass the args.
+    def call(payload)
+      args = payload["args"]
+      klass = eval(payload["method"].split(".").first)
+      message = payload["method"].split(".").last
+      klass.send(message, *args)
+    end
+
+    # This method will be called when an exception
+    # is raised during the execution of the job.
+    def handle_failure(job,e)
+      log(:at => "handle_failure")
+    end
+
+    def log(data)
+      Komrade.log(data)
+    end
+
+  end
+end

data/readme.md

@@ -0,0 +1,61 @@
+# Komrade
+
+A client library for the komrade worker queue.
+
+## Setup
+
+```bash
+$ heroku addons:add komrade:basic
+$ gem install komrade-client
+```
+
+## Usage
+
+1. Install Gem
+2. Enqueue
+3. Dequeue
+
+### Install
+
+Gemfile
+
+```ruby
+source :rubygems
+gem 'komrade-client', '1.0.0'
+```
+
+### Enqueue
+
+Example Model
+
+```ruby
+class User < ActiveRecord::Base
+  after_create :enqueue_welcome_email
+
+  def self.send_welcome_email(id)
+    if u = find(id)
+      Mailer.welcome(u).deliver
+    end
+  end
+
+  def enqueue_welcome_email
+    Komrade.enqueue("User.send_welcome_email", self.id)
+  end
+end
+```
+
+### Dequeue
+
+Rakefile
+
+```ruby
+require 'komrade'
+require 'komrade/tasks'
+```
+
+Procfile
+
+```
+web: bundle exec rails s
+worker: bundle exec rake komrade:work
+```

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: komrade-client
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Smith (♠ ace hacker)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-26 00:00:00.000000000 Z
+dependencies: []
+description: A client library for the komrad worker queue.
+email: komrade@32k.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/komrade/http_helpers.rb
+- lib/komrade/queue.rb
+- lib/komrade/rate_limiter.rb
+- lib/komrade/tasks.rb
+- lib/komrade/worker.rb
+- lib/komrade.rb
+- readme.md
+homepage: http://github.com/ryandotsmith/komrade-client
+licenses:
+- MIT
+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.23
+signing_key: 
+specification_version: 3
+summary: Queues are tough. Let Komrade work for you.
+test_files: []