pidly 0.1.0

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.*
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.yardopts

@@ -0,0 +1 @@
+--markup rdoc --title "pidly Documentation" --protected

data/ChangeLog.rdoc

@@ -0,0 +1,4 @@
+=== 0.1.0 / 2011-04-04
+
+* Initial release:
+

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Dustin Willis Webber
+
+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,59 @@
+# pidly
+
+* [Homepage][https://github.com/mephux/pidly]
+* [Documentation][http://rubydoc.info/gems/pidly/frames]
+
+## Description
+
+Pidly is a very minimalistic daemon library that doesn't make assumptions. Pidly allows you to control the 
+daemon without getting in the way with forced verbose output and usage messages.
+
+## Examples
+
+    require 'pidly'
+
+		class Test < Pidly::Control
+
+		  before_start do
+		    "BEFORE START #{@pid}"
+		  end
+
+		  start :when_daemon_starts
+
+		  stop do
+		    "Attempting to kill process: #{@pid}"
+		  end
+
+		  after_stop :test_after_daemon_stops
+
+		  error do
+		    "SENDING EMAIL | Error Count: #{@error_count}"
+		  end
+
+		  def when_daemon_starts
+		    loop do
+		      print "TEST FROM #{@pid}"
+		      sleep 2
+		    end
+		  end
+
+		end
+
+	@daemon = Test.spawn(
+	  :name => 'Test Daemon',
+	  :path => '/tmp',
+	  :verbose => true
+	)
+
+	# @daemon.send ARGV.first
+	@daemon.start # stop, status, restart, and kill.
+
+## Install
+
+  $ gem install pidly
+
+## Copyright
+
+Copyright (c) 2011 Dustin Willis Webber
+
+See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  gem 'ore-tasks', '~> 0.4'
+  require 'ore/tasks'
+
+  Ore::Tasks.new
+rescue LoadError => e
+  STDERR.puts e.message
+  STDERR.puts "Run `gem install ore-tasks` to install 'ore/tasks'."
+end
+
+begin
+  gem 'rspec', '~> 2.4'
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new
+rescue LoadError => e
+  task :spec do
+    abort "Please run `gem install rspec` to install RSpec."
+  end
+end
+
+task :test => :spec
+task :default => :spec
+
+begin
+  gem 'yard', '~> 0.6.0'
+  require 'yard'
+
+  YARD::Rake::YardocTask.new  
+rescue LoadError => e
+  task :yard do
+    abort "Please run `gem install yard` to install YARD."
+  end
+end
+task :doc => :yard

data/gemspec.yml

@@ -0,0 +1,14 @@
+name: pidly
+summary: "A super simple daemon library."
+description: 
+ "Pidly is a very minimalistic daemon library that doesnt make assumptions. Pidly allows you to control the
+  daemon without getting in the way with forced verbose output and usage messages."
+license: MIT
+authors: Dustin Willis Webber
+homepage: https://github.com/mephux/pidly
+has_yard: true
+
+development_dependencies:
+  ore-tasks: ~> 0.4
+  rspec: ~> 2.4
+  yard: ~> 0.6.0

data/lib/pidly.rb

@@ -0,0 +1,2 @@
+require 'pidly/control'
+require 'pidly/version'

data/lib/pidly/callbacks.rb

@@ -0,0 +1,120 @@
+module Pidly
+  #
+  # Pidly before/after callbacks
+  # 
+  module Callbacks
+    
+    #
+    # Before start
+    # 
+    # Right before the daemon is instructed to start the 
+    # following callback will be invoked and executed.
+    # 
+    # @param [Symbol] callback Method name
+    # @yield [] Code to be executed upon callback invocation
+    #
+    # @example 
+    #   before_start :method_name
+    #   # OR
+    #   before_start { puts "#{@pid} is about to start!" }
+    #
+    def before_start(callback=nil, &block)
+      add_callback(:before_start, (callback || block))
+    end
+    
+    #
+    # Start
+    # 
+    # When the daemon is instructed to start the 
+    # following callback will be invoked and executed.
+    # 
+    # @param [Symbol] callback Method name
+    # @yield [] Code to be executed upon callback invocation
+    #
+    # @example 
+    #   start :method_name
+    #   # OR
+    #   start { puts "Daemon Started!" }
+    # 
+    def start(callback=nil, &block)
+      add_callback(:start, (callback || block))
+    end
+    
+    #
+    # Stop
+    # 
+    # When the daemon is instructed to stop the 
+    # following callback will be invoked and executed.
+    # 
+    # @param [Symbol] callback Method name
+    # @yield [] Code to be executed upon callback invocation
+    # 
+    # @example 
+    #   stop :method_name
+    #   # OR
+    #   stop { puts "Attempting to stop #{@name} with pid #{@pid}!" }
+    # 
+    def stop(callback=nil, &block)
+      add_callback(:stop, (callback || block))
+    end
+    
+    #
+    # After stop
+    # 
+    # Right after the daemon is instructed to stop the 
+    # following callback will be invoked and executed.
+    # 
+    # @param [Symbol] callback Method name
+    # @yield [] Code to be executed upon callback invocation
+    #
+    # @example 
+    #   after_start :method_name
+    #   # OR
+    #   after_start { puts "#{@pid} was just killed!" }
+    #
+    def after_stop(callback=nil, &block)
+      add_callback(:after_stop, (callback || block))
+    end
+    
+    #
+    # Error
+    # 
+    # If the daemon encounters an error or an exception is raised
+    # the following callback will be invoked and executed.
+    # 
+    # @param [Symbol] callback Method name
+    # @yield [] Code to be executed upon callback invocation
+    #
+    # @example 
+    #   error :send_error_email
+    #   # OR
+    #   error { puts "ZOMG! #{@name} failed!" }
+    #
+    def error(callback=nil, &block)
+      add_callback(:error, (callback || block))
+    end
+
+    #
+    # Add callback
+    # 
+    # @param [Symbol] callback Callback method name
+    # @param [Symbol, nil] invoke Method to call
+    # @yield [] Code to be executed upon callback invocation
+    # 
+    def add_callback(callback, invoke)
+      Control.class_variable_set(:"@@#{callback}", invoke)
+    end
+
+    #
+    # Extend and include callback methods
+    # 
+    # @param [Class] receiver The calling class
+    # 
+    def self.included(receiver)
+      puts receiver.class
+      receiver.extend self
+    end
+
+  end # modle Callbacks
+  
+end # module Pidly

data/lib/pidly/control.rb

@@ -0,0 +1,331 @@
+require 'fileutils'
+require 'pathname'
+
+require 'pidly/callbacks'
+require 'pidly/logger'
+
+#
+# Pidly namespace
+#
+module Pidly
+
+  #
+  # Pidly daemon control
+  #
+  class Control
+
+    # Include callbacks
+    include Pidly::Callbacks
+    
+    # Include logging helpers
+    include Pidly::Logger
+
+    attr_accessor :daemon, :name, :pid_file,
+      :log_file, :path, :sync_log, :allow_multiple,
+      :verbose, :pid, :timeout, :error_count, :messages
+
+    #
+    # Initialize control object
+    #
+    # @param [Hash] options The options to create a controller with.
+    # 
+    # @raise [RuntimeError] 
+    #   Raise exception if path does not exist
+    # 
+    # @raise [RuntimeError] 
+    #   Raise exception if path is not readable or writable.
+    # 
+    def initialize(options={})
+
+      @messages = []
+
+      @error_count = 0
+
+      @name = options.fetch(:name)
+
+      if options.has_key?(:path)
+        @path = Pathname.new(options.fetch(:path))
+      else
+        @path = Pathname.new('/tmp')
+      end
+
+      unless @path.directory?
+        raise('Path does not exist or is not a directory.')
+      end
+
+      unless @path.readable? && @path.writable?
+        raise('Path must be readable and writable.')
+      end
+
+      if options.has_key?(:pid_file)
+        @pid_file = options.fetch(:pid_path)
+      else
+        @pid_file = File.join(@path.to_s, 'pids', @name + '.pid')
+      end
+
+      if options.has_key?(:log_file)
+        @log_file = options.fetch(:log_path)
+      else
+        @log_file = File.join(@path.to_s, 'logs', @name + '.log')
+      end
+
+      @pid = fetch_pid if File.file?(@pid_file)
+
+      @sync_log = options.fetch(:sync_log, true)
+
+      @allow_multiple = options.fetch(:allow_multiple, false)
+
+      @signal = options.fetch(:signal, "TERM")
+
+      @timeout = options.fetch(:timeout, 10)
+
+      @verbosity = options.fetch(:verbose, false)
+
+      @logger = options.fetch(:logger, true)
+    end
+
+    #
+    # Spawn
+    #
+    # @param [Hash] options The options to create a controller with.
+    # 
+    # @option options [String] :name Daemon name
+    # 
+    # @option options [String] :path Path to create the log/pids directory
+    # 
+    # @option options [String] :pid_file Pid file path
+    # 
+    # @option options [String] :log_file Log file path
+    # 
+    # @option options [true, false] :sync_log Synchronize log files
+    # 
+    # @option options [true, false] :allow_multiple 
+    #   Allow multiple daemons of the same type
+    # 
+    # @option options [true, false] :sync_log Synchronize log files
+    # 
+    # @option options [String] :signal Trap signal
+    # 
+    # @option options [Integer] :timeout Timeout for Process#wait
+    # 
+    # @option options [true, false] :verbose Display daemon messages
+    # 
+    # @option options [true, false] :logger Enable daemon logging
+    #
+    # @return [Control] Control object
+    #
+    def self.spawn(options={})
+      @daemon = new(options)
+    end
+    
+    #
+    # Start
+    # 
+    # Validate callbacks and start daemon
+    # 
+    def start
+      validate_files_and_paths!
+      validate_callbacks!
+
+      unless @allow_multiple
+        if running?
+          log(:error, "#{@name} is already running (PID #{@pid})")
+          return
+        end
+      end
+
+      @pid = fork do
+        begin
+          Process.setsid
+
+          open(@pid_file, 'w') do |f|
+            f << Process.pid
+            @pid = Process.pid
+          end
+
+          execute_callback(:before_start)
+
+          Dir.chdir @path.to_s
+          File.umask 0000
+
+          if @logger
+            log = File.new(@log_file, "a")
+            log.sync = @sync_log
+
+            STDIN.reopen "/dev/null"
+            STDOUT.reopen log
+            STDERR.reopen STDOUT
+          end
+          
+          trap("TERM") do
+            stop
+          end
+
+          execute_callback(:start)
+
+        rescue RuntimeError => message
+          STDERR.puts message
+          STDERR.puts message.backtrace
+
+          execute_callback(:error)
+        rescue => message
+          STDERR.puts message
+          STDERR.puts message.backtrace
+
+          execute_callback(:error)
+        end
+      end
+
+    rescue => message
+      STDERR.puts message
+      STDERR.puts message.backtrace
+      execute_callback(:error)
+    end
+    
+    #
+    # Stop
+    # 
+    # Stop daemon and remove pid file
+    # 
+    def stop
+
+      if running?
+
+        Process.kill(@signal, @pid)
+        FileUtils.rm(@pid_file)
+
+        execute_callback(:stop)
+
+        begin
+          Process.wait(@pid)
+        rescue Errno::ECHILD
+        end
+
+        @timeout.downto(0) do
+          sleep 1
+          exit unless running?
+        end
+
+        Process.kill 9, @pid if running?
+        execute_callback(:after_stop)
+
+      else
+        FileUtils.rm(@pid_file) if File.exists?(@pid_file)
+        log(:info, "PID file not found. Is the daemon started?")
+      end
+
+    rescue Errno::ENOENT
+    end
+    
+    #
+    # Status
+    # 
+    # Return current daemon status and pid
+    # 
+    # @return [String] Status
+    # 
+    def status
+      if running?
+        log(:info, "#{@name} is running (PID #{@pid})")
+      else
+        log(:info, "#{@name} is NOT running")
+      end
+    end
+    
+    #
+    # Restart
+    # 
+    # Restart the daemon
+    # 
+    def restart
+      stop; sleep 1 while running?; start
+    end
+    
+    #
+    # Kill
+    # 
+    # @param [String] remove_pid_file Remove the daemon pid file
+    # 
+    def kill(remove_pid_file=true)
+      if running?
+        log(:info, "Killing #{@name} (PID #{@pid})")
+        Process.kill 9, @pid
+      end
+
+      FileUtils.rm(@pid_file) if remove_pid_file
+    rescue Errno::ENOENT
+    end
+    
+    #
+    # Running?
+    # 
+    # @return [true, false] Return the running status of the daemon.
+    # 
+    def running?
+      Process.kill 0, @pid
+      true
+    rescue Errno::ESRCH
+      false
+    rescue Errno::EPERM
+      true
+    rescue
+      false
+    end
+    
+    def validate_files_and_paths!
+      log = Pathname.new(@log_file).dirname
+      pid = Pathname.new(@pid_file).dirname
+
+      unless File.directory?(log)
+        FileUtils.mkdir_p(log.to_s)
+      end
+
+      unless File.directory?(pid)
+        FileUtils.mkdir_p(pid.to_s)
+      end
+    end
+
+    def validate_callbacks!
+      unless Control.class_variable_defined?(:"@@start")
+        raise('You must define a "start" callback.')
+      end
+    end
+
+    def execute_callback(callback_name)
+      @error_count += 1 if callback_name == :error
+
+      if Control.class_variable_defined?(:"@@#{callback_name}")
+        callback = Control.class_variable_get(:"@@#{callback_name}")
+
+        if callback.kind_of?(Symbol)
+
+          unless self.respond_to?(callback.to_sym)
+            raise("Undefined callback method: #{callback}")
+          end
+
+          self.send(callback.to_sym)
+
+        elsif callback.respond_to?(:call)
+
+          self.instance_eval(&callback)
+
+        else
+          nil
+        end
+
+      end
+
+    end
+
+    def fetch_pid
+      IO.read(@pid_file).to_i
+    rescue
+      nil
+    end
+
+    private :validate_callbacks!, :fetch_pid,
+      :validate_files_and_paths!, :execute_callback
+
+  end # class Control
+
+end # module Pidly

data/lib/pidly/logger.rb

@@ -0,0 +1,49 @@
+module Pidly
+  #
+  # Logger namespace
+  # 
+  module Logger
+
+    attr_accessor :verbosity
+    
+    #
+    # Verbose
+    # 
+    # @return [true, false] Is the logging level verbose?
+    # 
+    def verbose?
+      @verbosity
+    end
+    
+    #
+    # Log
+    # 
+    # @param [String, Symbol] type Log type (info or error)
+    # @param [String] message Log message
+    # 
+    # @return [Strign] Log message
+    # 
+    def log(type, message)
+      case type.to_sym
+      when :info
+        msg = message
+      when :error
+        msg = message
+      end
+
+      @messages << msg
+      puts msg if verbose?
+    end
+    
+    #
+    # Extend and include callback methods
+    # 
+    # @param [Class] receiver The calling class
+    #
+    def self.included(receiver)
+      receiver.extend self
+    end
+
+  end # class Logger
+
+end # module Pidly

data/lib/pidly/version.rb

@@ -0,0 +1,4 @@
+module Pidly
+  # pidly version
+  VERSION = "0.1.0"
+end

data/pidly.gemspec

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+begin
+  Ore::Specification.new do |gemspec|
+    # custom logic here
+  end
+rescue NameError
+  begin
+    require 'ore/specification'
+    retry
+  rescue LoadError
+    STDERR.puts "The '#{__FILE__}' file requires Ore."
+    STDERR.puts "Run `gem install ore-core` to install Ore."
+  end
+end

data/spec/control_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'pidly'
+
+describe Control do
+
+  before(:all) do
+    @daemon = Test.spawn(
+      :name => 'test',
+      :path => '/tmp',
+      :verbose => false
+    )
+    @daemon.kill if @daemon.running?
+    @daemon.start
+    sleep 1
+  end
+
+  it "should be running" do
+    @daemon.running?.should == true
+  end
+  
+  it "should have an active status, name and pid" do
+    @daemon.status
+    reply = "#{@daemon.name} is running (PID #{@daemon.pid})"
+    @daemon.messages.last.should == reply
+  end
+  
+  it "should have the correct pid path" do
+    @daemon.pid_file.should == "/tmp/pids/#{@daemon.name}.pid"
+  end
+  
+  it "should have a pid file that exists" do
+    File.exists?("/tmp/pids/#{@daemon.name}.pid").should == true
+  end
+  
+  it "should have the correct log file" do
+    @daemon.log_file.should == "/tmp/logs/#{@daemon.name}.log"
+  end
+  
+  it "should have a log file that exists" do
+    File.exists?("/tmp/logs/#{@daemon.name}.log").should == true
+  end
+  
+  it "should fail when trying to start another daemon" do
+    @daemon.start
+    reply = "#{@daemon.name} is already running (PID #{@daemon.pid})"
+    
+    @daemon.messages.last.should == reply
+  end
+  
+  it "should write to the log file" do
+    file = File.open(@daemon.log_file, 'r')
+    file.read.should =~ /TEST FROM #{@daemon.pid}/
+  end
+  
+  it "should write to the pid file" do
+    file = File.open(@daemon.pid_file, 'r')
+    file.read.should =~ /#{@daemon.pid}/
+  end
+  
+  after(:all) do
+    @daemon.kill if @daemon
+    FileUtils.rm @daemon.log_file.to_s
+  end
+
+end

data/spec/pidly_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'pidly'
+
+describe Pidly do
+  it "should have a VERSION constant" do
+    subject.const_get('VERSION').should_not be_empty
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+gem 'rspec', '~> 2.4'
+require 'rspec'
+
+require 'pp'
+require 'pidly'
+include Pidly
+
+class Test < Pidly::Control
+
+  before_start do
+    "BEFORE START #{@pid}"
+  end
+
+  start :when_daemon_starts
+
+  stop do
+    "Attempting to kill process: #{@pid}"
+  end
+
+  after_stop :test_after_daemon_stops
+  
+  error do
+    "SENDING EMAIL | Error Count: #{@error_count}"
+  end
+
+  def when_daemon_starts
+    loop do
+      print "TEST FROM #{@pid}"
+      sleep 2
+    end
+  end
+
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: pidly
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Dustin Willis Webber
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-06 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ore-tasks
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.4"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.4"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.6.0
+  type: :development
+  version_requirements: *id003
+description: Pidly is a very minimalistic daemon library that doesnt make assumptions. Pidly allows you to control the daemon without getting in the way with forced verbose output and usage messages.
+email: []
+
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- ChangeLog.rdoc
+- LICENSE.txt
+files: 
+- .document
+- .rspec
+- .yardopts
+- ChangeLog.rdoc
+- LICENSE.txt
+- README.md
+- Rakefile
+- gemspec.yml
+- lib/pidly.rb
+- lib/pidly/callbacks.rb
+- lib/pidly/control.rb
+- lib/pidly/logger.rb
+- lib/pidly/version.rb
+- pidly.gemspec
+- spec/control_spec.rb
+- spec/pidly_spec.rb
+- spec/spec_helper.rb
+has_rdoc: yard
+homepage: https://github.com/mephux/pidly
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: pidly
+rubygems_version: 1.6.1
+signing_key: 
+specification_version: 3
+summary: A super simple daemon library.
+test_files: 
+- spec/control_spec.rb
+- spec/pidly_spec.rb