lark 0.0.1 → 0.0.2

data/README.markdown

@@ -3,20 +3,22 @@
 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|
+    Lark.on_expired 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.configure :domain => "staging", :expire => 60
+
+    EM.run do
+      lark = Lark::Base.new "bottom_node.1", "group3", "ip" => "127.0.0.1", "role" => "worker node"
+
+      EM::PeriodicTimer.new(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
+        Lark.get(:group3).each do |n|
+          check_on_node(n)
+        end
       end
     end

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/lark.rb

@@ -2,11 +2,27 @@ require 'redis'
 
 class LarkDBOffline < Exception ; end
 
-class Lark
-  attr_accessor :id
+module Lark
+#  attr_accessor :id
 
-  def self.urls
-    if ENV['LARK_URLS']
+  extend self;
+
+  def configure(options)
+    @domain = options[:domain]
+    @expire = options[:expire]
+    @urls   = options[:urls]
+  end
+
+  def domain
+    @domain.to_s
+  end
+
+  def urls
+    if @urls
+      @urls
+    elsif @url
+      [ @url ]
+    elsif ENV['LARK_URLS']
       ENV['LARK_URLS'].split(",")
     elsif ENV['LARK_URL']
       [ ENV['LARK_URL'] ]
@@ -15,20 +31,24 @@ class Lark
     end
   end
 
-  def self.dbs
+  def dbs
     @dbs ||= urls.map do |url|
       puts "Connecting to #{url}";
       Redis.connect(:url => url)
     end
   end
 
+  def index(group)
+    "#{domain}:#{group}:idx"
+  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)
+  def pool(&blk)
     dbs.push dbs.shift
 
     num_errors = 0
@@ -48,95 +68,100 @@ class Lark
     results
   end
 
-  def self.on_expired(&blk)
+  def on_expired(&blk)
     @expired = blk;
   end
 
-  def self.expired
-    @expired
+  def index_search(group)
+    pool { |db| db.smembers(index(group)) }.flatten.uniq.sort
   end
 
-  def initialize(_id, options = {})
-    @id = _id
-    @options = options
-    @domain = options[:domain]
-    @expire = options[:expire]
+  def key(id, group)
+    "#{domain}:#{group}:key:#{id}"
   end
 
-  def load_data
-    ## try each db - return when one works without an error
-    ## throw an error if all are down
+  def destroy(id, group)
     pool do |db|
-      data = db.hgetall(key)
-      return data if not data.empty?
+      db.multi do
+        db.del key(id, group)
+        db.srem index(group), id
+      end
     end
-    {}
+    @expired.call(id, group) if @expired
   end
 
-  def key
-    "#{@domain}:#{@id}"
+  def clean(group)
+    index_search(group).reject { |i| load_data(i, group) }.each { |i| destroy(i, group) } 
   end
 
-  def set_key
-    "#{@domain}:lark:all"
+  def get_all(group)
+    index_search(group).map { |i| load_data(i, group) }
   end
 
-  def set(new_data)
-    data.merge!(new_data)
-    save_data
+  def load_data(id, group)
+    key = key(id, group)
+    ## 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
+    nil
   end
 
-  def save_data
-    data[:created_on] ||= Time.new.to_i
-    data[:domain] ||= @domain
-    data[:updated_on] = Time.new.to_i
+  def save_data(id, group, data)
+    key = key(id,group)
+
     pool do |db|
       db.multi do
         db.hmset *[ key, data.to_a ].flatten
         db.expire key, @expire if @expire
-        db.sadd set_key, @id
+        db.sadd index(group), id
       end
     end
   end
 
-  def data
-    @data ||= load_data
+  def get(group)
+    get_all(group).select { |i| i }
   end
 
-  def destroy
-    pool do |db|
-      db.multi do
-        db.del key
-        db.srem set_key, id
-      end
+  class Base
+    attr_accessor :id, :group
+
+    def initialize(_id, _group, _data = nil)
+      @id      = _id
+      @group   = _group
+      @data    = _data
+      save_data if @data
     end
-    self.class.expired.call(id, @domain);
-  end
 
-  def all_ids
-    pool { |db| db.smembers(set_key) }.flatten.uniq.sort
-  end
+    def key
+      Lark.key(id, group)
+    end
 
-  def find_ids(match)
-    all_ids.select { |_id| match.match(_id) }
-  end
+    def set(new_data)
+      data.merge!(new_data)
+      save_data
+    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 save_data
+      data[:created_on] ||= Time.new.to_i
+      data[:updated_on] = Time.new.to_i
+      data[:id] = id
+      Lark.save_data(id, group, data)
+    end
 
-  def find(match = //)
-    result = {}
-    find_valid(match).each { |v| result[v.id] = v.data }
-    result
-  end
+    def data
+      @data ||= (Lark.load_data(key) || {})
+    end
 
-  def pool(&blk)
-    self.class.pool(&blk)
-  end
+    def destroy
+      Lark.destroy(id, group)
+    end
 
+    def pool(&blk)
+      self.class.pool(&blk)
+    end
+
+  end
 end

data/spec/lark_spec.rb

@@ -2,26 +2,27 @@
 require File.dirname(__FILE__) + "/init.rb"
 
 describe 'Lark' do
+
       before do
-        @lark = Lark.new "lark", :domain => "domain"
-        @db1 = mock()
-        @db2 = mock()
+        @group = :testgroup
+        @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({})
+        @db1.expects(:smembers).returns([ "test123" ])
+        @db1.expects(:hgetall).with(":#{@group}:key:test123").returns({})
         @db2.expects(:smembers).returns([ ])
-        @db2.expects(:hgetall).with("domain:key1").returns({"foo" => "bar"})
+        @db2.expects(:hgetall).with(":#{@group}:key:test123").returns({"foo" => "bar"})
 
-        @lark.find.should.equal({ "key1" => {"foo" => "bar"} })
+        Lark.get(@group).should.equal([ {"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"]
+        Lark.index_search(@group).should.equal ["a","b","c"]
       end
 
       # it 'should run delete on old objects'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: lark
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Orion Henry