iyyov 1.0.0-java

data/lib/iyyov/daemon.rb

@@ -0,0 +1,348 @@
+#--
+# Copyright (C) 2010 David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+require 'rjack-slf4j'
+require 'fileutils'
+
+require 'iyyov/log_rotator'
+
+module Iyyov
+  include RJack
+
+  # A daemon isntance to start and monitor
+  class Daemon
+
+    # Name of this daemon. Must be unique in combination with any
+    # specified instance.
+    #
+    # String (required)
+    attr_accessor :name
+
+    # Optional specific instance identifier, distinguishing this
+    # daemon from others of the same name. For example, a port number
+    # could be used.
+    #
+    # Proc,~to_s (default: nil)
+    attr_writer   :instance
+
+    # Full path to executable to start.
+    #
+    # Proc,~to_s (default: compute from gem_name, init_name, and version)
+    attr_writer   :exe_path
+
+    # Any additional args to use on start
+    #
+    # Proc,Array[~to_s] (default: [])
+    attr_writer   :args
+
+    # Base directory under which run directories are found
+    #
+    # Proc,~to_s (default: Context.base_dir)
+    attr_writer   :base_dir
+
+    # Directory to execute under
+    #
+    # Proc,~to_s (default: base_dir / full_name)
+    attr_writer   :run_dir
+
+    # Whether to make run_dir, if not already present
+    #
+    # Boolean (default: Context.make_run_dir )
+    attr_accessor :make_run_dir
+
+    # Whether to stop this daemon when Iyyov exits
+    #
+    # Boolean (default: Context.stop_on_exit)
+    attr_accessor :stop_on_exit
+
+    # Duration in seconds between SIGTERM and final SIGKILL when
+    # stopping.
+    #
+    # Numeric (default: Context.stop_delay)
+    attr_accessor :stop_delay
+
+    # PID file written by the daemon process after start, containing
+    # the running daemon Process ID
+    #
+    # Proc,~to_s (default: run_dir, init_name + '.pid')
+    attr_writer   :pid_file
+
+    # The gem name used, in conjunction with version for gem-based
+    # default exe_path
+    #
+    # Proc,~to_s (default: name)
+    attr_writer   :gem_name
+
+    # The gem version requirements, i.e '~> 1.1.3'
+    #
+    # Proc,~to_s,Array[~to_s] (default: '>= 0')
+    attr_writer   :version
+
+    # The init script name used for gem-based default exe_path.
+    #
+    # Proc,~to_s (default: name)
+    attr_writer   :init_name
+
+    # Last found state of this daemon.
+    #
+    # Symbol (in STATES)
+    attr_reader   :state
+
+    # Once do_first is called and provided a gem is found (gem version
+    # specified).
+    #
+    # Gem::Specification
+    # FIXME: May not want to expose this.
+    attr_reader   :gem_spec
+
+    # States tracked
+    STATES = [ :begin, :up, :failed, :stopped ]
+
+    # Instance variables which may be set as Procs
+    LVARS = [ :@instance, :@exe_path, :@args, :@base_dir, :@run_dir, :@pid_file,
+              :@gem_name, :@version, :@init_name ]
+
+    # New daemon given specified or default global
+    # Iyyov.context. Yields self to block for configuration.
+    def initialize( context = Iyyov.context )
+
+      @context      = context
+      @name         = nil
+
+      @instance     = nil
+      @exe_path     = method :gem_exe_path
+      @args         = []
+      @base_dir     = method :default_base_dir
+      @run_dir      = method :default_run_dir
+      @make_run_dir = @context.make_run_dir
+      @stop_on_exit = @context.stop_on_exit
+      @stop_delay   = @context.stop_delay
+
+      @pid_file     = method :default_pid_file
+      @gem_name     = method :name
+      @version      = '>= 0'
+      @init_name    = method :name
+
+      @state        = :begin
+      @gem_spec     = nil
+      @rotators     = {}
+
+      yield self if block_given?
+
+      raise "name not specified" unless name
+
+      @log = SLF4J[ [ SLF4J[ self.class ].name,
+                      name, instance ].compact.join( '.' ) ]
+    end
+
+    # Given name + ( '-' + instance ) if provided.
+    def full_name
+      [ name, instance ].compact.join('-')
+    end
+
+    # Create a new LogRotator and yields it to block for
+    # configuration.
+    # The default log path is name + ".log" in run_dir
+    def log_rotate( &block )
+      lr = LogRotator.new( default_log, &block )
+      @rotators[ lr.log ] = lr
+      nil
+    end
+
+    # Post initialization validation, attempt immediate start if
+    # needed, and add appropriate tasks to scheduler.
+    def do_first( scheduler )
+      unless File.directory?( run_dir )
+        if make_run_dir
+          @log.info { "Creating run_dir [#{run_dir}]." }
+          FileUtils.mkdir_p( run_dir, :mode => 0755 )
+        else
+          raise( DaemonFailed, "run_dir [#{run_dir}] not found" )
+        end
+      end
+
+      res = start_check
+      unless res == :stop
+        tasks.each { |t| scheduler.add( t ) }
+      end
+      res
+    rescue DaemonFailed, SystemCallError => e
+      #FIXME: Ruby 1.4.0 throws SystemCallError when mkdir fails from
+      #permissions
+      @log.error( e.to_s )
+      @state = :failed
+      :stop
+    end
+
+    def tasks
+      t = [ Task.new( :name => full_name, :period => 5.0 ) { start_check } ]
+      t += @rotators.values.map do |lr|
+        Task.new( :name => "#{full_name}.rotate",
+                  :mode => :async,
+                  :period => lr.check_period ) do
+          lr.check_rotate( pid ) do |rlog|
+            @log.info { "Rotating log #{rlog}" }
+          end
+        end
+      end
+      t
+    end
+
+    def do_exit
+      stop if stop_on_exit
+    end
+
+    def default_base_dir
+      @context.base_dir
+    end
+
+    def default_run_dir
+      File.join( base_dir, full_name )
+    end
+
+    def default_pid_file
+      in_dir( init_name + '.pid' )
+    end
+
+    def default_log
+      in_dir( init_name + '.log' )
+    end
+
+    # Return full path to file_name within run_dir
+    def in_dir( file_name )
+      File.join( run_dir, file_name )
+    end
+
+    def gem_exe_path
+      File.join( find_gem_spec.full_gem_path, 'init', init_name )
+    end
+
+    def find_gem_spec
+      #FIXME: Use Gem.clear_paths to rescan.
+      @gem_spec ||= Gem.source_index.find_name( gem_name, version ).last
+      unless @gem_spec
+        raise( Gem::GemNotFoundException, "Missing gem #{gem_name} (#{version})" )
+      end
+      @gem_spec
+    end
+
+    def start
+      epath = File.expand_path( exe_path )
+      eargs = args.to_a.map { |a| a.to_s.strip }.compact
+      aversion = @gem_spec && @gem_spec.version
+      @log.info { ( [ "starting", aversion || epath ] + eargs ).join(' ') }
+
+      unless File.executable?( epath )
+        raise( DaemonFailed, "Exe path: #{epath} not found/executable." )
+      end
+
+      Dir.chdir( run_dir ) do
+        system( epath, *eargs ) or raise( DaemonFailed, "Start failed with #{$?}" )
+      end
+
+      @state = :up
+      true
+    rescue Gem::GemNotFoundException, DaemonFailed, Errno::ENOENT => e
+      @log.error( e.to_s )
+      @state = :failed
+      false
+    end
+
+    # Return array suitable for comparing this daemon with prior
+    # running instance.
+    def exec_key
+      keys = [ run_dir, exe_path ].map { |p| File.expand_path( p ) }
+      keys += args.to_a.map { |a| a.to_s.strip }.compact
+      keys.compact
+    end
+
+    def start_check
+      p = pid
+      if alive?( p )
+        @log.debug { "checked: alive pid: #{p}" }
+        @state = :up
+      else
+        unless start
+          @log.info "start failed, done trying"
+          :stop
+        end
+      end
+    end
+
+    # True if process is up
+    def alive?( p = pid )
+      ( Process.getpgid( p ) != -1 ) if p
+    rescue Errno::ESRCH
+      false
+    end
+
+    # Stop via SIGTERM, waiting for shutdown for up to stop_delay, then
+    # SIGKILL as last resort. Return true if a process was stopped.
+    def stop
+      p = pid
+      if p
+        @log.info "Sending TERM signal"
+        Process.kill( "TERM", p )
+        unless wait_pid( p )
+          @log.info "Sending KILL signal"
+          Process.kill( "KILL", p )
+        end
+        @status = :stopped
+        true
+      end
+      false
+    rescue Errno::ESRCH
+      # No such process: only raised by MRI ruby currently
+      false
+    rescue Errno::EPERM => e
+      # Not permitted: only raised by MRI ruby currently
+      @log.error( e )
+      false
+    end
+
+    # Wait for process to go away
+    def wait_pid( p = pid )
+      delta = 1.0 / 16
+      delay = 0.0
+      check = false
+      while delay < stop_delay do
+        break if ( check = ! alive?( p ) )
+        sleep delta
+        delay += delta
+        delta += ( 1.0 / 16 ) if delta < 0.50
+      end
+      check
+    end
+
+    # Return process ID from pid_file if exists or nil otherwise
+    def pid
+      id = IO.read( pid_file ).strip.to_i
+      ( id > 0 ) ? id : nil
+    rescue Errno::ENOENT # Pid file doesn't exist
+      nil
+    end
+
+    LVARS.each do |sym|
+      define_method( sym.to_s[1..-1] ) do
+        exp = instance_variable_get( sym )
+        exp.respond_to?( :call ) ? exp.call : exp
+      end
+    end
+
+  end
+
+  class DaemonFailed < StandardError; end
+end

data/lib/iyyov/errors.rb

@@ -0,0 +1,19 @@
+#--
+# Copyright (C) 2010 David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+module Iyyov
+  class SetupError < StandardError; end
+end

data/lib/iyyov/log_rotator.rb

@@ -0,0 +1,99 @@
+#--
+# Copyright (C) 2010 David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+require 'logrotate'
+
+module Iyyov
+  include RJack
+
+  # Support check for size and rotation of a log file.
+  class LogRotator
+
+    # Full path to log file to check and rotate
+    #
+    # String (required)
+    attr_accessor :log
+
+    # Maximum log size triggering rotation
+    #
+    # Fixnum bytes (default: 256M bytes)
+    attr_accessor :max_size
+
+    # Number of rotated logs in addition to active log.
+    #
+    # Fixnum (default: 3)
+    attr_accessor :count
+
+    # GZIP compress rotated logs?
+    #
+    # Boolean (default: true)
+    attr_accessor :gzip
+
+    # The signal to use post rotation (but before gzip) requesting
+    # that the daemon reopen its logs.
+    #
+    # String (default: "HUP")
+    attr_accessor :signal
+
+    # Period between subsequent checks for rotation (default: 300.0)
+    #
+    # Float seconds
+    attr_accessor :check_period
+
+    # Process ID to signal (if known in advance/constant, i.e. 0 for
+    # this process)
+    #
+    # Fixnum
+    attr_writer :pid
+
+    # Set max_size in megabytes
+    #
+    # mb<Fixnum>:: megabytes
+    def max_size_mb=( mb )
+      @max_size = mb * 1024 * 1024
+    end
+
+    def initialize( log = nil )
+      @log = log
+      max_size_mb = 256
+      @count = 3
+      @gzip = true
+      @signal = "HUP"
+      @check_period = 5 * 60.0
+      @pid = nil
+
+      yield self if block_given?
+
+      #FIXME: Validate log directory?
+      nil
+    end
+
+    # Check if log is over size and rotate if needed. Yield log name
+    # to block just before rotating
+    def check_rotate( pid = @pid )
+      if File.exist?( log ) && File.size( log ) > max_size
+        yield log if block_given?
+        opts  = { :count => count, :gzip => gzip }
+        if signal && pid
+          opts[ :post_rotate ] = lambda { Process.kill( signal, pid ) }
+        end
+        LogRotate.rotate_file( log, opts )
+      end
+      nil
+    end
+
+  end
+end

data/lib/iyyov/scheduler.rb

@@ -0,0 +1,120 @@
+#--
+# Copyright (C) 2010 David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+require 'java'
+
+require 'thread'
+require 'iyyov/shutdown_handler'
+
+module Iyyov
+
+  # Maintains a queue of Task to be executed at fixed or periodic
+  # times.
+  class Scheduler
+
+    def initialize
+      # min heap
+      @queue = Java::java.util.PriorityQueue.new( 67, TimeComp.new )
+      @lock = Mutex.new
+      @shutdown_handler = nil
+      @log = SLF4J[ self.class ]
+    end
+
+    def add( t, now = Time.now )
+      @queue.add( t ) if t.schedule( now )
+    end
+
+    def peek
+      @queue.peek
+    end
+
+    def poll
+      @queue.poll
+    end
+
+    # Execute the specified block on exit (in a shutdown thread.) The
+    # Scheduler queue is drained such that the on_exit block is
+    # guaranteed to be the last to run.
+    def on_exit( &block )
+      off_exit
+      @shutdown_handler = ShutdownHandler.new do
+
+        # Need to lock out the event loop since exit handler is called
+        # from a different thread.
+        @lock.synchronize do
+          @queue.clear
+          block.call
+        end
+      end
+      @log.debug { "Registered exit: #{ @shutdown_handler.handler }" }
+    end
+
+    # Deregister any previously added on_exit block
+    def off_exit
+      if @shutdown_handler
+        @log.debug { "Unregistered exit: #{ @shutdown_handler.handler }" }
+        @shutdown_handler.unregister
+        @shutdown_handler = nil
+      end
+    end
+
+    # Loop forever executing tasks or waiting for the next to be
+    # ready. Return only when the queue is empty (which may be arranged by
+    # on_exit) or if a Task returns :shutdown.
+    def event_loop
+      rc = nil
+
+      # While not shutdown
+      while ( rc != :shutdown )
+        now = Time.now
+        delta = 0.0
+
+        @lock.synchronize do
+          # While we don't need to wait, and a task is available
+          while ( delta <= 0.0 && ( task = peek ) && rc != :shutdown )
+            delta = task.next_time - now
+
+            if delta <= 0.0
+              task = poll
+
+              rc = task.run
+              add( task, now ) unless ( rc == :shutdown || rc == :stop )
+            end
+          end
+        end #lock
+
+        break unless delta > 0.0
+        sleep delta
+      end
+
+      if rc == :shutdown
+        @log.debug "Begin scheduler shutdown sequence."
+        @queue.clear
+        off_exit
+      end
+      rc
+    end
+
+    # Implements java.util.Comparator over task.next_time values
+    class TimeComp
+      include Java::java.util.Comparator
+      def compare( p, n )
+        p.next_time <=> n.next_time
+      end
+    end
+
+  end
+end

data/lib/iyyov/shutdown_handler.rb

@@ -0,0 +1,46 @@
+#--
+# Copyright (C) 2010 David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+require 'java'
+
+module Iyyov
+
+  class ShutdownHandler
+    Thread  = Java::java.lang.Thread
+    Runtime = Java::java.lang.Runtime
+
+    include Java::java.lang.Runnable
+
+    attr_reader :handler
+
+    def initialize( &block )
+      @block = block
+      @handler = Thread.new( self )
+      Runtime::runtime.add_shutdown_hook( @handler )
+    end
+
+    def unregister
+      Runtime::runtime.remove_shutdown_hook( @handler )
+      @handler = nil
+      @block = nil
+    end
+
+    def run
+      @block.call
+    end
+
+  end
+end