Shared Juno store Implement your own key value server in 50 lines!

shared.rb

require 'drb'                                                                                                                               
                                                                                                                                            
module Juno                                                                                                                                 
  class Shared < Base                                                                                                                       
    def initialize(options = {}, &block)                                                                                                    
      options[:port] ||= 9000                                                                                                               
      @uri = options[:uri] || (options[:socket] ? "drbunix://#{options[:socket]}" :                                                         
                               "druby://#{options[:host]}:#{options[:port]}")                                                               
      @builder = Builder.new(&block)                                                                                                        
    end                                                                                                                                     
                                                                                                                                            
    def key?(key, options = {})                                                                                                             
      with_adapter {|a| a.key?(key, options) }                                                                                              
    end                                                                                                                                     
                                                                                                                                            
    def load(key, options = {})                                                                                                             
      with_adapter {|a| a.load(key, options) }                                                                                              
    end                                                                                                                                     
                                                                                                                                            
    def store(key, value, options = {})                                                                                                     
      with_adapter {|a| a.store(key, value, options) }                                                                                      
    end                                                                                                                                     
                                                                                                                                            
    def delete(key, options = {})                                                                                                           
      with_adapter {|a| a.delete(key, options) }                                                                                            
    end                                                                                                                                     
                                                                                                                                            
    def clear(options = {})                                                                                                                 
      with_adapter {|a| a.clear(options) }                                                                                                  
      self                                                                                                                                  
    end                                                                                                                                     
                                                                                                                                            
    def close                                                                                                                               
      if @server                                                                                                                            
        @adapter.close                                                                                                                      
        @server.stop_service                                                                                                                
        @server = nil                                                                                                                       
      end                                                                                                                                   
      @adapter = nil                                                                                                                        
    end                                                                                                                                     
                                                                                                                                            
    private                                                                                                                                 
                                                                                                                                            
    def with_adapter                                                                                                                        
      yield(@adapter ||= DRb::DRbObject.new(nil, @uri))                                                                                     
    rescue DRb::DRbConnError                                                                                                                
      @adapter = Lock.new(@builder.build.last)                                                                                              
      @server = DRb::DRbServer.new(@uri, @adapter)                                                                                          
      retry                                                                                                                                 
    end                                                                                                                                     
  end                                                                                                                                       
end