singleton_process 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in singleton_process.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Robert Jackson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+# SingletonProcess
+
+Ensure that a given process is only running once. Helpful for ensure that scheduled tasks do not overlap if they run longer than the scheduled interval.
+
+Prior attempts simply used a pid file, and checked if the process specified was still running (by calling `Process.kill(0, pid)`), but 
+since the system reuses PID's you can get false positives.  This project uses a locked pid file to ensure that the process is truly still 
+running. So basically, if the file is locked the process is still running.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'singleton_process'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install singleton_process
+
+## Usage
+
+The basic usage is quite simple: just supply a process name (will show up in `ps ax` output) and call `#lock`.
+
+```ruby
+SingletonProcess.new('long_running_process').lock
+```
+
+By default the lock file will be removed when the process exits, but if you need to clear the lock earlier you can call #unlock.
+
+```ruby
+process = SingletonProcess.new('long_running_process')
+process.lock
+# your process here
+process.unlock
+```
+
+If you want only a specific block of code to be locked call `#run!` with the block.
+
+```ruby
+SingletonProcess.new('long_running_process_name').run! do
+  # some long running code here
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/singleton_process/version.rb

@@ -0,0 +1,3 @@
+class SingletonProcess
+  VERSION = "0.0.1" unless defined?(VERSION)
+end

data/lib/singleton_process.rb

@@ -0,0 +1,91 @@
+require "singleton_process/version"
+
+require 'pathname'
+
+class SingletonProcess
+  class AlreadyRunningError < RuntimeError; end
+
+  attr_accessor :name, :root_path, :app_name
+  private :name=
+
+  def initialize(name, options = {})
+    self.name      = name
+    self.root_path = options.fetch(:root_path, nil)
+    self.app_name  = options.fetch(:app_name, nil)
+  end
+
+  def root_path=(value)
+    @root_path = Pathname.new(value) if value
+  end
+  private :root_path=
+
+  def root_path
+    @root_path ||= defined?(Rails) ? Rails.root : Pathname.new('.')
+  end
+
+  def pidfile_path
+    pidfile_directory.join("#{name}.pid")
+  end
+
+  def lock
+    write_pidfile
+    at_exit { delete_pidfile }
+    $0 = "#{app_name} | #{name} | started #{Time.now}"
+  end
+
+  def run!
+    lock
+    yield if block_given?
+    unlock
+  end
+
+  def unlock
+    delete_pidfile
+    !running?
+  end
+
+  def running?
+    if pidfile_path.exist?
+      pidfile = pidfile_path.open('r')
+      !pidfile.flock(File::LOCK_EX | File::LOCK_NB)
+    else
+      false
+    end
+  ensure
+    if pidfile
+      pidfile.flock(File::LOCK_UN)
+      pidfile.close
+    end
+  end
+
+  def pid
+    running? ? pidfile_path.read.to_i : nil
+  end
+
+  private
+
+  def pidfile
+    @pidfile ||= pidfile_path.open('a')
+  end
+
+  def write_pidfile
+    if pidfile.flock(File::LOCK_EX | File::LOCK_NB)
+      pidfile.truncate(0)
+      pidfile.write("#{Process.pid}\n")
+      pidfile.fsync
+    else
+      raise AlreadyRunningError.new("Process already running: #{pid}")
+    end
+  end
+
+  def delete_pidfile
+    pidfile_path.unlink if pidfile_path.exist?
+  end
+
+  def pidfile_directory
+    dir = Pathname.new(root_path.join('tmp/pids'))
+    dir.mkpath unless dir.directory?
+    dir
+  end
+end
+

data/singleton_process.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'singleton_process/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "singleton_process"
+  gem.version       = SingletonProcess::VERSION
+  gem.authors       = ["Robert Jackson"]
+  gem.email         = ["robert.w.jackson@me.com"]
+  gem.description   = %q{Ensure that a given process is only running once. Helpful for ensure that scheduled tasks do not overlap if they run longer than the scheduled interval.}
+  gem.summary       = %q{Ensure that a given process is only running once.}
+  gem.homepage      = "https://github.com/rjackson/singleton_process"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rspec', '~>2.12.0'
+end

data/spec/singleton_process_spec.rb

@@ -0,0 +1,233 @@
+require 'timeout'
+require 'spec_helper'
+
+require_relative '../lib/singleton_process'
+
+describe SingletonProcess do
+  let(:random_pid)   { rand(99999)}
+  let(:process_name) {'testing'}
+  let(:pidfile_path) {Pathname.new("tmp/pids/#{process_name}.pid")}
+
+  before do
+    @original_name = $PROGRAM_NAME
+  end
+
+  after do
+    $PROGRAM_NAME = @original_name
+    singleton.pidfile_path.unlink if singleton.pidfile_path.exist?
+  end
+
+  def write_random_pid
+    pidfile_path.open('w'){|io| io.write "#{random_pid}\n"}
+  end
+
+  describe '.new' do
+    let(:tmp_pathname) {Pathname.new('/tmp')}
+
+    it "should accept a name." do
+      instance = described_class.new(process_name)
+      instance.name.should eql(process_name)
+    end
+
+    it "should accept a root_path." do
+      instance = described_class.new(process_name, root_path: tmp_pathname)
+      instance.root_path.should eql(tmp_pathname)
+    end
+
+    it "should convert root_path to a Pathname." do
+      instance = described_class.new(process_name, root_path: '/tmp')
+      instance.root_path.should eql(tmp_pathname)
+    end
+
+    it "should set root_path to Rails.root if not specified." do
+      stub_const('Rails', double('rails',:root => tmp_pathname))
+      instance = described_class.new(process_name)
+      instance.root_path.should eql(tmp_pathname)
+    end
+
+    it "should accept and save an application name." do
+      instance = described_class.new(process_name, app_name: 'blah')
+      instance.app_name.should eql('blah')
+    end
+  end
+
+  subject(:singleton) {described_class.new(process_name)}
+
+  describe "#name=" do
+    it "should be private." do
+      singleton.respond_to?(:name=).should be_false
+      singleton.respond_to?(:name=, true).should be_true
+    end
+  end
+
+  describe "lock" do
+    let(:expected_error) {SingletonProcess::AlreadyRunningError}
+
+    context "when it is not already running" do
+      it "should write the current PID to the pidfile." do
+        singleton.lock
+        written_pid = singleton.pidfile_path.read.to_i
+        written_pid.should eql(Process.pid)
+      end
+
+      it "should set the $PROGRAM_NAME." do
+        singleton.lock
+        $PROGRAM_NAME.should_not eql(@original_name)
+      end
+    end
+
+    context "when it is already running" do
+      context "in the same process" do
+        it "should raise an error." do
+          instance1 = described_class.new('blah')
+          instance2 = described_class.new('blah')
+
+          instance1.lock
+          expect{instance2.lock}.to raise_error(expected_error)
+        end
+      end
+
+      context "in separate processes" do
+        let(:successful_output) {'Ran successfully!'}
+        let(:process_name) {'spawn_test'}
+
+        let(:spawn_command) do
+          [ File.join(*RbConfig::CONFIG.values_at('bindir', 'RUBY_INSTALL_NAME')),
+            "-I", File.expand_path("../../lib", __FILE__),
+            "-r", "singleton_process",
+            "-e", """
+                trap(:INT) {puts '#{successful_output}'; exit;};
+                SingletonProcess.new('#{process_name}').lock;
+                while true; sleep 0.01; end;
+              """
+          ]
+        end
+
+        before do
+          require 'open3'
+          require 'io/wait'
+        end
+
+        after do
+          Process.kill(:KILL, @pid1) rescue nil
+          Process.kill(:KILL, @pid2) rescue nil
+        end
+
+        it "should raise an error." do
+          pidfile_path.exist?.should be_false
+          stdin1, stdout1, stderr1, wait_thr1 = Open3.popen3(*spawn_command)
+          @pid1 = wait_thr1[:pid]
+
+          start_time = Time.now
+          while Time.now - start_time < 1
+            break if pidfile_path.exist?
+            sleep 0.01
+          end
+          pidfile_path.exist?.should be_true
+
+          stdin2, stdout2, stderr2, wait_thr2 = Open3.popen3(*spawn_command)
+          @pid2 = wait_thr2[:pid]
+
+          begin
+            exit_status = Timeout.timeout(5) { wait_thr2.value }
+          rescue Timeout::Error
+            raise "Child process didn't exit properly."
+          end
+
+          stderr2.read.should match(/AlreadyRunningError/)
+          exit_status.success?.should be_false
+
+          stdin2.close; stdout2.close; stderr2.close
+
+          Process.kill(:INT, @pid1)
+
+          begin
+            exit_status = Timeout.timeout(5) { wait_thr1.value }
+          rescue Timeout::Error
+            raise "Child process didn't exit properly."
+          end
+
+          stdout1.read.should eql("#{successful_output}\n")
+          stdin1.close; stdout1.close; stderr1.close
+          exit_status.success?.should be_true
+        end
+      end
+    end
+  end
+
+  describe "run!" do
+    it "should yield." do
+      ran = false
+      singleton.run! { ran = true }
+      ran.should be_true
+    end
+
+    it "should call #lock." do
+      singleton.should_receive(:lock)
+      singleton.run!
+    end
+
+    it "should call #unlock." do
+      singleton.should_receive(:unlock)
+      singleton.run!
+    end
+  end
+
+  describe "#unlock" do
+    it "should delete the pid file." do
+      singleton.lock
+      singleton.running?.should be_true
+      singleton.unlock
+      singleton.running?.should be_false
+    end
+  end
+
+  describe "#running?" do
+    context "when the pid file exists" do
+      let(:pidfile) {pidfile_path.open('r')}
+
+      before do
+        write_random_pid
+      end
+
+      after do
+        pidfile_path.unlink
+      end
+
+      it "should return true when the pid file is locked." do
+        pidfile.flock(File::LOCK_EX | File::LOCK_NB).should be_true
+
+        singleton.running?.should be_true
+      end
+
+      it "should return false when there is no lock." do
+        singleton.running?.should be_false
+      end
+    end
+
+    it "should return false when the process is not running." do
+      pidfile_path.unlink if pidfile_path.exist?
+      singleton.running?.should be_false
+    end
+  end
+
+  describe "#pid" do
+
+    it "should return the pid from pidfile_path." do
+      pidfile_path.open('w') {|io| io.write "#{random_pid}\n" }
+      singleton.should_receive(:running?).and_return(true)
+      singleton.pid.should eql(random_pid)
+    end
+
+    it "should return nil unless the process is running?." do
+      singleton.pid.should be_nil
+    end
+  end
+
+  describe "#pidfile_path" do
+    it "should return the proper path based on the processes name." do
+      singleton.pidfile_path.expand_path.should eql(pidfile_path.expand_path)
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: singleton_process
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Robert Jackson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+    none: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+    none: false
+description: Ensure that a given process is only running once. Helpful for ensure
+  that scheduled tasks do not overlap if they run longer than the scheduled interval.
+email:
+- robert.w.jackson@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/singleton_process.rb
+- lib/singleton_process/version.rb
+- singleton_process.gemspec
+- spec/singleton_process_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/rjackson/singleton_process
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ensure that a given process is only running once.
+test_files:
+- spec/singleton_process_spec.rb
+- spec/spec_helper.rb
+has_rdoc: