run_once 1.0

data/CHANGELOG

@@ -0,0 +1 @@
+v1.0. First version

data/Manifest

@@ -0,0 +1,6 @@
+CHANGELOG
+Manifest
+README
+Rakefile
+lib/run_once.rb
+test/test_all.rb

data/README

@@ -0,0 +1,47 @@
+
+run_once 
+---------
+
+This gem lets a code block run only once every N seconds.
+
+For example:
+
+  > loop { RunOnce.in(3) { puts Time.now } }
+  2011-07-31 10:29:02 +1000
+  2011-07-31 10:29:05 +1000
+  2011-07-31 10:29:08 +1000
+  ...
+
+
+Usage
+-----
+
+First, gem install 'run_once'.  RunOnce uses a text file to keep track of
+the state and puts it in /tmp by default.  The file is locked during update
+so you can safely use it from multiple threads.
+
+  require 'run_once'
+  
+  RunOnce.use_file = 'run_once.db'
+  # or
+  RunOnce.use_path = '/tmp/'
+
+
+Caller Context
+--------------
+
+RunOnce looks at the ruby stack to know where its being called from, so you
+can use it in different places in the same program.
+
+Sometimes you may set the context manually using with_context().  You can
+re-use the same context in different places in your program, for example to
+make sure warning emails of any kind are only sent once every 2 minutes, eg:
+
+  RunOnce.with_context('email alert').in(120) { EmailAlert.deliver ... }
+
+
+Contact the author
+------------------
+
+Andrew Snow <andrew@modulus.org>
+Andys^ on irc.freenode.net

data/Rakefile

@@ -0,0 +1,7 @@
+require 'echoe'
+Echoe.new('run_once') do |g|
+ g.summary = "Ruby Gem to limit rate of code execution to every N seconds"
+ g.author = 'Andrew Snow'
+ g.email = 'andrew@modulus.org'
+ g.url = "https://github.com/andys/run_once" 
+end

data/lib/run_once.rb

@@ -0,0 +1,82 @@
+
+class RunOnce
+  class << self
+    attr_accessor :db_file
+    
+    def use_path=(path)
+      self.use_file = path + "/#{self}.db.#{$$}"
+    end
+    
+    def use_file=(file)
+      self.db_file = file
+      File.open(@db_file, 'a+') { }
+    end
+    
+    def get_a_context
+      self.new(caller[1])
+    end
+    
+    def with_context(context)
+      new(context)
+    end
+    
+    def in(seconds, &bl)
+      get_a_context.in(seconds, &bl)
+    end
+    
+    def update_db(key, val)
+      formatted_val = '%015.3f' % val.to_f
+      File.open(@db_file, 'w+') do |io|
+        io.flock(File::LOCK_EX)
+        io.rewind
+        io.puts key if !search_db(io,key)
+        io.puts formatted_val
+      end
+    end
+    
+    def lookup_db(key)
+      retval = nil
+      File.open(@db_file, 'r') do |io|
+        io.flock(File::LOCK_SH)
+        retval = io.readline.strip if search_db(io,key)
+      end
+      retval
+    end
+    
+    protected
+    def search_db(io, key)
+      retval = nil
+      keywithnewline = "#{key}\n"
+      while(retval.nil? && line = io.gets)
+        if(line == keywithnewline)
+          retval = true 
+        else
+          io.gets  # skip over the next value
+        end
+      end
+      retval
+    end
+  end
+  
+  @db_file = "/tmp/#{self}.db.#{$$}"
+  
+  def initialize(context)
+    @context = context
+  end
+  
+  def in(seconds)
+    if(!last_happened || last_happened && (Time.now.to_f > (last_happened + seconds.to_f)))
+      update_last_happened
+      yield
+    end
+  end
+  
+  def last_happened
+    @last_happened ||= (self.class.lookup_db(@context).to_f rescue nil)
+  end
+  
+  def update_last_happened
+    self.class.update_db(@context, Time.now.to_f)
+  end
+  
+end

data/run_once.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{run_once}
+  s.version = "1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Andrew Snow"]
+  s.date = %q{2011-07-31}
+  s.description = %q{Ruby Gem to limit rate of code execution to every N seconds}
+  s.email = %q{andrew@modulus.org}
+  s.extra_rdoc_files = ["CHANGELOG", "README", "lib/run_once.rb"]
+  s.files = ["CHANGELOG", "Manifest", "README", "Rakefile", "lib/run_once.rb", "test/test_all.rb", "run_once.gemspec"]
+  s.homepage = %q{https://github.com/andys/run_once}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Run_once", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{run_once}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Ruby Gem to limit rate of code execution to every N seconds}
+  s.test_files = ["test/test_all.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/test_all.rb

@@ -0,0 +1,67 @@
+
+require 'test/unit'
+require "./#{File.dirname(__FILE__)}/../lib/run_once.rb"
+
+class TestRunOnce < Test::Unit::TestCase
+  class TestException < Exception ; end
+
+  def setup
+    @fn = './run_once.db'
+    File.unlink @fn rescue nil
+    RunOnce.use_file = @fn
+  end
+  
+  def teardown
+    File.unlink @fn rescue nil
+  end
+  
+  def test_db_file
+    assert File.exists?(@fn)
+  end
+  
+  def test_db_ops
+    assert_equal nil, RunOnce.lookup_db('A')
+    RunOnce.update_db('A', 1.1)
+    assert_equal 1.1, RunOnce.lookup_db('A').to_f
+    RunOnce.update_db('A', 2.2)
+    assert_equal 2.2, RunOnce.lookup_db('A').to_f
+  end
+  
+  def test_manual_context
+    assert_raises TestException do
+      RunOnce.with_context('test').in(0.5) { raise TestException.new }
+    end
+    3.times do
+      assert_nothing_raised TestException do
+        RunOnce.with_context('test').in(0.5) { raise TestException.new }
+      end
+      sleep 0.1
+    end
+    sleep 0.3
+    assert_raises TestException do
+      RunOnce.with_context('test').in(0.5) { raise TestException.new }
+    end
+  end
+
+  def test_auto_context
+    block = lambda do 
+      RunOnce.in(0.5) { raise TestException.new }
+    end
+    assert_raises TestException, &block
+    3.times do
+      assert_nothing_raised TestException, &block
+      sleep 0.1
+    end
+    sleep 0.3
+    assert_raises TestException, &block
+  end
+  
+  def test_1_sec
+    stop_time = Time.now + 0.95
+    counter = 0
+    while(stop_time > Time.now)
+      RunOnce.in(0.1) { counter += 1 }
+    end
+    assert_equal 10, counter
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: run_once
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  version: "1.0"
+platform: ruby
+authors: 
+- Andrew Snow
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-31 00:00:00 +10:00
+default_executable: 
+dependencies: []
+
+description: Ruby Gem to limit rate of code execution to every N seconds
+email: andrew@modulus.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- README
+- lib/run_once.rb
+files: 
+- CHANGELOG
+- Manifest
+- README
+- Rakefile
+- lib/run_once.rb
+- test/test_all.rb
+- run_once.gemspec
+has_rdoc: true
+homepage: https://github.com/andys/run_once
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Run_once
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: run_once
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby Gem to limit rate of code execution to every N seconds
+test_files: 
+- test/test_all.rb