sadie 0.0.52 → 0.1.6

data/lib/sadie_server.rb

@@ -0,0 +1,59 @@
+require 'sadie_session'
+
+class SadieServer
+  
+  attr_accessor :framework_dirpath
+  def initialize( params )
+    self.framework_dirpath = "/var/sadie"
+    unless params.nil?
+      if params.is_a? Hash
+        if params.has_key?( :framework_dirpath )
+          self.framework_dirpath = params[:framework_dirpath]
+        end
+      end      
+    end
+    @sadie_session = SadieSession.new( :primers_dirpath => File.join( self.framework_dirpath, 'primers' ) )
+  end
+   
+  def get( key )
+    @sadie_session.get( key )
+  end
+ 
+  def set( key, value )
+    @sadie_session.set( key, value )
+  end
+# 
+#   def query
+#   end
+# 
+#   def set_multiple
+#   end
+# 
+#   def get_multiple
+#   end
+  
+  def self.proc_args( argv_param )
+    argv = argv_param.dup
+    ARGV.clear
+    ret = nil
+    
+    unless argv.nil?
+      if argv.is_a? Array
+        unless argv.empty?
+          argv.each do |argstr|
+            puts "argstr: #{argstr}"
+            if argstr =~ /^\-\-([^\=]+)\=(.*)$/
+              ret = {} if ret.nil?
+              k,v = $1,$2
+              ret[k.gsub(/\-/,"_").to_sym] = v
+            else
+              ARGV.push argstr
+            end
+          end
+        end        
+      end
+    end
+    ret
+  end
+  
+end

data/lib/sadie_session.rb

@@ -0,0 +1,194 @@
+require 'sadie_storage_manager'
+require 'storage/memory'
+require 'primer'
+require 'thread'
+require 'rbtree'
+
+class SadieSession
+  attr_accessor :primers_dirpath
+  
+  def initialize( params )
+    
+    @expiry_mutex = Mutex.new
+    @expire_schedule = MultiRBTree.new
+    @expiry_thread = Thread.new do
+      _expiry_loop
+    end
+    
+    @refresh_mutex = Mutex.new
+    @refresh_schedule = MultiRBTree.new
+    @refresh_thread = Thread.new do
+      _refresh_loop
+    end
+    
+    @registered_key = {}
+    
+    unless params.nil?
+      if params.is_a? Hash
+        if params.has_key?( :primers_dirpath )
+          self.primers_dirpath = params[:primers_dirpath]
+          puts "initializing session with primer dirpath: #{self.primers_dirpath}"
+          _register_primers
+        end
+      end
+    end
+    
+    @storage_manager_thread_mutex = Mutex.new
+    @storage_manager = SadieStorageManager.new
+    @storage_manager_thread_mutex.synchronize do
+      @storage_manager.register_storage_mechanism :memory, SadieStorageMechanismMemory.new
+    end
+  end
+  
+  def has_key?( key )
+    @storage_manager_thread_mutex.synchronize do
+      @storage_manager.has_key?( key )
+    end
+  end
+  
+  def primer_registered?( key )
+    @registered_key.has_key? key
+  end
+  
+  def unset( key )
+    @storage_manager_thread_mutex.synchronize do
+      @storage_manager.unset( key )
+    end
+  end
+  
+  def set( keys, value, params=nil )
+    expires, mechanism = :never, :memory
+    unless params.nil?
+      if params.is_a? Hash
+        expires = params[:expire] if params.has_key?( :expire )
+        mechanism = params[:mechanism] if params.has_key?( :mechanism )
+      end
+    end
+    @storage_manager_thread_mutex.synchronize do
+      @storage_manager.set( :keys => Array( keys ),
+                            :value => value,
+                            :mechanism => mechanism )
+    end
+    _manage_expiry( keys, expires ) unless expires == :never || expires == :on_get
+  end
+  
+  def get( key )
+    if @storage_manager.has_key?( key )
+      @storage_manager.get( key )
+    elsif primer_registered?( key )
+      p = Primer.new( :session => self )
+      p.decorate( @registered_key[ key ] )
+      if p.expire == :on_get
+        ret = @storage_manager.get( key )
+        @storage_manager.unset( key )
+        ret
+      elsif ( p.refreshes? )
+        _manage_refresh( key, p.refresh_rate )
+        @storage_manager.get( key )
+      else
+        @storage_manager.get( key )
+      end
+    end
+  end
+  
+  private
+  
+  def _manage_expiry( keys, expires_seconds )
+    if ! expires_seconds.is_a?( Symbol ) && expires_seconds.to_i > 0
+      expires = expires_seconds.to_i + _current_time
+      unless Array(keys).empty?
+        Array(keys).each do |key|
+          @expiry_mutex.synchronize do
+            @expire_schedule[expires] = key
+          end
+        end
+      end
+    end
+  end
+  
+  def _manage_refresh( keys, refresh_seconds )
+    if ! refresh_seconds.is_a?( Symbol ) && refresh_seconds.to_i > 0
+      refreshes = refresh_seconds.to_i + _current_time
+      unless Array(keys).empty?
+        Array(keys).each do |key|
+          @refresh_mutex.synchronize do
+            @refresh_schedule[refreshes] = key
+          end
+        end
+      end
+    end
+  end
+  
+  def _register_primers
+    Dir.glob( File.join( self.primers_dirpath, "**", "*.rb" ) ).each do |primer_filepath|
+      p = Primer.new( :session => self )
+      p.mode = :registration
+      p.decorate( primer_filepath )
+      _register_keys p.keys, primer_filepath
+    end
+  end
+  
+  def _register_keys( keys=nil, filepath )
+    if ( ! keys.nil? ) && ( ! Array( keys ).empty? )
+      Array( keys ).each do |key|
+        @registered_key[key] = filepath
+      end
+    end
+  end
+  
+  def _expiry_loop
+    loop do
+      _expiry_pass
+      sleep 1
+    end
+  end
+  
+  def _expiry_pass
+    time_now_in_seconds = _current_time
+    @expiry_mutex.synchronize do
+      loop do
+        break if @expire_schedule.empty?
+        ts,key = @expire_schedule.shift
+        if ts < time_now_in_seconds
+          unset key
+        else
+          @expire_schedule[ts] = key
+          break
+        end
+      end
+    end    
+  end
+  
+  def _refresh_loop
+    loop do
+      _refresh_pass
+      sleep 1
+    end
+  end
+  
+  def _refresh_pass
+    time_now_in_seconds = _current_time
+      loop do
+        break if @refresh_schedule.empty?
+        ts,key = @refresh_schedule.shift
+        if ts < time_now_in_seconds
+          _refresh key
+        else
+          @refresh_mutex.synchronize do
+            @refresh_schedule[ts] = key
+          end
+          break
+        end
+      end
+  end
+  
+  def _refresh( key )
+    p = Primer.new( :session => self )
+    p.decorate( @registered_key[ key ] )
+    _manage_refresh( key, p.refresh_rate )
+  end
+  
+  def _current_time
+    Time.now.to_i
+  end
+end

data/lib/sadie_storage_manager.rb

@@ -0,0 +1,60 @@
+class SadieStorageManager
+  
+  def initialize
+    @mechanisms = {}
+    @known_keys = {}
+  end
+  
+  def register_storage_mechanism( handle, mechanism )
+    @mechanisms[handle] = mechanism
+  end
+  
+  def mechanism_is_registered?( mechanism_handle )
+    
+    @mechanisms.has_key?( mechanism_handle )
+    
+  end
+  
+  def has_key?( key )
+    @known_keys.has_key?( key )
+  end
+  
+  def get( key )
+    @mechanisms[@known_keys[key]].get( key ) if has_key?( key )
+  end
+  
+  def unset( key )
+    if has_key?( key )
+      @mechanisms[@known_keys[key]].unset( key )
+      @known_keys.delete key
+    end
+  end
+  
+  def set( params )
+    unless params.nil?
+      
+      if params.is_a? Hash
+        
+        if params.has_key?( :mechanism )
+          
+          if mechanism_is_registered? params[:mechanism]
+            
+            if params.has_key?( :keys ) && params[:keys].is_a?( Array ) &&
+               params.has_key?( :value )
+            
+              params[:keys].each do |key|
+                @mechanisms[params[:mechanism]].set( key, params[:value] )
+                @known_keys[key] = params[:mechanism]
+              end
+            end
+            
+          end
+          
+        end
+        
+      end
+      
+    end
+  end
+  
+end

data/lib/sadie_storage_mechanism.rb

@@ -0,0 +1,18 @@
+class SadieStorageMechanism
+  
+  def initialize
+  end
+  
+  def set( key, value )
+    false
+  end
+  
+  def get( key )
+    nil
+  end
+  
+  def unset( key )
+    nil
+  end
+  
+end

data/lib/storage/memory.rb

@@ -0,0 +1,24 @@
+require 'sadie_storage_mechanism'
+class SadieStorageMechanismMemory < SadieStorageMechanism
+  
+  def initialize
+    @storage_hash = {}
+  end
+  
+  def set( key, value )
+    @storage_hash[key] = value
+  end
+  
+  def get( key )
+    @storage_hash[key] if @storage_hash.has_key?( key )
+  end
+  
+  def unset( key )
+    @storage_hash.delete key
+  end
+  
+  def has_key?( key )
+    @storage_hash.has_key?( key )
+  end
+  
+end

data/sadie.gemspec

@@ -23,8 +23,12 @@ Gem::Specification.new do |s|
   # s.add_runtime_dependency "rest-client"
 
   #s.add_runtime_dependency "ini"
-  s.add_runtime_dependency "dbi"
+  #s.add_runtime_dependency "dbi"
   #s.add_runtime_dependency "mysql2"
-  s.add_runtime_dependency "dbd-mysql"
+  #s.add_runtime_dependency "dbd-mysql"
+  s.add_runtime_dependency "sinatra", "~> 1.4.4"
+  s.add_runtime_dependency "rbtree", "~> 0.4.2"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rack-test"
   s.extra_rdoc_files = ['README', 'CHANGELOG', 'TODO']
 end

data/spec/primer.rb

@@ -0,0 +1,167 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'primer'
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+# require 'sadie_storage_manager'
+# require 'storage_mechanisms/memory'
+require 'sadie_session'
+require 'pp'
+
+describe Primer do
+  
+  it "should default to the memory storage mechanism" do
+    p = Primer.new
+    p.storage_mechanism.should == :memory
+  end
+  
+  it  "should be able to successfully set using a storage manager" do
+    session = SadieSession.new( :primers_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation','primers' ))
+    p = Primer.new( :session => session )
+    p.prime [ "simple.test"] do
+      p.assign [ "simple.test" ] do
+        p.set( "simple.value" )
+      end
+    end
+    session.get( "simple.test" ).should == "simple.value"
+  end
+  
+  it "should not allow assignment for keys not mentioned in the prime directive" do
+    expect {
+      session = SadieSession.new( :primers_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation','primers' ))
+#       storage = SadieStorageManager.new
+#       mech = SadieStorageMechanismMemory.new
+#       storage.register_storage_mechanism :memory, mech
+      p = Primer.new( :session => session )
+      p.prime [ "simple.test"] do
+        p.assign [ "simple.other" ]
+      end
+    }.to raise_error
+    
+  end
+  
+  it "should not allow set for keys not mentioned in the assign directive" do
+    expect {
+      session = SadieSession.new( :primers_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation','primers' ))
+      p = Primer.new( :session => session )
+      p.prime [ "simple.test"] do
+        p.assign [ "simple.test" ] do
+          p.set ["simple.other"], "someval"
+        end
+      end
+    }.to raise_error
+  end
+  
+  it "should be ok to use strings instead of arrays for prime" do
+    session = SadieSession.new( :primers_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation','primers' ))
+    p = Primer.new( :session => session )
+    p.prime "simple.test" do
+      p.assign [ "simple.test" ] do
+        p.set "someval"
+      end
+    end
+    session.get("simple.test").should == "someval"
+  end
+  
+  it "should be ok to use strings instead of arrays for assign" do
+    session = SadieSession.new( :primers_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation','primers' ))
+    p = Primer.new( :session => session )
+    p.prime ["simple.test"] do
+      p.assign "simple.test" do
+        p.set "someval"
+      end
+    end
+    session.get("simple.test").should == "someval"
+  end
+  
+  it "should be ok to use strings instead of arrays for set" do
+    session = SadieSession.new( :primers_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation','primers' ))
+    p = Primer.new( :session => session )
+    p.prime ["simple.test"] do
+      p.assign "simple.test" do
+        p.set "simple.test","someval"
+      end
+    end
+    session.get("simple.test").should == "someval"
+  end
+  
+  it "should successfully load a primer file using decorate method" do
+    session = SadieSession.new( :primers_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation','primers' ))
+    p = Primer.new( :session => session )
+    p.decorate( File.join(File.dirname(__FILE__), '..', 'test', 'v2', 'test_installation', 'primers', 'minimal.rb') )
+    session.get( "minimal.primer" ).should == "testval"
+  end
+  
+  it "should successfully execute before each clauses" do
+    
+    session = SadieSession.new( :primers_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation','primers' ))
+    p = Primer.new( :session => session )
+    def p.get_r
+      @r
+    end
+    p.decorate( File.join(File.dirname(__FILE__), '..', 'test', 'v2', 'test_installation', 'primers', 'test_before_each.rb') )
+    session.get( "test.var1" ).should == "val1"
+    session.get( "test.var2" ).should == "val2"
+    r= p.get_r
+    r.has_key?("test.var1").should be_true
+    r.has_key?("test.var2").should be_true
+    r["test.var1"].should == 1
+    r["test.var2"].should == 1
+  end
+  
+  it "should successfully execute before key clauses" do
+    
+    session = SadieSession.new( :primers_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation','primers' ))
+    p = Primer.new( :session => session )
+    def p.get_r
+      @r
+    end
+    p.decorate( File.join(File.dirname(__FILE__), '..', 'test', 'v2', 'test_installation', 'primers', 'test_before_key.rb') )
+    session.get( "test.var1" ).should == "val1"
+    session.get( "test.var2" ).should == "val2"
+    r= p.get_r
+    r.has_key?("test.var1").should be_true
+    r.has_key?("test.var2").should be_false
+    r["test.var1"].should == 1
+  end
+  
+  it "should successfully execute after each clauses" do
+    
+    session = SadieSession.new( :primers_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation','primers' ))
+    p = Primer.new( :session => session )
+    def p.get_r
+      @r
+    end
+    p.decorate( File.join(File.dirname(__FILE__), '..', 'test', 'v2', 'test_installation', 'primers', 'test_after_each.rb') )
+    session.get( "test.var1" ).should == "val1"
+    session.get( "test.var2" ).should == "val2"
+    r= p.get_r
+    r.has_key?("test.var1").should be_true
+    r.has_key?("test.var2").should be_true
+    r["test.var1"].should == "val1"
+    r["test.var2"].should == "val2"
+  end
+  
+  it "should successfully execute after key clauses" do
+    
+    session = SadieSession.new( :primers_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation','primers' ))
+    p = Primer.new( :session => session )
+    def p.get_r
+      @r
+    end
+    p.decorate( File.join(File.dirname(__FILE__), '..', 'test', 'v2', 'test_installation', 'primers', 'test_after_key.rb') )
+    session.get( "test.var1" ).should == "val1"
+    session.get( "test.var2" ).should == "val2"
+    r= p.get_r
+    r.has_key?("test.var1").should be_true
+    r.has_key?("test.var2").should be_false
+    r["test.var1"].should == "val1"
+  end
+  
+  it "should set the refresh rate" do
+    session = SadieSession.new( :primers_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation','primers' ))
+    p = Primer.new( :session => session )
+    p.decorate( File.join(File.dirname(__FILE__), '..', 'test', 'v2', 'test_installation', 'primers', 'test_refresh.rb') )
+    p.refresh_rate.should == 2
+  end
+  
+end

data/spec/sadie_server.rb

@@ -0,0 +1,39 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+$:.unshift File.join(File.dirname(__FILE__), '..')
+
+require 'sadie_server'
+
+class SadieServer
+  def self.proc_args( argv )
+    { :framework_dirpath => File.join( File.dirname( __FILE__ ), '..','test','v2','test_installation' ) }
+  end
+end
+
+require 'bin/sadie_server'
+require 'rack/test'
+
+describe 'the sadie server app' do
+  
+  include Rack::Test::Methods
+  
+  def app
+    Sinatra::Application
+  end
+  
+  it "returns the correct value" do
+    get '/minimal.primer'
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq('testval')
+  end
+  
+  it "updates via post" do
+    fields = {
+      :value => 'testval99'
+    }
+    post '/set.via.post', fields
+    expect(last_response).to be_ok
+    get '/set.via.post'
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq('testval99')
+  end
+end

data/spec/sadie_server_lib.rb

@@ -0,0 +1,31 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'sadie_server'
+require 'pp'
+describe SadieServer do
+  
+  describe '#proc_args' do
+    
+    it "should accept a framework-dirpath arg" do
+      
+      result = SadieServer::proc_args ["--framework-dirpath=/tmp/sadietest"]
+      result.should_not be_nil
+      result.is_a?( Hash ).should be_true
+      result.has_key?( :framework_dirpath ).should be_true
+      result[:framework_dirpath].should == '/tmp/sadietest'
+      
+    end
+    
+  end
+  
+  describe "#initialize" do
+    
+    it "should store the framework dirpath" do
+      
+      serv = SadieServer.new( SadieServer::proc_args( ["--framework-dirpath=/tmp/sadietest"] ) )
+      serv.framework_dirpath.should == '/tmp/sadietest'
+      
+    end
+    
+  end
+  
+end