starling 0.9.3 → 0.9.8

data/lib/starling/persistent_queue.rb

@@ -1,9 +1,3 @@
-if RUBY_VERSION >= "1.8.6"
-  require 'thread'
-else
-  require 'fastthread'
-end
-
 module StarlingServer
 
   ##
@@ -28,19 +22,20 @@ module StarlingServer
     attr_reader :initial_bytes
     attr_reader :total_items
     attr_reader :logsize
+    attr_reader :current_age
 
     ##
     # Create a new PersistentQueue at +persistence_path+/+queue_name+.
     # If a queue log exists at that path, the Queue will be loaded from
     # disk before being available for use.
-    
+
     def initialize(persistence_path, queue_name, debug = false)
       @persistence_path = persistence_path
       @queue_name = queue_name
-      @transaction_mutex = Mutex.new
       @total_items = 0
       super()
       @initial_bytes = replay_transaction_log(debug)
+      @current_age = 0
     end
 
     ##
@@ -55,31 +50,30 @@ module StarlingServer
       end
 
       @total_items += 1
-      super(value)
+      super([now_usec, value])
     end
 
     ##
     # Retrieves data from the queue.
-    
+
     def pop(log_trx = true)
       raise NoTransactionLog if log_trx && !@trx
-      
+
       begin
         rv = super(!log_trx)
       rescue ThreadError
         puts "WARNING: The queue was empty when trying to pop(). Technically this shouldn't ever happen. Probably a bug in the transactional underpinnings. Or maybe shutdown didn't happen cleanly at some point. Ignoring."
-        rv = ''
+        rv = [now_usec, '']
       end
       transaction "\001" if log_trx
-      rv
+      @current_age = (now_usec - rv[0]) / 1000
+      rv[1]
     end
 
     ##
     # Safely closes the transactional queue.
-    
-    def close
-      @transaction_mutex.lock
 
+    def close
       # Ok, yeah, this is lame, and is *technically* a race condition. HOWEVER,
       # the QueueCollection *should* have stopped processing requests, and I don't
       # want to add yet another Mutex around all the push and pop methods. So we
@@ -103,8 +97,10 @@ module StarlingServer
 
     def rotate_log #:nodoc:
       @trx.close
-      File.rename(log_path, "#{log_path}.#{Time.now.to_i}")
+      backup_logfile = "#{log_path}.#{Time.now.to_i}"
+      File.rename(log_path, backup_logfile)
       reopen_log
+      File.unlink(backup_logfile)
     end
 
     def replay_transaction_log(debug) #:nodoc:
@@ -142,15 +138,14 @@ module StarlingServer
     def transaction(data) #:nodoc:
       raise "no transaction log handle. that totally sucks." unless @trx
 
-      begin
-        @transaction_mutex.lock
-        @trx.write data
-        @trx.fsync
-        @logsize += data.size
-        rotate_log if @logsize > SOFT_LOG_MAX_SIZE && self.length == 0
-      ensure
-        @transaction_mutex.unlock
-      end
+      @trx.write_nonblock data
+      @logsize += data.size
+      rotate_log if @logsize > SOFT_LOG_MAX_SIZE && self.length == 0
+    end
+    
+    def now_usec
+      now = Time.now
+      now.to_i * 1000000 + now.usec
     end
   end
 end

data/lib/starling/queue_collection.rb

@@ -7,20 +7,21 @@ module StarlingServer
 
   ##
   # QueueCollection is a proxy to a collection of PersistentQueue instances.
-  
+
   class QueueCollection
 
     ##
     # Create a new QueueCollection at +path+
-    
+
     def initialize(path)
       unless File.directory?(path) && File.writable?(path)
-        raise InaccessibleQueuePath.new(path)
+        raise InaccessibleQueuePath.new("'#{path}' must exist and be read-writable by #{Etc.getpwuid(Process.uid).name}.")
       end
 
       @shutdown_mutex = Mutex.new
 
       @path = path
+      @logger = StarlingServer::Base.logger
 
       @queues = {}
       @queue_init_mutexes = {}
@@ -39,7 +40,7 @@ module StarlingServer
       @stats[:total_items] += 1
 
       queue.push(data)
-      
+
       return true
     end
 
@@ -60,7 +61,7 @@ module StarlingServer
     end
 
     ##
-    # Returns all active queues. 
+    # Returns all active queues.
 
     def queues(key=nil)
       return nil if @shutdown_mutex.locked?

data/lib/starling/server.rb

@@ -1,5 +1,8 @@
 require 'socket'
 require 'logger'
+require 'rubygems'
+require 'eventmachine'
+require 'analyzer_tools/syslog_logger'
 
 here = File.dirname(__FILE__)
 
@@ -8,13 +11,9 @@ require File.join(here, 'handler')
 
 module StarlingServer
 
-  VERSION = "0.9.3"
-
-  class StopServer < Exception #:nodoc:
-  end
-
+  VERSION = "0.9.8"
+  
   class Base
-
     attr_reader :logger
 
     DEFAULT_HOST    = '127.0.0.1'
@@ -36,11 +35,10 @@ module StarlingServer
     #   [:loglevel] Logger verbosity. Default is Logger::ERROR.
     #
     # Other options are ignored.
-    
+
     def self.start(opts = {})
       server = self.new(opts)
-      acceptor = server.run
-      [server, acceptor]
+      server.run
     end
 
     ##
@@ -48,32 +46,20 @@ module StarlingServer
     # process requests.
     #
     # +opts+ is as for +start+
-    
-    def initialize(opts = {})
-      @opts = { :host    => DEFAULT_HOST,
-                :port    => DEFAULT_PORT,
-                :path    => DEFAULT_PATH,
-                :timeout => DEFAULT_TIMEOUT }.merge(opts)
-
-      @logger = case @opts[:logger]
-      when IO, String; Logger.new(opts[:logger])
-      when Logger; opts[:logger]
-      else; Logger.new(STDERR)
-      end
-
-      @logger.level = @opts[:log_level] || Logger::ERROR
 
-      @timeout = @opts[:timeout]
-
-      @socket = TCPServer.new(@opts[:host], @opts[:port])
-      @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+    def initialize(opts = {})
+      @opts = {
+        :host    => DEFAULT_HOST,
+        :port    => DEFAULT_PORT,
+        :path    => DEFAULT_PATH,
+        :timeout => DEFAULT_TIMEOUT,
+        :server  => self
+      }.merge(opts)
 
-      @queue_collection = QueueCollection.new(@opts[:path])
+      @stats = Hash.new(0)
 
-      @workers = ThreadGroup.new
+      FileUtils.mkdir_p(@opts[:path])
 
-      @stats = Hash.new(0)
     end
 
     ##
@@ -82,127 +68,51 @@ module StarlingServer
     def run
       @stats[:start_time] = Time.now
 
-      BasicSocket.do_not_reverse_lookup = true
-
-      @acceptor = Thread.new do
-        loop do
-          begin
-            accept_connection
-          rescue StopServer
-            @socket.close rescue Object
-            break
-          rescue Errno::EMFILE
-            cull_workers("Too many open files or sockets")
-            sleep @timeout / 100
-          rescue Errno::ECONNABORTED
-            begin
-              client.close
-            rescue Object => e
-              logger.warn "Got exception closing socket (client aborted connection) #{e}"
-            end
-          rescue Object => e
-            logger.fatal "Unhandled exception: #{e}.  TELL BLAINE HE'S A MORON."
-            logger.debug e.backtrace.join("\n")
-          end
-        end
-
-        graceful_shutdown
+      @@logger = case @opts[:logger]
+                 when IO, String; Logger.new(@opts[:logger])
+                 when Logger; @opts[:logger]
+                 else; Logger.new(STDERR)
+                 end
+      @@logger = SyslogLogger.new(@opts[:syslog_channel]) if @opts[:syslog_channel]
+
+      begin
+        @opts[:queue] = QueueCollection.new(@opts[:path])
+      rescue InaccessibleQueuePath => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+      @@logger.level = @opts[:log_level] || Logger::ERROR
+
+      @@logger.info "Starling STARTUP on #{@opts[:host]}:#{@opts[:port]}"
+
+      EventMachine.epoll
+      EventMachine.set_descriptor_table_size(4096)
+      EventMachine.run do
+        EventMachine.start_server(@opts[:host], @opts[:port], Handler, @opts)
       end
 
-      return @acceptor
+      # code here will get executed on shutdown:
+      @opts[:queue].close
     end
 
+    def self.logger
+      @@logger
+    end
+
+
     ##
     # Stop accepting new connections and shutdown gracefully.
 
     def stop
-      stopper = Thread.new { @acceptor.raise(StopServer.new) }
-      stopper.priority = Thread.current.priority + 10
+      EventMachine.stop_event_loop
     end
 
     def stats(stat = nil) #:nodoc:
       case stat
       when nil; @stats
-      when :connections; @workers.list.length
+      when :connections; 1
       else; @stats[stat]
       end
     end
-
-    private
-
-    def accept_connection #:nodoc:
-      client = @socket.accept
-
-      @stats[:total_connections] += 1
-
-      thread = Thread.new(client) { |c| spawn_handler(c) }
-      thread[:last_activity] = Time.now
-      @workers.add(thread)
-    end
-
-    def spawn_handler(client) #:nodoc:
-      begin
-        queue_handler = Handler.new(client, self, @queue_collection)
-        queue_handler.run
-      rescue EOFError, Errno::EBADF, Errno::ECONNRESET, Errno::EINVAL, Errno::EPIPE
-        begin
-          client.close
-        rescue Object => e
-          logger.warn "Got exception while closing socket after connection error: #{e}"
-          logger.debug e.backtrace.join("\n")
-        end
-      rescue TimeoutError => reason
-        begin
-          logger.info "Shutdown due to timeout: #{reason.message}"
-          client.close
-        rescue Object => e
-          logger.warn "Got exception while closing socket after timeout: #{e}"
-          logger.debug e.backtrace.join("\n")
-        end
-      rescue Errno::EMFILE
-        cull_workers('Too many open files or sockets')
-      rescue Object => e
-        logger.error("Unknown error: #{e}")
-        logger.debug(e.backtrace.join("\n"))
-      ensure
-        begin
-          client.close
-        rescue Object => e
-          logger.info "Got exception while closing socket: #{e}"
-          logger.debug e.backtrace.join("\n")
-        end
-      end
-    end
-
-    def cull_workers(reason='unknown') #:nodoc:
-      if @workers.list.length > 0
-        logger.info "#{Time.now}: Reaping #{@workers.list.length} threads because of #{reason}"
-        error_msg = "Starling timed out this thread: #{reason}"
-        mark = Time.now
-        @workers.list.each do |w|
-          w[:last_activity] = Time.now if not w[:last_activity]
-
-          if mark - w[:last_activity] > @timeout
-            logger.warn "Thread #{w.inspect} has been idle for #{mark - w[:last_activity]}s, killing."
-            w.raise(TimeoutError.new(error_msg))
-          end
-        end
-      end
-
-      return @workers.list.length
-    end
-
-    def graceful_shutdown #:nodoc:
-      @workers.list.each do |w|
-        w[:shutdown] = true
-      end
-
-      @queue_collection.close
-
-      while cull_workers("shutdown") > 0
-        logger.info "Waiting for #{@workers.list.length} requests to finish, could take #{@timeout} seconds."
-        sleep 0.5
-      end
-    end
   end
 end

data/lib/starling/{runner.rb → server_runner.rb}

@@ -1,5 +1,6 @@
 require File.join(File.dirname(__FILE__), 'server')
 require 'optparse'
+require 'yaml'
 
 module StarlingServer
   class Runner
@@ -10,11 +11,16 @@ module StarlingServer
     def self.run
       new
     end
-   
+    
+    def self.shutdown
+      @@instance.shutdown
+    end
+
     def initialize
+      @@instance = self
       parse_options
 
-      @process = ProcessHelper.new(options[:log_file], options[:pid_file], options[:user], options[:group])
+      @process = ProcessHelper.new(options[:logger], options[:pid_file], options[:user], options[:group])
 
       pid = @process.running?
       if pid
@@ -27,29 +33,50 @@ module StarlingServer
       start
     end
 
+    def load_config_file(filename)
+      YAML.load(File.open(filename))['starling'].each do |key, value|
+        # alias some keys
+        case key
+        when "queue_path" then key = "path"
+        when "log_file" then key = "logger"
+        end
+        options[key.to_sym] = value
+
+        if options[:log_level].instance_of?(String)
+          options[:log_level] = Logger.const_get(options[:log_level])
+        end
+      end
+    end
+
     def parse_options
       self.options = { :host => '127.0.0.1',
                        :port => 22122,
-                       :path => File.join(%w( / var spool starling )),
-                       :log_level => 0,
+                       :path => File.join('', 'var', 'spool', 'starling'),
+                       :log_level => Logger::INFO,
                        :daemonize => false,
-                       :pid_file => File.join(%w( / var run starling.pid )) }
+                       :timeout => 0,
+                       :pid_file => File.join('', 'var', 'run', 'starling.pid') }
 
       OptionParser.new do |opts|
         opts.summary_width = 25
 
         opts.banner = "Starling (#{StarlingServer::VERSION})\n\n",
-                      "usage: starling [-v] [-q path] [-h host] [-p port]\n",
-                      "                [-d [-P pidfile]] [-u user] [-g group] [-l log]\n",
+                      "usage: starling [options...]\n",
                       "       starling --help\n",
                       "       starling --version\n"
 
         opts.separator ""
         opts.separator "Configuration:"
+
+        opts.on("-f", "--config FILENAME",
+                "Config file (yaml) to load") do |filename|
+          load_config_file(filename)
+        end
+
         opts.on("-q", "--queue_path PATH",
                 :REQUIRED,
                 "Path to store Starling queue logs", "(default: #{options[:path]})") do |queue_path|
-          options[:path] = queue_path
+          options[:path] = File.expand_path(queue_path)
         end
 
         opts.separator ""; opts.separator "Network:"
@@ -68,26 +95,36 @@ module StarlingServer
           options[:daemonize] = true
         end
 
-        opts.on("-PFILE", "--pid FILE", "save PID in FILE when using -d option.", "(default: #{options[:pid_file]})") do |pid_file|
-          options[:pid_file] = pid_file
+        opts.on("-PFILE", "--pid FILENAME", "save PID in FILENAME when using -d option.", "(default: #{options[:pid_file]})") do |pid_file|
+          options[:pid_file] = File.expand_path(pid_file)
         end
 
-        opts.on("-u", "--user USER", Integer, "User to run as") do |user|
-          options[:user] = user
+        opts.on("-u", "--user USER", "User to run as") do |user|
+          options[:user] = user.to_i == 0 ? Etc.getpwnam(user).uid : user.to_i
         end
 
         opts.on("-gGROUP", "--group GROUP", "Group to run as") do |group|
-          options[:group] = group
+          options[:group] = group.to_i == 0 ? Etc.getgrnam(group).gid : group.to_i
         end
 
         opts.separator ""; opts.separator "Logging:"
 
-        opts.on("-l", "--log [FILE]", "Path to print debugging information.") do |log_path|
-          options[:log] = log_path
+        opts.on("-L", "--log [FILE]", "Path to print debugging information.") do |log_path|
+          options[:logger] = File.expand_path(log_path)
+        end
+
+        opts.on("-l", "--syslog CHANNEL", "Write logs to the syslog instead of a log file.") do |channel|
+          options[:syslog_channel] = channel
+        end
+
+        opts.on("-v", "Increase logging verbosity (may be used multiple times).") do
+          options[:log_level] -= 1
         end
 
-        opts.on("-v", "Increase logging verbosity.") do
-          options[:log_level] += 1
+        opts.on("-t", "--timeout [SECONDS]", Integer,
+                "Time in seconds before disconnecting inactive clients (0 to disable).",
+                "(default: #{options[:timeout]})") do |timeout|
+          options[:timeout] = timeout
         end
 
         opts.separator ""; opts.separator "Miscellaneous:"
@@ -112,21 +149,22 @@ module StarlingServer
       setup_signal_traps
       @process.write_pid_file
 
-      @server, @thread = StarlingServer::Base.start(options)
-      @thread.join
+      STDOUT.puts "Starting at #{options[:host]}:#{options[:port]}."
+      @server = StarlingServer::Base.new(options)
+      @server.run
 
       @process.remove_pid_file
     end
 
     def drop_privileges
-      Process.euid = options[:user] if options[:user]
       Process.egid = options[:group] if options[:group]
+      Process.euid = options[:user] if options[:user]
     end
 
     def shutdown
       begin
         STDOUT.puts "Shutting down."
-        @server.logger.info "Shutting down."
+        StarlingServer::Base.logger.info "Shutting down."
         @server.stop
       rescue Object => e
         STDERR.puts "There was an error shutting down: #{e}"
@@ -178,7 +216,7 @@ module StarlingServer
       safefork and exit
 
       unless sess_id = Process.setsid
-        raise "Couldn't detache from controlling terminal."
+        raise "Couldn't detach from controlling terminal."
       end
 
       trap 'SIGHUP', 'IGNORE'
@@ -196,7 +234,7 @@ module StarlingServer
         end
       end
     end
-    
+
     def redirect_io
       begin; STDIN.reopen('/dev/null'); rescue Exception; end
 
@@ -205,7 +243,7 @@ module StarlingServer
           STDOUT.reopen(@log_file, "a")
           STDOUT.sync = true
         rescue Exception
-          begin; STDOUT.reopen('/dev/null'); rescue Exception; end 
+          begin; STDOUT.reopen('/dev/null'); rescue Exception; end
         end
       else
         begin; STDOUT.reopen('/dev/null'); rescue Exception; end
@@ -224,6 +262,7 @@ module StarlingServer
 
     def write_pid_file
       return unless @pid_file
+      FileUtils.mkdir_p(File.dirname(@pid_file))
       File.open(@pid_file, "w") { |f| f.write(Process.pid) }
       File.chmod(0644, @pid_file)
     end