lark 0.0.1

data/README.markdown

@@ -0,0 +1,22 @@
+# Lark
+
+Lark is a simple system to store local cache in a cluster of redis servers, be
+able to query state about other lark nodes, and notice when one goes offline.
+
+    Lark.on_expire do |id|
+      Log.debug "Lost node #{id}"
+    end
+
+    EM.start do
+      lark = Lark.new "bottom_node.1", :expire => 60
+      lark.set "ip" => "127.0.0.1", "role" => "worker node"
+      EM::PeriodicTimer(5) do
+        lark.set "load" => get_load, "mem_usage" => get_mem_usage
+      end
+
+      on_some_event do
+        lark.find(/^top_node/).each do |id, data|
+          check_on_node(id, data)
+        do
+      end
+    end

data/Rakefile

@@ -0,0 +1,23 @@
+require 'jeweler'
+
+Jeweler::Tasks.new do |s|
+	s.name = "lark"
+	s.description = "A system for nodes to communicate state and presence through a redis cluster"
+	s.summary = s.description
+	s.author = "Orion Henry"
+	s.email = "orion@heroku.com"
+	s.homepage = "http://github.com/orionz/lark"
+	s.rubyforge_project = "lark"
+	s.files = FileList["[A-Z]*", "{lib,spec}/**/*"]
+	s.add_dependency "redis",  [">= 2.0.5"]
+end
+
+Jeweler::RubyforgeTasks.new
+
+desc 'Run specs'
+task :spec do
+	sh 'bacon -s spec/*_spec.rb'
+end
+
+task :default => :spec
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/lark.rb

@@ -0,0 +1,142 @@
+require 'redis'
+
+class LarkDBOffline < Exception ; end
+
+class Lark
+  attr_accessor :id
+
+  def self.urls
+    if ENV['LARK_URLS']
+      ENV['LARK_URLS'].split(",")
+    elsif ENV['LARK_URL']
+      [ ENV['LARK_URL'] ]
+    else
+      [ "redis://127.0.0.1:6379/0" ]
+    end
+  end
+
+  def self.dbs
+    @dbs ||= urls.map do |url|
+      puts "Connecting to #{url}";
+      Redis.connect(:url => url)
+    end
+  end
+
+  ## all the black magic happens here
+  ## pool runs the block against all the db's
+  ## throws an error if non of them are online
+  ## and returns an array of the block results
+  ## from the ones who are online
+
+  def self.pool(&blk)
+    dbs.push dbs.shift
+
+    num_errors = 0
+    results = []
+    begin
+      dbs.each do |db|
+        begin
+          results << blk.call(db)
+        rescue Errno::ECONNREFUSED, Timeout::Error => e
+          puts "#{e.class}: #{e.message}"
+          num_errors += 1
+        end
+      end
+    ensure
+      raise LarkDBOffline if num_errors == dbs.size
+    end
+    results
+  end
+
+  def self.on_expired(&blk)
+    @expired = blk;
+  end
+
+  def self.expired
+    @expired
+  end
+
+  def initialize(_id, options = {})
+    @id = _id
+    @options = options
+    @domain = options[:domain]
+    @expire = options[:expire]
+  end
+
+  def load_data
+    ## try each db - return when one works without an error
+    ## throw an error if all are down
+    pool do |db|
+      data = db.hgetall(key)
+      return data if not data.empty?
+    end
+    {}
+  end
+
+  def key
+    "#{@domain}:#{@id}"
+  end
+
+  def set_key
+    "#{@domain}:lark:all"
+  end
+
+  def set(new_data)
+    data.merge!(new_data)
+    save_data
+  end
+
+  def save_data
+    data[:created_on] ||= Time.new.to_i
+    data[:domain] ||= @domain
+    data[:updated_on] = Time.new.to_i
+    pool do |db|
+      db.multi do
+        db.hmset *[ key, data.to_a ].flatten
+        db.expire key, @expire if @expire
+        db.sadd set_key, @id
+      end
+    end
+  end
+
+  def data
+    @data ||= load_data
+  end
+
+  def destroy
+    pool do |db|
+      db.multi do
+        db.del key
+        db.srem set_key, id
+      end
+    end
+    self.class.expired.call(id, @domain);
+  end
+
+  def all_ids
+    pool { |db| db.smembers(set_key) }.flatten.uniq.sort
+  end
+
+  def find_ids(match)
+    all_ids.select { |_id| match.match(_id) }
+  end
+
+  def find_valid(match)
+    all = find_ids(match).map { |_id| Lark.new(_id, @options) }
+    valid = all.reject { |l| l.data.empty? }
+    invalid = all - valid
+    invalid.each { |i| i.destroy }
+    valid
+  end
+
+  def find(match = //)
+    result = {}
+    find_valid(match).each { |v| result[v.id] = v.data }
+    result
+  end
+
+  def pool(&blk)
+    self.class.pool(&blk)
+  end
+
+end

data/spec/init.rb

@@ -0,0 +1,17 @@
+
+require File.dirname(__FILE__) + "/../lib/lark"
+require "bacon"
+require "mocha/api"
+require "mocha/object"
+
+class Bacon::Context
+  include Mocha::API
+  alias_method :old_it,:it
+  def it description,&block
+    mocha_setup
+    old_it(description,&block)
+    mocha_verify
+    mocha_teardown
+  end
+end
+

data/spec/lark_spec.rb

@@ -0,0 +1,31 @@
+
+require File.dirname(__FILE__) + "/init.rb"
+
+describe 'Lark' do
+      before do
+        @lark = Lark.new "lark", :domain => "domain"
+        @db1 = mock()
+        @db2 = mock()
+        Lark.stubs(:dbs).returns([@db1, @db2]);
+      end
+
+      it 'should locate the data even if the key and data are on different databases' do
+        @db1.expects(:smembers).returns([ "key1" ])
+        @db1.expects(:hgetall).with("domain:key1").returns({})
+        @db2.expects(:smembers).returns([ ])
+        @db2.expects(:hgetall).with("domain:key1").returns({"foo" => "bar"})
+
+        @lark.find.should.equal({ "key1" => {"foo" => "bar"} })
+      end
+
+      it 'should get the union of the ids on each server' do
+        @db1.expects(:smembers).returns([ "a", "b" ])
+        @db2.expects(:smembers).returns([ "b", "c" ])
+        @lark.all_ids.should.equal ["a","b","c"]
+      end
+
+      # it 'should run delete on old objects'
+      # it 'should invoke a handler when deleting old objects'
+      # it 'should fetch data properly when one redis is offline'
+      # it 'should raise an exception if all redis are offline'
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: lark
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Orion Henry
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-21 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 0
+        - 5
+        version: 2.0.5
+  type: :runtime
+  version_requirements: *id001
+description: A system for nodes to communicate state and presence through a redis cluster
+email: orion@heroku.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- README.markdown
+- Rakefile
+- VERSION
+- lib/lark.rb
+- spec/init.rb
+- spec/lark_spec.rb
+has_rdoc: true
+homepage: http://github.com/orionz/lark
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: lark
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A system for nodes to communicate state and presence through a redis cluster
+test_files: 
+- spec/init.rb
+- spec/lark_spec.rb