chain-reactor 0.2.0

data/lib/chain-reactor/client.rb

@@ -0,0 +1,64 @@
+require 'socket'
+require 'json'
+
+module ChainReactor
+
+  # An error raised if there are communication problems with the server.
+  class ClientError < StandardError
+  end
+
+  # A client for connecting to a chain reactor server.
+  class Client
+    # The version of the chain reactor server.
+    attr_reader :version
+
+    # Create a connection to a chain reactor server at the given address and port.
+    def initialize(server_addr,server_port)
+      begin
+        @socket = TCPSocket.new(server_addr, server_port)
+      rescue Errno::ECONNREFUSED
+        raise ClientError, "Failed to connect to Chain Reactor server on #{server_addr}:#{server_port}"
+      end
+      connect
+    end
+
+    # Send hash data to the server as a JSON
+    def send_as_json(data_hash)
+      if data_hash.length > 0
+        json_string = JSON.generate(data_hash)
+        send(json_string)
+      else
+        raise ClientError, 'Cannot send empty data to chain reactor server'
+      end
+    end
+    
+    # Send a data string to the server
+    def send(data_string)
+      if data_string.length > 0
+        puts "Sending data: #{data_string}"
+        @socket.puts data_string
+      else
+        raise ClientError, 'Cannot send empty data to chain reactor server'
+      end
+    end
+
+    # Close the client socket.
+    def close
+      @socket.close
+    end
+    
+    private
+    # Connect and check the server response.
+    def connect
+      intro = @socket.gets
+      matches = /^ChainReactor v([\d.]+)/.match(intro)
+      if matches
+        @version = matches[1]
+      else
+        @socket.close
+        raise ClientError, "Invalid server response: #{intro}"
+      end
+    end
+
+  end
+end

data/lib/chain-reactor/client_connection.rb

@@ -0,0 +1,48 @@
+module ChainReactor
+
+  # Exception used by the ClientConnection class, signifying incorrect connection
+  # details for a client.
+  class ClientConnectionError < StandardError
+  end
+
+  # Holds information about the connected client, and provides access to the
+  # socket.
+  #
+  # The host, ip and port of the client are provided as attributes.
+  class ClientConnection
+
+    # Client's IP address.
+    attr_reader :ip
+    # Client's port.
+    attr_reader :port
+
+    # Create the ClientConnection with a TCPSocket. This socket holds connection
+    # parameters and allows data transfer both ways.
+    def initialize(socket,logger)
+      @socket = socket
+      fam, @port, *addr = @socket.getpeername.unpack('nnC4')
+
+      @ip = addr.join('.')
+      @log = logger
+      @log.info { "New connection from #{@ip}:#{@port}" }
+    end
+
+    # Write a string to the client socket, using <tt>TCPSocket.puts</tt>.
+    def say(string)
+      @socket.puts string
+    end
+
+    # Read from the client socket, using <tt>TCPSocket.gets</tt>.
+    def read
+      @socket.gets
+    end
+
+    # Close the socket connection, using <tt>TCPSocket.close</tt>.
+    def close
+      @log.info { "Closing connection to client #{@ip}" }
+      @socket.close
+    end
+
+  end
+
+end

data/lib/chain-reactor/conf.rb

@@ -0,0 +1,137 @@
+module ChainReactor
+  # Raised when trying to access a non-existent configuration option.
+  class ConfError < StandardError
+  end
+
+  require 'main'
+
+  # Configuration object that combines default values and command line options.
+  #
+  # The command line parameters are provided through the gem 'main', and these
+  # take precedent over options set through the chain file.
+  class Conf
+
+    # Create a new Conf object with the parameters from Main.
+    def initialize(cli_params)
+      @params = cli_params
+      @defaults = {}
+    end
+
+    # Get the chainfile, as a File object.
+    #
+    # This is the exception - it has to come as a CLI parameter.
+    def chainfile
+      @params[:chainfile].value
+    end
+
+    # Set the default bind IP address.
+    def address=(address)
+      set_default :address, address
+    end
+
+    # Get the IP address to bind to.
+    def address
+      get_value :address
+    end
+
+    # Set the log file location.
+    def log_file=(log_file)
+      set_default :logfile, log_file
+    end
+
+    # Get the log file location.
+    def log_file
+      get_value :logfile
+    end
+    
+    # Set the pid file location.
+    def pid_file=(pid_file)
+      set_default :pidfile, pid_file
+    end
+
+    # Get the pid file location.
+    def pid_file
+      get_value :pidfile
+    end
+
+    # Set the default port number.
+    def port=(port)
+      set_default :port, port
+    end
+
+    # Get the port number.
+    def port
+      get_value :port
+    end
+
+    # Set the whether to run multithreaded by default.
+    def multithreaded=(multithreaded)
+      set_default :multithreaded, multithreaded
+    end
+
+    # Whether the server should open each client connection in a new thread.
+    def multithreaded
+      get_value :multithreaded
+    end
+
+    # Set the default verbosity.
+    def verbosity=(verbosity)
+      set_default :verbosity, verbosity
+    end
+
+    # How verbose the program should be.
+    def verbosity
+      get_value :verbosity
+    end
+
+    # Set whether to run on top (instead of daemonizing).
+    def on_top=(on_top)
+      set_default :ontop, on_top
+    end
+
+    # Whether to run on top (instead of daemonizing).
+    def on_top
+      get_value :ontop
+    end
+
+    # Alias for on_top().
+    alias :on_top? :on_top
+    # Alias for multithreaded().
+    alias :multithreaded? :multithreaded
+
+    private
+
+    # Set the default value for a key.
+    #
+    # This value is used only if the equivalent command line
+    # parameter is not given.
+    def set_default(key,value)
+      if @defaults.nil?
+        @defaults = {}
+      end
+      @defaults[key] = value
+    end
+
+    # Get the value for a key.
+    #
+    # The command line parameters take precedence if given explicitly,
+    # followed by values set on the Conf object. Finally, default command
+    # line values are used.
+    #
+    # A ConfError exception is thrown if the key is unknown.
+    def get_value(key)
+      begin
+        param = @params.fetch(key)
+        if param.given?
+          param.value
+        elsif @defaults.has_key? key
+          @defaults[key]
+        else
+          param.value
+        end
+      rescue ::Main::Parameter::NoneSuch
+        raise ConfError, "Missing configuration parameter '#{key}'"
+      end
+    end
+  end
+end

data/lib/chain-reactor/controller.rb

@@ -0,0 +1,57 @@
+module ChainReactor
+  
+  # The Controller manages starting and stopping of the server, and daemonizing.
+  class Controller
+
+    require 'chainfile_parser'
+    require 'server'
+    require 'dante'
+
+    # Parse the chain file with a ChainfileParser object.
+    def initialize(config,log)
+      @config = config
+      @log = log
+      # log to STDOUT/ERR while parsing the chain file, only daemonize when complete.
+      @reactor = ChainfileParser.new(@config.chainfile,@config,@log).parse
+
+    end
+
+    # Start the server, as a daemon or on top if --ontop is supplied as a CLI arg.
+    #
+    # Uses dante as the daemonizer.
+    def start
+      # Change output format for logging to file if daemonizing
+      unless @config.on_top?
+        @log.outputters.first.formatter = ChainReactor::PatternFormatter.new(:pattern => "[%l] %d :: %m")
+        @log.info { "Starting daemon, PID file => #{@config.pid_file}" }
+      end
+
+      # Dante picks up ARGV, so remove it
+      ARGV.replace []
+      server = Server.new(@config.address,@config.port,@reactor,@log)
+
+      Dante::Runner.new('chain-reactor').execute(daemon_opts) do
+        server.start(@config.multithreaded?)
+      end
+    end
+
+    # Stop a daemonized process via the PID file specified in the options.
+    def stop
+      ARGV.replace []
+      Dante::Runner.new('chain-reactor').execute(:kill => true, 
+                                                 :pid_path => @config.pid_file)
+    end
+
+    protected
+
+      # Get a hash of the options passed to the daemonizer, dante.
+      def daemon_opts
+        { 
+          :daemonize => !@config.on_top, 
+          :pid_path => @config.pid_file, 
+          :log_path => @config.log_file,
+          :debug => true
+        }
+      end
+  end
+end

data/lib/chain-reactor/create_log.rb

@@ -0,0 +1,22 @@
+module ChainReactor
+
+  require 'log4r'
+  include Log4r
+
+  # Creates a logger object that prints to STDOUT.
+  def self.create_logger(level)
+    log = self.create_empty_logger(level)
+
+    outputter = Outputter.stdout
+    outputter.formatter = PatternFormatter.new(:pattern => "%l\t%m")
+    log.outputters << outputter
+    log
+  end
+
+  # Creates a logger object with no outputter.
+  def self.create_empty_logger(level)
+    log = Logger.new 'chain-reactor'
+    log.level = ChainReactor.const_get(level.upcase)
+    log
+  end
+end

data/lib/chain-reactor/parser_factory.rb

@@ -0,0 +1,23 @@
+module ChainReactor
+
+  require 'parsers/parser'
+  require 'parsers/json_parser'
+
+  # Used to parse strings using a method defined by child classes.
+  class ParserFactory
+
+    # Class method for retrieving a new Parser object depending on the type
+    # variable.
+    def self.get_parser(type,logger)
+      class_name = type.to_s.capitalize
+      if class_name.include? "_"
+        class_name = class_namesplit('_').map{|e| e.capitalize}.join
+      end
+      parser_class_name = class_name + 'Parser'
+      logger.debug { "Creating parser: #{parser_class_name}" }
+      parser_class = ChainReactor::Parsers.const_get parser_class_name
+      parser_class.new(logger)
+    end
+
+  end
+end

data/lib/chain-reactor/parsers/json_parser.rb

@@ -0,0 +1,20 @@
+module ChainReactor::Parsers
+
+  # Parse the string as a JSON object.
+  class JsonParser < Parser
+    require 'json'
+
+    # Parse a JSON string, returning the result as a hash.
+    #
+    # Raises a ParseError on failure.
+    def do_parse(string)
+      begin
+        @log.debug { "Parsing JSON string #{string.inspect}" }
+        JSON.parse(string)
+      rescue JSON::ParserError => e
+        raise ParseError, "Data from client is not a valid JSON: #{string}, error: #{e.message}, data: #{string}"
+      end
+    end
+  end
+
+end

data/lib/chain-reactor/parsers/parser.rb

@@ -0,0 +1,50 @@
+# Contains all parsers used to convert clients' data strings to ruby hashes.
+module ChainReactor::Parsers
+
+  # Error raised if there's an error parsing a string.
+  class ParseError < StandardError
+  end
+  
+  # Error raised if a required key is missing
+  class RequiredKeyError < StandardError
+  end
+
+  # Base class for all concrete implementations of parsers.
+  class Parser
+    
+    # Set up the parser with a logger object.
+    def initialize(logger)
+      @log = logger
+    end
+
+    # Parse the string sent by the client.
+    #
+    # Calls the do_parse() method which is defined by a subclass.
+    #
+    # Required keys can be passed as an array, and a RequiredKeyError
+    # is raised if any of those keys don't exist in the returned value
+    # from do_parse().
+    #
+    # keys_to_sym converts all string keys to symbol keys, and is true
+    # by default. 
+    def parse(string,required_keys,keys_to_sym)
+      data = do_parse(string.strip)
+      if keys_to_sym
+        @log.debug { "Converting data keys #{data.keys} to symbols" }
+        data = Hash[data.map { |k,v| [k.to_sym, v] }]
+      end
+      required_keys.each do |key|
+        data.has_key? key or raise RequiredKeyError, "Required key '#{key}' is missing from data #{data}"
+      end
+      data
+    end
+
+    # Parse the string, using an implmentation defined by child classes. 
+    # 
+    # Should return a hash.
+    def do_parse(string)
+      raise 'This method should implement a string to hash parser'
+    end
+  end
+end
+

data/lib/chain-reactor/parsers/xml_simple_parser.rb

@@ -0,0 +1,20 @@
+module ChainReactor::Parsers
+   
+  # Parse the string using the xml simple library.
+  class XmlSimpleParser < Parser
+
+    require 'xmlsimple'
+
+    # Parse an XML string, returning the result as a hash.
+    #
+    # Raises a ParseError on failure.
+    def do_parse(string)
+      begin
+        @log.debug { "Parsing XML string #{string.inspect}" }
+        XmlSimple.xml_in(string)
+      rescue StandardError => e
+        raise ParseError, "Data from client is not a valid XML string: #{string}, #{e.class.name} error: #{e.message}, data: #{string}"
+      end
+    end
+  end
+end