class Servolux::Daemon

def alive?
  pid = retrieve_pid
  Process.kill(0, pid)
  true
rescue Errno::ESRCH, Errno::ENOENT
  false
rescue Errno::EACCES => err
  logger.error "You do not have access to the PID file at " \
               "#{pid_file.inspect}: #{err.message}"
  false
end

def exec( *args )
  logger.debug "Calling: exec(*#{args.inspect})"
  skip = [STDIN, STDOUT, STDERR]
  skip << @piper.write_io if @piper
  ObjectSpace.each_object(IO) { |obj|
    next if skip.include? obj
    obj.close rescue nil
  }
  Kernel.exec(*args)
end

def initialize( opts = {} )
  self.server = opts.getopt(:server) || opts.getopt(: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)
  @piper = nil
  @logfile_reader = nil
  self.log_file = opts.getopt(:log_file)
  self.look_for = opts.getopt(:look_for)
  yield self if block_given?
  ary = %w[name logger pid_file startup_command].map { |var|
    self.send(var).nil? ? var : nil
  }.compact
  raise Error, "These variables are required: #{ary.join(', ')}." unless ary.empty?
end

def kill( signal = 'INT' )
  signal = Signal.list.invert[signal] if signal.is_a?(Integer)
  pid = retrieve_pid
  logger.info "Killing PID #{pid} with #{signal}"
  Process.kill(signal, pid)
rescue Errno::EINVAL
  logger.error "Failed to kill PID #{pid} with #{signal}: " \
               "'#{signal}' is an invalid or unsupported signal number."
rescue Errno::EPERM
  logger.error "Failed to kill PID #{pid} with #{signal}: " \
               "Insufficient permissions."
rescue Errno::ESRCH
  logger.error "Failed to kill PID #{pid} with #{signal}: " \
               "Process is deceased or zombie."
rescue Errno::EACCES => err
  logger.error err.message
rescue Errno::ENOENT => err
  logger.error "Could not find a PID file at #{pid_file.inspect}. " \
               "Most likely the process is no longer running."
rescue Exception => err
  unless err.is_a?(SystemExit)
    logger.error "Failed to kill PID #{pid} with #{signal}: #{err.message}"
  end
end

def log_file=( filename )
  return if filename.nil?
  @logfile_reader ||= LogfileReader.new
  @logfile_reader.filename = filename
end

def logger
  @logger ||= Logging.logger[self]
end

def look_for=( val )
  return if val.nil?
  @logfile_reader ||= LogfileReader.new
  @logfile_reader.look_for = val
end

def retrieve_pid
  @piper ? @piper.pid : Integer(File.read(pid_file).strip)
rescue TypeError
  raise Error, "A PID file was not specified."
rescue ArgumentError
  raise Error, "#{pid_file.inspect} does not contain a valid PID."
end

def run_startup_command
  case startup_command
  when String; exec(startup_command)
  when Array; exec(*startup_command)
  when Proc, Method; startup_command.call
  when ::Servolux::Server; startup_command.startup
  else
    raise Error, "Unrecognized startup command #{startup_command.inspect}"
  end
rescue Exception => err
  unless err.is_a?(SystemExit)
    logger.fatal err
    @piper.puts err
  end
ensure
  @piper.close
end

def shutdown
  return unless alive?
  case shutdown_command
  when nil; kill
  when String; exec(shutdown_command)
  when Array; exec(*shutdown_command)
  when Proc, Method; shutdown_command.call
  when ::Servolux::Server; shutdown_command.shutdown
  else
    raise Error, "Unrecognized shutdown command #{shutdown_command.inspect}"
  end
  wait_for_shutdown
end

def started?
  return false unless alive?
  return true if @logfile_reader.nil?
  @logfile_reader.updated?
end

def startup
  raise Error, "Fork is not supported in this Ruby environment." unless ::Servolux.fork?
  return if alive?
  logger.debug "About to fork ..."
  @piper = ::Servolux::Piper.daemon(nochdir, noclose)
  @piper.parent {
    @piper.timeout = 0
    wait_for_startup
    exit!(0)
  }
  @piper.child { run_startup_command }
end

def startup_command=( val )
  @startup_command = val
  return unless val.is_a?(::Servolux::Server)
  @name = val.name
  @logger = val.logger
  @pid_file = val.pid_file
  @shutdown_command = nil
end

def wait_for
  start = Time.now
  nap_time = 0.2
  loop do
    sleep nap_time
    diff = Time.now - start
    nap_time = 2*nap_time
    nap_time = 0.2 if nap_time > 1.6
    break true if yield
    break false if diff >= timeout
  end
end

def wait_for_shutdown
  logger.debug "Waiting for #{name.inspect} to shutdown."
  return if wait_for { !alive? }
  raise Timeout, "#{name.inspect} failed to shutdown in a timely fashion. " \
                 "The timeout is set at #{timeout} seconds."
end

def wait_for_startup
  logger.debug "Waiting for #{name.inspect} to startup."
  started = wait_for {
    rv = started?
    err = @piper.gets
    raise StartupError, "Child raised error: #{err.inspect}" unless err.nil?
    rv
  }
  raise Timeout, "#{name.inspect} failed to startup in a timely fashion. " \
                 "The timeout is set at #{timeout} seconds." unless started
  logger.info 'Server has daemonized.'
ensure
  @piper.close
end