daemonic 0.0.2 → 0.1.0

data/lib/daemonic.rb

@@ -1,17 +1,49 @@
+require "thread"
+require "optparse"
+require "logger"
+require "fileutils"
+require "timeout"
+
 require "daemonic/version"
-require "daemonic/master"
-require "daemonic/pool"
-require "daemonic/configuration"
+require "daemonic/daemon"
 require "daemonic/cli"
+require "daemonic/producer"
+require "daemonic/pool"
+
+Thread.abort_on_exception = true
 
 module Daemonic
 
-  def self.start(options)
-    config = Configuration.new(options, Dir.pwd)
-    config.reload
-    Process.daemon if config.daemonize?
-    Master.new(config).start
+  def self.run(worker, default_options = {})
+    command, options = CLI.new(ARGV, default_options).run
+    case command
+    when :start   then start(worker, options)
+    when :stop    then stop(options)
+    when :status  then status(options)
+    when :restart then restart(worker, options)
+    end
+  end
+
+  def self.start(worker, options)
+    daemon = Daemon.new(options)
+    daemon.start do
+      Producer.new(worker, options).run
+    end
   end
 
+  def self.stop(options)
+    Daemon.new(options).stop
+  end
+
+  def self.status(options)
+    Daemon.new(options).status
+  end
+
+  def self.restart(worker, options)
+    daemon = Daemon.new(options.merge(daemonize: true))
+    daemon.restart do
+      Producer.new(worker, options).run
+    end
+  end
 
 end

data/lib/daemonic/cli.rb

@@ -1,67 +1,174 @@
-require 'optparse'
-
 module Daemonic
-  module CLI
+  class CLI
 
-    def self.parse(args)
-      options = {}
+    COMMANDS = %w(start stop status restart help)
 
-      parser = OptionParser.new do |opts|
+    attr_reader :argv, :default_options
 
-        opts.banner = "Usage: #{$0} options"
+    def initialize(argv, default_options = {})
+      @argv            = argv
+      @default_options = default_options
+    end
 
-        opts.on("--command COMMAND", "The command to start") do |command|
-          options[:command] = command
-        end
+    def run
+      command = argv[0]
+      case command
+      when nil, "-h", "--help", "help"
+        help
+        exit
+      when "-v", "--version"
+        puts "Daemonic version #{Daemonic::VERSION}"
+        exit
+      when "start"
+        start
+      when "stop"
+        stop
+      when "status"
+        status
+      when "restart"
+        restart
+      else
+        puts "Unknown command #{command.inspect}."
+        help
+        exit 1
+      end
+    end
 
-        opts.on("--[no-]daemonize", "Start process in background") do |daemonize|
-          options[:daemonize] = daemonize
-        end
+    def help
+      info <<-USAGE
 
-        opts.on("--workers NUM", Integer, "Amount of workers (default: 1)") do |workers|
-          options[:workers] = workers
-        end
+        Usage: #{program} COMMAND OPTIONS
 
-        opts.on("--pid FILENAME", "Location of pid files") do |pidfile|
-          options[:pidfile] = pidfile
-        end
+        Available commands:
+        * start              Start the daemon
+        * stop               Stops the daemon
+        * restart            Stops and starts a daemonized process
+        * status             Shows the status
 
-        opts.on("--working-dir DIRECTORY", "Specify the working directory") do |dir|
-          options[:working_dir] = dir
-        end
+        To get more information about each command, run the command with --help.
+
+        Example: #{program} start --help
+
+      USAGE
+    end
+
+    def start
+      options = parse "start", log: STDOUT, concurrency: 2, daemonize: false, startup_timeout: 1
+      [ :start, options ]
+    end
+
+    def stop
+      options = parse "stop", stop_timeout: 5
+      [ :stop, options ]
+    end
+
+    def status
+      options = parse "status"
+      [ :status, options ]
+    end
+
+    def restart
+      options = parse "restart", log: STDOUT, concurrency: 2, stop_timeout: 5, startup_timeout: 1
+      [ :restart, options ]
+    end
 
-        opts.on("--name NAME", "Name of the server") do |name|
-          options[:program_name] = name
+    private
+
+    def program
+      $PROGRAM_NAME
+    end
+
+    def info(text)
+      puts text.gsub(/^ */, '')
+    end
+
+    def parse(command, options = {})
+
+      optparser = OptionParser.new { |parser|
+
+        parser.banner = "Usage: #{program} #{command} OPTIONS"
+
+        parser.separator ""
+        parser.separator "Process options:"
+
+        parser.on "-P", "--pid LOCATION", "Where the pid file is stored (required for daemonized processes)" do |pid|
+          options[:pid] = pid
         end
 
-        opts.on("--log FILENAME", "Send daemon_of_the_fall output to a file") do |logfile|
-          options[:logfile] = logfile
+        if options.has_key?(:daemonize)
+          parser.on "-d", "--[no-]daemonize", "Should the process be daemonized" do |daemonize|
+            options[:daemonize] = daemonize
+          end
         end
 
-        opts.on("--loglevel LEVEL", [:debug, :info, :warn, :fatal], "Set the log level (default: info)") do |level|
-          options[:loglevel] = level
+        if options.has_key?(:concurrency)
+          parser.on "-c", "--concurrency NUMBER", Integer, "How many consumer threads to spawn (default: #{options[:concurrency]})" do |concurrency|
+            if concurrency < 1
+              puts "Concurrency cannot be smaller than 1."
+              exit 1
+            end
+            options[:concurrency] = concurrency
+          end
         end
 
-        opts.on("--config FILENAME", "Read settings from a file") do |config_file|
-          options[:config_file] = config_file
+
+        if options.has_key?(:startup_timeout)
+          parser.on "--startup-timeout TIMEOUT", Integer, "How many seconds to wait for the process to start (default: #{options[:startup_timeout]})" do |timeout|
+            if timeout < 1
+              puts "Timeout cannot be smaller than 1."
+              exit 1
+            end
+            options[:startup_timeout] = timeout
+          end
         end
 
-        opts.on_tail("--version", "Shows the version") do
-          require "daemonic/version"
-          puts "#{$0}: version #{Daemonic::VERSION}"
-          exit 0
+        if options.has_key?(:stop_timeout)
+          parser.on "--stop-timeout TIMEOUT", Integer, "How many seconds to wait for the process to stop (default: #{options[:stop_timeout]})" do |timeout|
+            if timeout < 1
+              puts "Timeout cannot be smaller than 1."
+              exit 1
+            end
+            options[:stop_timeout] = timeout
+          end
         end
 
-        opts.on_tail("--help", "You're watching it") do
-          puts opts
-          exit 0
+        if options.has_key?(:log)
+
+          parser.separator ""
+          parser.separator "Logging options:"
+
+          parser.on "--log FILE", "Where to write the log to" do |log|
+            options[:log] = log
+          end
+
+          parser.on "--verbose", "Sets the log level to debug" do
+            options[:log_level] = Logger::DEBUG
+          end
+
+          parser.on "--log-level LEVEL", %w(debug info warn fatal), "Set the log level (default: info)" do |level|
+            options[:log_level] = Logger.const_get(level.upcase)
+          end
+
         end
 
-      end
+        parser.separator ""
+        parser.separator "Common options:"
+
+        parser.on_tail("-h", "--help", "Show this message") do
+          puts parser
+          exit
+        end
 
-      parser.parse!(args.dup)
+      }
 
-      options
+      begin
+        optparser.parse!(argv)
+        default_options.merge(options)
+      rescue OptionParser::InvalidOption, OptionParser::InvalidArgument => error
+        puts error
+        puts optparser
+        exit 1
+      end
     end
 
   end

data/lib/daemonic/daemon.rb

@@ -0,0 +1,126 @@
+module Daemonic
+  class Daemon
+
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def start(&block)
+      fail ArgumentError, "No block given" if block.nil?
+      if options[:daemonize]
+        ensure_pid_specified
+        fork do
+          at_exit { cleanup_pid_file }
+          Process.daemon(true)
+          write_pid_file
+          block.call
+        end
+        sleep 0.1
+        wait_until(options.fetch(:startup_timeout) { 1 }) { !running? }
+        if running?
+          puts "The daemon started successfully"
+        else
+          puts "The daemon did not start properly"
+          exit 1
+        end
+      else
+        at_exit { cleanup_pid_file }
+        write_pid_file
+        block.call
+      end
+    end
+
+    def status
+      ensure_pid_specified
+      if running?
+        puts "Running with pid: #{pid.inspect}"
+        exit 0
+      else
+        puts "Not running. Pid: #{pid.inspect}"
+        exit 2
+      end
+    end
+
+    def stop
+      ensure_pid_specified
+      puts "Stopping"
+      if running?
+        Process.kill("TERM", pid)
+        wait_until(options.fetch(:stop_timeout) { 5 }) { !running? }
+        if running?
+          puts "Couldn't shut down. Pid: #{pid}"
+          exit 1
+        else
+          puts "Worker shut down."
+        end
+      else
+        puts "Not running. Pid: #{pid.inspect}"
+        exit 1
+      end
+    end
+
+    def restart(&block)
+      ensure_pid_specified
+      if running?
+        stop
+        start(&block)
+      else
+        puts "Not running. Starting a new worker."
+        cleanup_pid_file
+        start(&block)
+      end
+    end
+
+    private
+
+    def running?
+      return false unless pid
+      Process.getpgid(pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+
+    def pid
+      File.exist?(pid_file) && Integer(File.read(pid_file).strip)
+    end
+
+    def cleanup_pid_file
+      File.unlink(pid_file) if pid_file
+    end
+
+    def write_pid_file
+      if pid_file
+        FileUtils.mkdir_p(File.dirname(pid_file))
+        File.open(pid_file, "w") { |f| f.puts Process.pid }
+      end
+    end
+
+    def pid_file
+      options[:pid]
+    end
+
+    def wait_until(timeout, &condition)
+      sleep 0.1
+      Timeout.timeout(timeout) do
+        until condition.call
+          print "."
+          sleep 0.1
+        end
+      end
+      print "\n"
+    rescue Timeout::Error
+      print "\n"
+    end
+
+    def ensure_pid_specified
+      unless pid_file
+        puts "No location of PID specified."
+        exit 1
+      end
+    end
+
+  end
+end

data/lib/daemonic/pool.rb

@@ -1,104 +1,65 @@
-require 'daemonic/logging'
-require 'daemonic/worker'
-
+# Stolen from RubyTapas by Avdi Grimm, episode 145.
 module Daemonic
   class Pool
-    include Logging
-
-    attr_reader :config
 
-    attr_reader :workers, :desired_workers
-
-    def initialize(config)
-      @config = config
-      @workers = []
-      reload_desired_workers
-    end
+    class StopSignal
 
-    def start
-      wait_for global_timeout do
-        increase if count < desired_workers
-        count == desired_workers
+      def inspect
+        "[STOP SIGNAL]"
       end
-      decrease while count > desired_workers
-    end
+      alias_method :to_s, :inspect
 
-    def restart
-      workers.each do |worker|
-        worker.restart
-        yield worker if block_given?
-      end
     end
 
-    def stop
-      workers.each do |worker|
-        worker.stop
-        yield worker if block_given?
-      end
-    end
-
-    def hup
-      reload_desired_workers
-      workers.each(&:hup)
-      start
-    end
-
-    def count
-      workers.count { |worker| worker.running? }
-    end
-
-    def increase
-      workers << start_worker(workers.size)
-    end
+    STOP_SIGNAL = StopSignal.new
 
-    def increase!
-      @desired_workers += 1
-      increase
-    end
-
-    def decrease
-      workers.pop.stop
+    def initialize(thread_count, worker, logger)
+      @worker  = worker
+      @jobs    = SizedQueue.new(thread_count)
+      @logger  = logger
+      @threads = thread_count.times.map {|worker_num|
+        Thread.new do
+          dispatch(worker_num)
+        end
+      }
     end
 
-    def decrease!
-      @desired_workers -= 1
-      decrease
+    def enqueue(job)
+      @logger.debug { "Enqueueing #{job.inspect}" }
+      @jobs.push(job)
     end
+    alias_method :<<, :enqueue
 
-    def monitor
-      workers.each(&:monitor)
+    def stop
+      @threads.size.times do
+        enqueue(STOP_SIGNAL)
+      end
+      @threads.each(&:join)
     end
 
     private
 
-    def start_worker(num)
-      Worker.new(
-        index:  num,
-        config: config,
-      ).tap(&:start)
-    end
-
-    def reload_desired_workers
-      @desired_workers = config.workers
-    end
-
-    def global_timeout
-      (desired_workers * 2) + 1
-    end
-
-    def wait_for(timeout=2)
-      deadline = Time.now + timeout
-      until Time.now >= deadline
-        result = yield
-        if result
-          return
-        else
-          sleep 0.1
+    def dispatch(worker_num)
+      @logger.debug { "T#{worker_num}: Starting" }
+      loop do
+        job = @jobs.pop
+        if STOP_SIGNAL.equal?(job)
+          @logger.debug { "T#{worker_num}: Received stop signal, terminating." }
+          break
+        end
+        begin
+          @logger.debug { "T#{worker_num}: Consuming #{job.inspect}" }
+          @worker.consume(job)
+          Thread.pass
+        rescue Object => error
+          @logger.warn { "T#{worker_num}: Error while processing #{job}: #{error.class}: #{error}" }
+          @logger.info { error.backtrace.join("\n") }
+          Thread.pass
         end
       end
-      fatal "Unable to get to boot the right amount of workers. Running: #{count}, desired: #{desired_workers}."
-      stop
-      exit 1
+      @logger.debug { "T#{worker_num}: Stopped" }
     end
+
+
   end
 end