goliath 0.9.0

data/lib/goliath/response.rb

@@ -0,0 +1,93 @@
+require 'goliath/headers'
+require 'goliath/request'
+require 'goliath/http_status_codes'
+require 'time'
+
+module Goliath
+  # Goliath::Response holds the information that will be sent back
+  # to the client.
+  #
+  # @private
+  class Response
+    # The status code to send
+    attr_accessor :status
+
+    # The headers to send
+    attr_accessor :headers
+
+    # The body to send
+    attr_accessor :body
+
+    SERVER = 'Server'.freeze
+    DATE = 'Date'.freeze
+
+    # Used to signal that a response is a streaming response
+    STREAMING = :goliath_stream_response
+
+    def initialize
+      @headers = Goliath::Headers.new
+      @status = 200
+    end
+
+    # Creates the header line for the response
+    #
+    # @return [String] The HTTP header line
+    def head
+      "HTTP/1.1 #{status} #{HTTP_STATUS_CODES[status.to_i]}\r\n"
+    end
+
+    # Creats the headers to be returned to the client
+    #
+    # @return [String] The HTTP headers
+    def headers_output
+      headers[SERVER] = Goliath::Request::SERVER
+      headers[DATE] = Time.now.httpdate
+
+      "#{headers.to_s}\r\n"
+    end
+
+    # Sets a set of key value pairs into the headers
+    #
+    # @param key_value_pairs [Hash] The key/value pairs to set as headers
+    # @return [Nil]
+    def headers=(key_value_pairs)
+      return unless key_value_pairs
+
+      key_value_pairs.each do |k, vs|
+        next unless vs
+
+        if vs.is_a?(String)
+          vs.each_line { |v| @headers[k] = v.chomp }
+
+        elsif vs.is_a?(Time)
+          @headers[k] = vs
+
+        else
+          vs.each { |v| @headers[k] = v.chomp }
+        end
+      end
+    end
+
+    # Used to signal that the response is closed
+    #
+    # @return [Nil]
+    def close
+      body.close if body.respond_to?(:close)
+    end
+
+    # Yields each portion of the response
+    #
+    # @yield [String] The header line, headers and body content
+    # @return [Nil]
+    def each
+      yield head
+      yield headers_output
+
+      if body.respond_to?(:each)
+        body.each { |chunk| yield chunk }
+      else
+        yield body
+      end
+    end
+  end
+end

data/lib/goliath/runner.rb

@@ -0,0 +1,236 @@
+require 'goliath/goliath'
+require 'goliath/server'
+require 'optparse'
+require 'log4r'
+
+module Goliath
+  # The Goliath::Runner is responsible for parsing any provided options, settting up the
+  # rack application, creating a logger, and then executing the Goliath::Server with the loaded information.
+  class Runner
+    # The address of the server @example 127.0.0.1
+    # @return [String] The server address
+    attr_accessor :address
+
+    # The port of the server @example 9000
+    # @return [Integer] The server port
+    attr_accessor :port
+
+    # Flag to determine if the server should daemonize
+    # @return [Boolean] True if the server should daemonize, false otherwise
+    attr_accessor :daemonize
+
+    # Flag to determine if the server should run in verbose mode
+    # @return [Boolean] True to turn on verbose mode, false otherwise
+    attr_accessor :verbose
+
+    # Flag to determine if the server should log to standard output
+    # @return [Boolean] True if the server should log to stdout, false otherwise
+    attr_accessor :log_stdout
+
+    # The log file for the server
+    # @return [String] The file the server should log too
+    attr_accessor :log_file
+
+    # The pid file for the server
+    # @return [String] The file to write the servers pid file into
+    attr_accessor :pid_file
+
+    # The Rack application
+    # @return [Object] The rack application the server will execute
+    attr_accessor :app
+
+    # The API application
+    # @return [Object] The API application the server will execute
+    attr_accessor :api
+
+    # The plugins the server will execute
+    # @return [Array] The list of plugins to be executed by the server
+    attr_accessor :plugins
+
+    # Any additional server options
+    # @return [Hash] Any options to be passed to the server
+    attr_accessor :app_options
+
+    # The parsed options
+    # @return [Hash] The options parsed by the runner
+    attr_reader :options
+
+    # Create a new Goliath::Runner
+    #
+    # @param argv [Array] The command line arguments
+    # @param api [Object | nil] The Goliath::API this runner is for, can be nil
+    # @return [Goliath::Runner] An initialized Goliath::Runner
+    def initialize(argv, api)
+      api.options_parser(options_parser, options) if api
+      options_parser.parse!(argv)
+
+      @api = api
+      @address = options.delete(:address)
+      @port = options.delete(:port)
+
+      @log_file = options.delete(:log_file)
+      @pid_file = options.delete(:pid_file)
+
+      @log_stdout = options.delete(:log_stdout)
+      @daemonize = options.delete(:daemonize)
+      @verbose = options.delete(:verbose)
+
+      @server_options = options
+    end
+
+    # Create the options parser
+    #
+    # @return [OptionParser] Creates the options parser for the runner with the default options
+    def options_parser
+      @options ||= {
+        :address => Goliath::Server::DEFAULT_ADDRESS,
+        :port => Goliath::Server::DEFAULT_PORT,
+
+        :daemonize => false,
+        :verbose => false,
+        :log_stdout => false
+      }
+
+      @options_parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: <server> [options]"
+
+        opts.separator ""
+        opts.separator "Server options:"
+
+        opts.on('-e', '--environment NAME', "Set the execution environment (prod, dev or test) (default: #{Goliath.env})") { |val| Goliath.env = val }
+
+        opts.on('-a', '--address HOST', "Bind to HOST address (default: #{@options[:address]})") { |addr| @options[:address] = addr }
+        opts.on('-p', '--port PORT', "Use PORT (default: #{@options[:port]})") { |port| @options[:port] = port.to_i }
+
+        opts.on('-l', '--log FILE', "Log to file (default: off)") { |file| @options[:log_file] = file }
+        opts.on('-s', '--stdout', "Log to stdout (default: #{@options[:log_stdout]})") { |v| @options[:log_stdout] = v }
+
+        opts.on('-P', '--pid FILE', "Pid file (default: off)") { |file| @options[:pid_file] = file }
+        opts.on('-d', '--daemonize', "Run daemonized in the background (default: #{@options[:daemonize]})") { |v| @options[:daemonize] = v }
+        opts.on('-v', '--verbose', "Enable verbose logging (default: #{@options[:verbose]})") { |v| @options[:verbose] = v }
+
+        opts.on('-h', '--help', 'Display help message') { show_options(opts) }
+      end
+    end
+
+    # Given a block, this will use Rack::Builder to create the application
+    #
+    # @param blk [Block] The application block to load
+    # @return [Object] The Rack application
+    def load_app(&blk)
+      @app = ::Rack::Builder.app(&blk)
+    end
+
+    # Stores the list of plugins to be used by the server
+    #
+    # @param plugins [Array] The list of plugins to use
+    # @return [Nil]
+    def load_plugins(plugins)
+      @plugins = plugins
+    end
+
+    # Create environment to run the server.
+    # If daemonize is set this will fork off a child and kill the runner.
+    #
+    # @return [Nil]
+    def run
+      if @daemonize
+        Process.fork do
+          Process.setsid
+          exit if fork
+
+          @pid_file ||= './goliath.pid'
+          @log_file ||= File.expand_path('goliath.log')
+          store_pid(Process.pid)
+
+          Dir.chdir(File.dirname(__FILE__))
+          File.umask(0000)
+
+          stdout_log_file = "#{File.dirname(@log_file)}/#{File.basename(@log_file)}_stdout.log"
+
+          STDIN.reopen("/dev/null")
+          STDOUT.reopen(stdout_log_file, "a")
+          STDERR.reopen(STDOUT)
+
+          run_server
+        end
+      else
+        run_server
+      end
+    end
+
+    private
+
+    # Output the servers options
+    #
+    # @param opts [OptionsParser] The options parser
+    # @return [exit] This will exit the server
+    def show_options(opts)
+      puts opts
+
+      at_exit { exit! }
+      exit
+    end
+
+    # Sets up the logging for the runner
+    # @return [Logger] The logger object
+     def setup_logger
+       log = Log4r::Logger.new('goliath')
+
+       log_format = Log4r::PatternFormatter.new(:pattern => "[#{Process.pid}:%l] %d :: %m")
+       setup_file_logger(log, log_format) if @log_file
+       setup_stdout_logger(log, log_format) if @log_stdout
+
+       log.level = @verbose ? Log4r::DEBUG : Log4r::INFO
+       log
+     end
+
+     # Setup file logging
+     #
+     # @param log [Logger] The logger to add file logging too
+     # @param log_format [Log4r::Formatter] The log format to use
+     # @return [Nil]
+     def setup_file_logger(log, log_format)
+       FileUtils.mkdir_p(File.dirname(@log_file))
+
+       log.add(Log4r::FileOutputter.new('fileOutput', {:filename => @log_file,
+                                                       :trunc => false,
+                                                       :formatter => log_format}))
+     end
+
+     # Setup stdout logging
+     #
+     # @param log [Logger] The logger to add stdout logging too
+     # @param log_format [Log4r::Formatter] The log format to use
+     # @return [Nil]
+     def setup_stdout_logger(log, log_format)
+       log.add(Log4r::StdoutOutputter.new('console', :formatter => log_format))
+     end
+
+     # Run the server
+     #
+     # @return [Nil]
+     def run_server
+       log = setup_logger
+
+       log.info("Starting server on #{@address}:#{@port} in #{Goliath.env} mode. Watch out for stones.")
+
+       server = Goliath::Server.new(@address, @port)
+       server.logger = log
+       server.app = @app
+       server.api = @api
+       server.plugins = @plugins || []
+       server.options = @server_options
+       server.start
+     end
+
+     # Store the servers pid into the @pid_file
+     #
+     # @param pid [Integer] The pid to store
+     # @return [Nil]
+     def store_pid(pid)
+       FileUtils.mkdir_p(File.dirname(@pid_file))
+       File.open(@pid_file, 'w') { |f| f.write(pid) }
+     end
+  end
+end

data/lib/goliath/server.rb

@@ -0,0 +1,149 @@
+require 'em-synchrony'
+require 'goliath/connection'
+require 'goliath/goliath'
+
+module Goliath
+  # The server is responsible for listening to the provided port and servicing the requests
+  #
+  # @private
+  class Server
+    # The address of the server @example 127.0.0.1
+    # @return [String] The server address
+    attr_accessor :address
+
+    # The port of the server @example 9000
+    # @return [Integer] The server port
+    attr_accessor :port
+
+    # The logger for the server
+    # @return [Logger] The logger object
+    attr_accessor :logger
+
+    # The Rack application
+    # @return [Object] The rack application the server will execute
+    attr_accessor :app
+
+    # The API application
+    # @return [Object] The API application the server will execute
+    attr_accessor :api
+
+    # Server status information
+    # @return [Hash] Server status information
+    attr_accessor :status
+
+    # Server configuration information
+    # @return [Hash] Server configuration information
+    attr_accessor :config
+
+    # The plugins the server will execute
+    # @return [Array] The list of plugins to be executed by the server
+    attr_accessor :plugins
+
+    # The server options
+    # @return [Hash] Server options
+    attr_accessor :options
+
+    # Default execution port
+    DEFAULT_PORT = 9000
+
+    # Default execution address
+    DEFAULT_ADDRESS = '0.0.0.0'
+
+    # Create a new Goliath::Server
+    #
+    # @param address [String] The server address (default: DEFAULT_ADDRESS)
+    # @param port [Integer] The server port (default: DEFAULT_PORT)
+    # @return [Goliath::Server] The new server object
+    def initialize(address = DEFAULT_ADDRESS, port = DEFAULT_PORT)
+      @address = address
+      @port = port
+
+      @status = {}
+      @config = {}
+      @plugins = []
+    end
+
+    # Starts the server running. This will execute the reactor, load config and plugins and
+    # start listening for requests
+    #
+    # @return Does not return until the server has halted.
+    def start
+      EM.synchrony do
+        trap("INT")  { EM.stop }
+        trap("TERM") { EM.stop }
+
+        EM.epoll
+
+        load_config
+        load_plugins
+
+        EM.start_server(address, port, Goliath::Connection) do |conn|
+          conn.port = port
+          conn.app = app
+          conn.api = api
+          conn.logger = logger
+          conn.status = status
+          conn.config = config
+          conn.options = options
+        end
+
+        EM.set_effective_user("nobody") if Goliath.prod?
+      end
+    end
+
+    # Loads a configuration file
+    #
+    # @param file [String] The file to load, if not set will use the basename of $0
+    # @return [Nil]
+    def load_config(file = nil)
+      api_name = api.class.to_s.gsub(/(.)([A-Z])/,'\1_\2').downcase!
+      file ||= "#{config_dir}/#{api_name}.rb"
+      return unless File.exists?(file)
+
+      eval(IO.read(file))
+    end
+
+    # Retrieves the configuration directory for the server
+    #
+    # @return [String] THe full path to the config directory
+    def config_dir
+      if Goliath.test?
+        "#{File.expand_path(ENV['PWD'])}/config"
+      else
+        "#{File.expand_path(File.dirname($0))}/config"
+      end
+    end
+
+    # Import callback for configuration files
+    # This will trigger a call to load_config with the provided name concatenated to the config_dir
+    #
+    # @param name [String] The name of the file in config_dir to load
+    # @return [Nil]
+    def import(name)
+      file = "#{config_dir}/#{name}.rb"
+      load_config(file)
+    end
+
+    # The environment block handling for configuration files
+    #
+    # @param type [String|Array] The environment(s) to load the config block for
+    # @param blk [Block] The configuration data to load
+    # @return [Nil]
+    def environment(type, &blk)
+      types = [type].flatten.collect { |t| t.to_sym }
+      blk.call if types.include?(Goliath.env.to_sym)
+    end
+
+    # Executes the run method of all set plugins
+    #
+    # @return [Nil]
+    def load_plugins
+      @plugins.each do |(name, args)|
+        logger.info("Loading #{name.to_s}")
+
+        plugin = name.new(port, config, status, logger)
+        plugin.run(*args)
+      end
+    end
+  end
+end