rack-rabbit 0.5.0

data/lib/rack-rabbit/handler.rb

@@ -0,0 +1,44 @@
+require 'rack-rabbit/response'
+
+module RackRabbit
+  class Handler
+
+    #--------------------------------------------------------------------------
+
+    attr_reader :app, :config, :logger
+
+    #--------------------------------------------------------------------------
+
+    def initialize(app, config)
+      @app    = app
+      @config = config
+      @logger = config.logger
+    end
+
+    #--------------------------------------------------------------------------
+
+    def handle(message)
+
+      env = message.get_rack_env(config.rack_env)
+
+      status, headers, body_chunks = app.call(env)
+
+      body = []
+      body_chunks.each{|c| body << c }
+      body_chunks.close if body_chunks.respond_to?(:close)
+
+      Response.new(status, headers, body.join)
+
+    rescue Exception => e    # don't let exceptions bubble out of worker process
+
+      logger.error e
+      logger.error e.backtrace.join("\n")
+
+      Response.new(500, {}, "Internal Server Error")
+
+    end
+
+    #--------------------------------------------------------------------------
+
+  end # class Handler
+end # module RackRabbit

data/lib/rack-rabbit/message.rb

@@ -0,0 +1,95 @@
+require 'stringio'
+
+module RackRabbit
+  class Message
+
+    #--------------------------------------------------------------------------
+
+    attr_reader :delivery_tag, :reply_to, :correlation_id,
+                :body, :headers,
+                :method, :uri, :path, :query, :status,
+                :content_type, :content_encoding, :content_length,
+                :rabbit
+
+    def initialize(delivery_tag, properties, body, rabbit)
+      @delivery_tag       = delivery_tag
+      @reply_to           = properties.reply_to
+      @correlation_id     = properties.correlation_id
+      @body               = body
+      @headers            = properties.headers || {}
+      @method             = headers.delete(RackRabbit::HEADER::METHOD) || :GET
+      @uri                = headers.delete(RackRabbit::HEADER::PATH)   || ""
+      @status             = headers.delete(RackRabbit::HEADER::STATUS)
+      @path, @query       = uri.split(/\?/)
+      @content_type       = properties.content_type
+      @content_encoding   = properties.content_encoding
+      @content_length     = body.nil? ? 0 : body.length
+      @rabbit             = rabbit
+    end
+
+    #--------------------------------------------------------------------------
+
+    def get_rack_env(defaults = {})
+
+      defaults.merge({
+        'rabbit.message' => self,
+        'rack.input'     => StringIO.new(body || ""),
+        'REQUEST_METHOD' => method,
+        'REQUEST_PATH'   => uri,
+        'PATH_INFO'      => path,
+        'QUERY_STRING'   => query,
+        'CONTENT_TYPE'   => "#{content_type || 'text/plain'}; charset=\"#{content_encoding || 'utf-8'}\"",
+        'CONTENT_LENGTH' => content_length
+      }).merge(headers)
+    
+    end
+
+    #--------------------------------------------------------------------------
+
+    def should_reply?
+      !reply_to.nil?
+    end
+
+    def get_reply_properties(response, config)
+      return {
+        :app_id           => config.app_id,
+        :routing_key      => reply_to,
+        :correlation_id   => correlation_id,
+        :timestamp        => Time.now.to_i,
+        :headers          => response.headers.merge(RackRabbit::HEADER::STATUS => response.status),
+        :content_type     => response.headers[RackRabbit::HEADER::CONTENT_TYPE],
+        :content_encoding => response.headers[RackRabbit::HEADER::CONTENT_ENCODING]
+      }
+    end
+
+    #--------------------------------------------------------------------------
+
+    def ack
+      raise RuntimeError, "already acknowledged" if acknowledged?
+      raise RuntimeError, "already rejected"     if rejected?
+      @acknowledged = true
+      rabbit.ack(delivery_tag)
+    end
+
+    def reject
+      raise RuntimeError, "already acknowledged" if acknowledged?
+      raise RuntimeError, "already rejected"     if rejected?
+      @rejected = true
+      rabbit.reject(delivery_tag)
+    end
+
+    def acknowledged?
+      @acknowledged == true
+    end
+
+    def rejected?
+      @rejected == true
+    end
+
+    #--------------------------------------------------------------------------
+
+  end
+end
+
+
+  

data/lib/rack-rabbit/middleware/program_name.rb

@@ -0,0 +1,34 @@
+module RackRabbit
+  module Middleware
+    class ProgramName
+
+      def initialize(app, default = "waiting for request")
+        @app = app
+        @default = default
+        set_program_name(default)
+      end
+
+      def call(env)
+        info = "#{env['REQUEST_METHOD']} #{env['REQUEST_PATH'] || env['PATH_INFO']}"
+        set_program_name info
+        status, headers, body = @app.call(env)
+        set_program_name @default
+        [status, headers, body]
+      end
+
+      def set_program_name(name)
+        $PROGRAM_NAME = sanitize($PROGRAM_NAME.split(" -- ")[0] + " -- #{name}")[0..200]
+      end
+
+      def sanitize(value)
+        if value.valid_encoding?
+          value.force_encoding('utf-8')
+        else
+          value.chars.select(&:valid_encoding?).join.force_encoding('utf-8')
+        end
+      end
+
+    end # class ProgramName
+  end # module Middleware
+end # module RackRabbit
+

data/lib/rack-rabbit/response.rb

@@ -0,0 +1,43 @@
+module RackRabbit
+  class Response
+
+    #--------------------------------------------------------------------------
+
+    attr_reader :status, :headers, :body
+
+    def initialize(status, headers, body)
+      @status  = status
+      @headers = headers
+      @body    = body
+    end
+
+    #--------------------------------------------------------------------------
+
+    def succeeded?
+      (200..299).include?(status)
+    end
+
+    def failed?
+      !succeeded?
+    end
+
+    #--------------------------------------------------------------------------
+
+    def to_s
+      if succeeded?
+        body
+      else
+        case status
+        when RackRabbit::STATUS::BAD_REQUEST then "#{status} Bad Request"
+        when RackRabbit::STATUS::NOT_FOUND   then "#{status} Not Found"
+        when RackRabbit::STATUS::FAILED      then "#{status} Internal Server Error"
+        else
+          status.to_s
+        end
+      end
+    end
+
+    #--------------------------------------------------------------------------
+
+  end
+end

data/lib/rack-rabbit/server.rb

@@ -0,0 +1,263 @@
+require 'rack/builder'
+require 'rack/server'
+
+require 'rack-rabbit'
+require 'rack-rabbit/config'
+require 'rack-rabbit/signals'
+require 'rack-rabbit/worker'
+require 'rack-rabbit/middleware/program_name'
+
+module RackRabbit
+  class Server
+
+    #--------------------------------------------------------------------------
+
+    attr_reader :app,
+                :config,
+                :logger,
+                :server_pid,
+                :worker_pids,
+                :killed_pids,
+                :signals
+
+    def initialize(options)
+      @config       = Config.new(options)
+      @logger       = config.logger
+      @server_pid   = $$
+      @worker_pids  = []
+      @killed_pids  = []
+      @signals      = Signals.new
+    end
+
+    #--------------------------------------------------------------------------
+
+    def run
+
+      check_pid
+
+      if config.daemonize
+        daemonize
+      elsif config.logfile
+        redirect_output
+      end
+
+      write_pid
+
+      logger.info "RUNNING #{config.app_id} (#{config.rack_file}) #{'DAEMONIZED' if config.daemonize}"
+      logger.info "  rabbit   : #{config.rabbit}"
+      logger.info "  exchange : #{config.exchange} (#{config.exchange_type})" if config.exchange
+      logger.info "  queue    : #{config.queue}"                              if config.queue
+      logger.info "  route    : #{config.routing_key}"                        if config.routing_key
+      logger.info "  workers  : #{config.workers}"
+      logger.info "  preload  : true"              if config.preload_app
+      logger.info "  logfile  : #{config.logfile}" unless config.logfile.nil?
+      logger.info "  pidfile  : #{config.pidfile}" unless config.pidfile.nil?
+
+      load_app if config.preload_app
+
+      trap_server_signals
+      manage_workers
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def manage_workers
+      while true
+
+        maintain_worker_count
+
+        sig = signals.pop   # BLOCKS until there is a signal
+        case sig
+
+        when :INT  then shutdown(:INT)
+        when :QUIT then shutdown(:QUIT)
+        when :TERM then shutdown(:TERM)
+
+        when :HUP
+          reload
+
+        when :CHLD
+          reap_workers
+
+        when :TTIN
+          config.workers [config.max_workers, config.workers + 1].min
+
+        when :TTOU
+          config.workers [config.min_workers, config.workers - 1].max
+
+        else
+          raise RuntimeError, "unknown signal #{sig}"
+
+        end
+
+      end
+    end
+
+    #--------------------------------------------------------------------------
+
+    def reload
+      logger.info "RELOADING"
+      config.reload
+      load_app if config.preload_app
+      kill_all_workers(:QUIT)  # they will respawn automatically
+    end
+
+    def maintain_worker_count
+      unless shutting_down?
+        diff = worker_pids.length - config.workers
+        if diff > 0
+          diff.times { kill_random_worker(:QUIT) }
+        elsif diff < 0
+          (-diff).times { spawn_worker }
+        end
+      end
+    end
+
+    def spawn_worker
+      config.before_fork(self)
+      worker_pids << fork do
+        signals.close
+        load_app unless config.preload_app
+        worker = Worker.new(config, app)
+        config.after_fork(self, worker)
+        worker.run
+      end
+    end
+
+    def kill_random_worker(sig)
+      kill_worker(sig, worker_pids.sample) # choose a random wpid
+    end
+
+    def kill_all_workers(sig)
+      kill_worker(sig, worker_pids.last) until worker_pids.empty?
+    end
+
+    def kill_worker(sig, wpid)
+      worker_pids.delete(wpid)
+      killed_pids.push(wpid)
+      Process.kill(sig, wpid)
+    end
+
+    def reap_workers
+      while true
+        wpid = Process.waitpid(-1, Process::WNOHANG)
+        return if wpid.nil?
+        worker_pids.delete(wpid)
+        killed_pids.delete(wpid)
+      end
+      rescue Errno::ECHILD
+    end
+
+    #--------------------------------------------------------------------------
+
+    def shutdown(sig)
+      @shutting_down = true
+      kill_all_workers(sig)
+      Process.waitall
+      logger.info "#{RackRabbit.friendly_signal(sig)} server"
+      exit
+    end
+
+    def shutting_down?
+      @shutting_down
+    end
+
+    #==========================================================================
+    # DAEMONIZING, PID MANAGEMENT, and OUTPUT REDIRECTION
+    #==========================================================================
+
+    def daemonize
+      exit if fork
+      Process.setsid
+      exit if fork
+      Dir.chdir "/"
+      redirect_output
+      logger.master_pid = $$ if logger.respond_to?(:master_pid)  # inform logger of new master_pid so it can continue to distinguish between "SERVER" and "worker" in log preamble
+    end
+
+    def redirect_output
+      if logfile = config.logfile
+        logfile = File.expand_path(logfile)
+        FileUtils.mkdir_p(File.dirname(logfile), :mode => 0755)
+        FileUtils.touch logfile
+        File.chmod(0644, logfile)
+        $stderr.reopen(logfile, 'a')
+        $stdout.reopen($stderr)
+        $stdout.sync = $stderr.sync = true
+      else
+        $stderr.reopen('/dev/null', 'a')
+        $stdout.reopen($stderr)
+      end
+    end
+
+    def write_pid
+      pidfile = config.pidfile
+      if pidfile
+        begin
+          File.open(pidfile, ::File::CREAT | ::File::EXCL | ::File::WRONLY){|f| f.write("#{Process.pid}") }
+          at_exit { File.delete(pidfile) if File.exists?(pidfile) }
+        rescue Errno::EEXIST
+          check_pid
+          retry
+        end
+      end
+    end
+
+    def check_pid
+      pidfile = config.pidfile
+      if pidfile
+        case pid_status(pidfile)
+        when :running, :not_owned
+          logger.fatal "A server is already running. Check #{pidfile}"
+          exit(1)
+        when :dead
+          File.delete(pidfile)
+        end
+      end
+    end
+
+    def pid_status(pidfile)
+      return :exited unless File.exists?(pidfile)
+      pid = ::File.read(pidfile).to_i
+      return :dead if pid == 0
+      Process.kill(0, pid)
+      :running
+    rescue Errno::ESRCH
+      :dead
+    rescue Errno::EPERM
+      :not_owned
+    end
+
+    #==========================================================================
+    # SIGNAL HANDLING
+    #==========================================================================
+
+    def trap_server_signals
+
+      [:HUP, :INT, :QUIT, :TERM, :CHLD, :TTIN, :TTOU].each do |sig|
+        trap(sig) do
+          signals.push(sig)
+        end
+      end
+
+    end
+
+    #==========================================================================
+    # RACK APP HANDLING
+    #==========================================================================
+
+    def load_app
+      inner_app, options = Rack::Builder.parse_file(config.rack_file)
+      @app = Rack::Builder.new do
+        use RackRabbit::Middleware::ProgramName
+        run inner_app
+      end.to_app
+      logger.info "LOADED #{inner_app.name if inner_app.respond_to?(:name)} FROM #{config.rack_file}"
+      @app
+    end
+
+    #--------------------------------------------------------------------------
+
+  end
+end