servolux 0.6.2 → 0.7.0

data/.gitignore

@@ -0,0 +1,17 @@
+# The list of files that should be ignored by Mr Bones.
+# Lines that start with '#' are comments.
+#
+# A .gitignore file can be used instead by setting it as the ignore
+# file in your Rakefile:
+#
+#   PROJ.ignore_file = '.gitignore'
+#
+# For a project with a C extension, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+*~
+*.sw[op]
+announcement.txt
+coverage
+doc
+pkg

data/History.txt

@@ -1,3 +1,10 @@
+== 0.7.0 / 2009-11-06
+
+* 1 Minor Enhancement
+  * Added a permissions mask for the server PID file [Avdi Grimm]
+* 1 Bug Fix
+  * Fixing up some development / runtime dependencies
+
 == 0.6.2 / 2009-07-16
 
 * 1 Minor Enhancement

data/README.rdoc

@@ -1,15 +1,15 @@
 = Serv-O-Lux
 * by Tim Pease
-* http://github.com/TwP/servolux/tree/master
+* http://gemcutter.org/gems/servolux
 
-=== DESCRIPTION:
+=== DESCRIPTION
 
 Serv-O-Lux is a collection of Ruby classes that are useful for daemon and
 process management, and for writing your own Ruby services. The code is well
 documented and tested. It works with Ruby and JRuby supporing both 1.8 and 1.9
 interpreters.
 
-=== FEATURES:
+=== FEATURES
 
 Servolux::Threaded -- when included into your own class, it gives you an
 activity thread that will run some code at a regular interval. Provides methods
@@ -34,11 +34,11 @@ signal the child process to die if it does not exit in a given amount of time.
 
 All the documentation is available online at http://codeforpeople.rubyforge.org/servolux
 
-=== INSTALL:
+=== INSTALL
 
   gem install servolux
 
-=== LICENSE:
+=== LICENSE
 
 (The MIT License)
 

data/Rakefile

@@ -1,16 +1,8 @@
-# Look in the tasks/setup.rb file for the various options that can be
-# configured in this Rakefile. The .rake files in the tasks directory
-# are where the options are used.
 
 begin
   require 'bones'
-  Bones.setup
 rescue LoadError
-  begin
-    load 'tasks/setup.rb'
-  rescue LoadError
-    raise RuntimeError, '### please install the "bones" gem ###'
-  end
+  abort '### please install the "bones" gem ###'
 end
 
 ensure_in_path 'lib'
@@ -18,24 +10,20 @@ require 'servolux'
 
 task :default => 'spec:specdoc'
 
-PROJ.name = 'servolux'
-PROJ.authors = 'Tim Pease'
-PROJ.email = 'tim.pease@gmail.com'
-PROJ.url = 'http://codeforpeople.rubyforge.org/servolux'
-PROJ.version = Servolux::VERSION
-PROJ.rubyforge.name = 'codeforpeople'
-PROJ.exclude << 'servolux.gemspec'
-PROJ.readme_file = 'README.rdoc'
-PROJ.ignore_file = '.gitignore'
-PROJ.rdoc.remote_dir = 'servolux'
+Bones {
+  name         'servolux'
+  authors      'Tim Pease'
+  email        'tim.pease@gmail.com'
+  url          'http://gemcutter.org/gems/servolux'
+  version      Servolux::VERSION
+  readme_file  'README.rdoc'
+  ignore_file  '.gitignore'
 
-PROJ.spec.opts << '--color'
+  spec.opts << '--color'
 
-PROJ.ann.email[:server] = 'smtp.gmail.com'
-PROJ.ann.email[:port] = 587
-PROJ.ann.email[:from] = 'Tim Pease'
+  use_gmail
 
-depend_on 'logging'
-depend_on 'rspec'
-
-# EOF
+  depend_on  'bones-extras', :development => true
+  depend_on  'logging',      :development => true
+  depend_on  'rspec',        :development => true
+}

data/lib/servolux/child.rb

@@ -68,10 +68,10 @@ class Servolux::Child
   #     a signal before trying the next one in the list.
   #
   def initialize( opts = {} )
-    @command = opts.getopt :command
-    @timeout = opts.getopt :timeout
-    @signals = opts.getopt :signals, %w[TERM QUIT KILL]
-    @suspend = opts.getopt :suspend, 4
+    @command = opts[:command]
+    @timeout = opts[:timeout]
+    @signals = opts[:signals] || %w[TERM QUIT KILL]
+    @suspend = opts[:suspend] || 4
     @io = @pid = @status = @thread = @timed_out = nil
     yield self if block_given?
   end

data/lib/servolux/daemon.rb

@@ -75,7 +75,7 @@ class Servolux::Daemon
   StartupError = Class.new(Error)
 
   attr_reader   :name
-  attr_writer   :logger
+  attr_accessor :logger
   attr_accessor :pid_file
   attr_reader   :startup_command
   attr_accessor :shutdown_command
@@ -144,20 +144,20 @@ class Servolux::Daemon
   #     is fully started. The default is nil.
   #
   def initialize( opts = {} )
-    self.server = opts.getopt(:server) || opts.getopt(:startup_command)
+    self.server = opts[:server] || opts[:startup_command]
 
     @name     = opts[:name]     if opts.key?(:name)
     @logger   = opts[:logger]   if opts.key?(:logger)
     @pid_file = opts[:pid_file] if opts.key?(:pid_file)
-    @timeout  = opts.getopt(:timeout, 30)
-    @nochdir  = opts.getopt(:nochdir, false)
-    @noclose  = opts.getopt(:noclose, false)
-    @shutdown_command = opts.getopt(:shutdown_command)
+    @timeout  = opts[:timeout] || 30
+    @nochdir  = opts[:nochdir] || false
+    @noclose  = opts[:noclose] || false
+    @shutdown_command = opts[:shutdown_command]
 
     @piper = nil
     @logfile_reader = nil
-    self.log_file = opts.getopt(:log_file)
-    self.look_for = opts.getopt(:look_for)
+    self.log_file = opts[:log_file]
+    self.look_for = opts[:look_for]
 
     yield self if block_given?
 
@@ -256,7 +256,7 @@ class Servolux::Daemon
     wait_for_shutdown
   end
 
-  # Returns +true+ if the daemon processis currently running. Returns
+  # Returns +true+ if the daemon process is currently running. Returns
   # +false+ if this is not the case. The status of the process is determined
   # by sending a signal to the process identified by the +pid_file+.
   #
@@ -301,12 +301,6 @@ class Servolux::Daemon
     end
   end
 
-  # Returns the logger instance used by the daemon to log messages.
-  #
-  def logger
-    @logger ||= Logging.logger[self]
-  end
-
 
   private
 

data/lib/servolux/piper.rb

@@ -121,7 +121,7 @@ class Servolux::Piper
       raise ArgumentError, "Unsupported mode #{mode.inspect}"
     end
 
-    @timeout = opts.getopt(:timeout, 0)
+    @timeout = opts[:timeout] || 0
     if defined? ::Encoding
       @read_io, @write_io = IO.pipe('ASCII-8BIT')    # encoding for Ruby 1.9
     else

data/lib/servolux/server.rb

@@ -129,9 +129,12 @@ class Servolux::Server
 
   Error = Class.new(::Servolux::Error)
 
+  DEFAULT_PID_FILE_MODE = 0640
+
   attr_reader   :name
   attr_accessor :logger
   attr_writer   :pid_file
+  attr_accessor :pid_file_mode
 
   # call-seq:
   #    Server.new( name, options = {} ) { block }
@@ -147,14 +150,13 @@ class Servolux::Server
   #
   def initialize( name, opts = {}, &block )
     @name = name
-    @activity_thread = nil
-    @activity_thread_running = false
     @mutex = Mutex.new
     @shutdown = nil
 
-    self.logger   = opts.getopt :logger
-    self.pid_file = opts.getopt :pid_file
-    self.interval = opts.getopt :interval, 0
+    self.logger        = opts[:logger]
+    self.pid_file      = opts[:pid_file]
+    self.pid_file_mode = opts[:pid_file_mode] || DEFAULT_PID_FILE_MODE
+    self.interval      = opts[:interval] || 0
 
     if block
       eg = class << self; self; end
@@ -246,7 +248,7 @@ class Servolux::Server
 
   def create_pid_file
     logger.debug "Server #{name.inspect} creating pid file #{pid_file.inspect}"
-    File.open(pid_file, 'w') {|fd| fd.write(Process.pid.to_s)}
+    File.open(pid_file, 'w', pid_file_mode) {|fd| fd.write(Process.pid.to_s)}
   end
 
   def delete_pid_file

data/lib/servolux/threaded.rb

@@ -1,4 +1,3 @@
-
 # == Synopsis
 # The Threaded module is used to peform some activity at a specified
 # interval.
@@ -52,35 +51,11 @@ module Servolux::Threaded
   # after the thread is created.
   #
   def start
-    return self if running?
+    return self if _activity_thread.running?
     logger.debug "Starting"
 
     before_starting if self.respond_to?(:before_starting)
-    @activity_thread_running = true
-    @activity_thread_iterations = 0
-    @activity_thread = Thread.new {
-      begin
-        loop {
-          begin
-            sleep interval if running?
-            break unless running?
-            run
-            @activity_thread_iterations += 1
-            break if finished_iterations?
-          rescue SystemExit; raise
-          rescue Exception => err
-            if continue_on_error?
-              logger.error err
-            else
-              logger.fatal err
-              raise err
-            end
-          end
-        }
-      ensure
-        @activity_thread_running = false
-      end
-    }
+    @_activity_thread.start self
     after_starting if self.respond_to?(:after_starting)
     self
   end
@@ -95,14 +70,11 @@ module Servolux::Threaded
   # has stopped.
   #
   def stop( limit = nil )
-    return self unless running?
+    return self unless _activity_thread.running?
     logger.debug "Stopping"
 
-    @activity_thread_running = false
     before_stopping if self.respond_to?(:before_stopping)
-    @activity_thread.wakeup
-    join limit
-    @activity_thread = nil
+    @_activity_thread.stop limit
     after_stopping if self.respond_to?(:after_stopping)
     self
   end
@@ -113,11 +85,12 @@ module Servolux::Threaded
   # number of iterations has passed since this method was called.
   #
   def wait( limit = nil )
-    return self unless running?
-    start_waiting_iterations = self.iterations
+    return self unless _activity_thread.running?
+    initial_iterations = @_activity_thread.iterations
     loop {
-      break unless running?
-      break if limit and self.iterations > ( start_waiting_iterations + limit )
+      break unless @_activity_thread.running?
+      break if limit and @_activity_thread.iterations > ( initial_iterations + limit )
+      Thread.pass
     }
   end
 
@@ -129,15 +102,14 @@ module Servolux::Threaded
   # with +nil+.
   #
   def join( limit = nil )
-    return if @activity_thread.nil?
-    @activity_thread.join(limit) ? self : nil
+    _activity_thread.join(limit) ? self : nil
   end
 
   # Returns +true+ if the activity thread is running. Returns +false+
   # otherwise.
   #
   def running?
-    @activity_thread_running
+    _activity_thread.running?
   end
 
   # Returns +true+ if the activity thread has finished its maximum
@@ -145,9 +117,8 @@ module Servolux::Threaded
   # Returns +false+ otherwise.
   #
   def finished_iterations?
-    return true unless running?
-    return true if maximum_iterations and (iterations >= maximum_iterations)
-    return false
+    return true unless _activity_thread.running?
+    @_activity_thread.finished_iterations?
   end
 
   # Returns the status of threaded object.
@@ -162,45 +133,50 @@ module Servolux::Threaded
   # will cause the exception to be raised in the calling thread.
   #
   def status
-    return false if @activity_thread.nil?
-    @activity_thread.status
+    return false if _activity_thread.thread.nil?
+    @_activity_thread.thread.status
   end
 
   # Sets the number of seconds to sleep between invocations of the
   # threaded object's 'run' method.
   #
   def interval=( value )
-    @activity_thread_interval = value
+    value = Float(value)
+    raise ArgumentError, "Sleep interval must be >= 0" unless value >= 0
+    _activity_thread.interval = value
   end
 
   # Returns the number of seconds to sleep between invocations of the
   # threaded object's 'run' method.
   #
   def interval
-    @activity_thread_interval ||= 60
+    _activity_thread.interval
   end
 
   # Sets the maximum number of invocations of the threaded object's
   # 'run' method
   #
   def maximum_iterations=( value )
-    raise ArgumentError, "maximum iterations must be >= 1" unless value.to_i >= 1
-    @activity_thread_maximum_iterations = value.to_i
+    unless value.nil?
+      value = Integer(value)
+      raise ArgumentError, "maximum iterations must be >= 1" unless value >= 1
+    end
+
+    _activity_thread.maximum_iterations = value
   end
 
   # Returns the maximum number of invocations of the threaded
   # object's 'run' method
   #
   def maximum_iterations
-    return unless defined? @activity_thread_maximum_iterations
-    @activity_thread_maximum_iterations
+    _activity_thread.maximum_iterations
   end
 
   # Returns the number of iterations of the threaded object's 'run' method
   # completed thus far.
   #
   def iterations
-    @activity_thread_iterations ||= 0
+    _activity_thread.iterations
   end
 
   # Set to +true+ to continue running the threaded object even if an error
@@ -211,7 +187,7 @@ module Servolux::Threaded
   # interpreter to exit.
   #
   def continue_on_error=( value )
-    @activity_thread_continue_on_error = (value ? true : false)
+    _activity_thread.continue_on_error = (value ? true : false)
   end
 
   # Returns +true+ if the threded object should continue running even if an
@@ -219,28 +195,64 @@ module Servolux::Threaded
   # threaded object will stop running when an error is raised.
   #
   def continue_on_error?
-    return @activity_thread_continue_on_error if defined? @activity_thread_continue_on_error
-    @activity_thread_continue_on_error = false
+    _activity_thread.continue_on_error
   end
 
   # :stopdoc:
-  #
-  # The JRuby platform has an implementation error in it's Thread#join
-  # method. In the Matz Ruby Interpreter, Thread#join with a +nil+ argument
-  # will sleep forever; in the JRuby implementation, join will return
-  # immediately.
-  #
-  if 'java' == RUBY_PLATFORM
-    undef :join
+
+  def _activity_thread
+    @_activity_thread ||= ::Servolux::Threaded::ThreadContainer.new(nil, false, 60, 0, nil, false);
+  end
+
+  ThreadContainer = Struct.new( :thread, :running, :interval, :iterations, :maximum_iterations, :continue_on_error ) {
+    def start( threaded )
+      self.running = true
+      self.iterations = 0
+      self.thread = Thread.new { run threaded }
+      Thread.pass
+    end
+
+    def stop( limit )
+      self.running = false
+      thread.wakeup
+      join limit
+      self.thread = nil
+    end
+
+    def run( threaded )
+      loop {
+        begin
+          sleep interval if running?
+          break unless running?
+          threaded.run
+          self.iterations += 1
+          break if finished_iterations?
+        rescue SystemExit; raise
+        rescue Exception => err
+          if continue_on_error
+            threaded.logger.error err
+          else
+            threaded.logger.fatal err
+            raise err
+          end
+        end
+      }
+    ensure
+      self.running = false
+    end
+
     def join( limit = nil )
-      return if @activity_thread.nil?
-      if limit.nil?
-        @activity_thread.join ? self : nil
-      else
-        @activity_thread.join(limit) ? self : nil
-      end
+      return if thread.nil?
+      limit ? thread.join(limit) : thread.join
     end
-  end
+
+    def finished_iterations?
+      return true if maximum_iterations and (iterations >= maximum_iterations)
+      return false
+    end
+
+    alias :running? :running
+  }
   # :startdoc:
 
 end  # module Servolux::Threaded

data/lib/servolux.rb

@@ -1,14 +1,12 @@
 
-require 'logging'
-
 module Servolux
 
   # :stopdoc:
-  VERSION = '0.6.2'
+  VERSION = '0.7.0'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:
-  
+
   # Generic Servolux Error class.
   Error = Class.new(StandardError)
 

data/spec/server_spec.rb

@@ -30,6 +30,19 @@ describe Servolux::Server do
     test(?e, @server.pid_file).should be_false
   end
 
+  it 'generates a PID file with mode rw-r----- by default' do
+    t = Thread.new {@server.startup}
+    Thread.pass until @server.status == 'sleep'
+    (File.stat(@server.pid_file).mode & 0777).should == 0640
+  end
+
+  it 'generates PID file with the specified permissions' do
+    @server.pid_file_mode = 0400
+    t = Thread.new {@server.startup}
+    Thread.pass until @server.status == 'sleep'
+    (File.stat(@server.pid_file).mode & 0777).should == 0400
+  end
+
   it 'shuts down gracefully when signaled' do
     t = Thread.new {@server.startup}
     Thread.pass until @server.status == 'sleep'

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ unless defined? SERVOLUX_SPEC_HELPER
 SERVOLUX_SPEC_HELPER = true
 
 require 'rubygems'
+require 'logging'
 require 'spec'
 require 'spec/logging_helper'
 

data/spec/threaded_spec.rb

@@ -6,8 +6,7 @@ describe Servolux::Threaded do
   base = Class.new do
     include Servolux::Threaded
     def initialize
-      @activity_thread_running = false
-      @activity_thread_interval = 0
+      self.interval = 0
     end
     def pass( val = 'sleep' )
       Thread.pass until status == val

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: servolux
 version: !ruby/object:Gem::Version 
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors: 
 - Tim Pease
@@ -9,28 +9,38 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-16 00:00:00 -06:00
+date: 2009-11-06 00:00:00 -07:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bones-extras
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
 - !ruby/object:Gem::Dependency 
   name: logging
-  type: :runtime
+  type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.2
+        version: 1.2.2
     version: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :runtime
+  type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.2.2
+        version: 1.2.8
     version: 
 - !ruby/object:Gem::Dependency 
   name: bones
@@ -40,9 +50,13 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.5.0
+        version: 3.0.0
     version: 
-description: Serv-O-Lux is a collection of Ruby classes that are useful for daemon and process management, and for writing your own Ruby services. The code is well documented and tested. It works with Ruby and JRuby supporing both 1.8 and 1.9 interpreters.
+description: |-
+  Serv-O-Lux is a collection of Ruby classes that are useful for daemon and
+  process management, and for writing your own Ruby services. The code is well
+  documented and tested. It works with Ruby and JRuby supporing both 1.8 and 1.9
+  interpreters.
 email: tim.pease@gmail.com
 executables: []
 
@@ -52,6 +66,7 @@ extra_rdoc_files:
 - History.txt
 - README.rdoc
 files: 
+- .gitignore
 - History.txt
 - README.rdoc
 - Rakefile
@@ -67,21 +82,10 @@ files:
 - spec/servolux_spec.rb
 - spec/spec_helper.rb
 - spec/threaded_spec.rb
-- tasks/ann.rake
-- tasks/bones.rake
-- tasks/gem.rake
-- tasks/git.rake
-- tasks/notes.rake
-- tasks/post_load.rake
-- tasks/rdoc.rake
-- tasks/rubyforge.rake
-- tasks/setup.rb
-- tasks/spec.rake
-- tasks/svn.rake
-- tasks/test.rake
-- tasks/zentest.rake
 has_rdoc: true
-homepage: http://codeforpeople.rubyforge.org/servolux
+homepage: http://gemcutter.org/gems/servolux
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -102,10 +106,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: codeforpeople
-rubygems_version: 1.3.1
+rubyforge_project: servolux
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Serv-O-Lux is a collection of Ruby classes that are useful for daemon and process management, and for writing your own Ruby services
 test_files: []