chain-reactor 0.2.0

data/lib/chain-reactor/reaction.rb

@@ -0,0 +1,47 @@
+module ChainReactor
+
+  # Raised if there's an error running a reaction.
+  #
+  # This is a simple wrapper around the originally raised exception.
+  class ReactionError < StandardError
+    attr_accessor :original_exception
+    def initialize(original_exception)
+      @original_exception = original_exception
+      super(original_exception.message)
+    end
+  end
+
+  # Represents a single reaction block, defined in the chain file with the 'react_to' method. 
+  class Reaction
+
+    require 'parser_factory'
+
+    # The previous return value from this reaction, if executed before.
+    attr_accessor :previous_result
+    # The previous data set sent to this reaction, if executed before.
+    attr_accessor :previous_data
+    # Options used by this reaction.
+    attr_accessor :options
+
+    # Create a new reaction, with the options and code block to run.
+    def initialize(options = {},block,logger)
+      @options = { :parser => :json, :required_keys => [], :keys_to_sym => true }.merge(options)
+      @block = block
+      @log = logger
+      @log.debug { "Created reaction with options: #{options}" }
+    end
+
+    # Executes the block of code after parsing the data string.
+    def execute(data_string)
+      parser = ParserFactory.get_parser(@options[:parser],@log)
+      data = parser.parse(data_string,@options[:required_keys],@options[:keys_to_sym])
+      begin
+        @previous_result = @block.call(data)
+        @previous_data = data
+      rescue StandardError => e
+        raise ReactionError.new(e)
+      end
+    end
+
+  end
+end

data/lib/chain-reactor/reactor.rb

@@ -0,0 +1,69 @@
+module ChainReactor
+  require 'reaction'
+
+  # Contains the map of reactions and allowed client addresses.
+  #
+  # This is used to determine which clients are allowed to connect, and to
+  # dispatch reactions.
+  class Reactor
+
+    # Pass a logger object and define an empty address map.
+    def initialize(logger)
+      @address_map = {}
+      @log = logger
+    end
+
+    # Add a react_to block from the chain file.
+    #
+    # Creates a Reaction object and calls add_address().
+    def add(addresses,options,block)
+      reaction = Reaction.new(options,block,@log)
+      addresses.each { |addr| add_address(addr,reaction) }
+    end
+
+    # Add an address with a reaction.
+    def add_address(address,reaction)
+      @log.debug { "Linking reaction to address #{address}" }
+
+      if @address_map.has_key? address
+        @address_map[address] << reaction
+      else
+        @address_map[address] = [reaction]
+      end
+    end
+
+    # React to a client by running the associated reactions.
+    # 
+    # Raises an error if the address is not allowed - use
+    # address_allowed? first.
+    def react(address,data_string)
+      address_allowed?(address) or raise 'Address is not allowed'
+      @address_map[address].each do |reaction|
+        @log.info { "Executing reaction for address #{address}" }
+        begin
+          reaction.execute(data_string)
+        rescue Parsers::ParseError => e
+          @log.error { "Parser error: #{e.message}" }
+        rescue Parsers::RequiredKeyError => e
+          @log.error { "Client data invalid: #{e.message}" }
+        rescue ReactionError => e
+          @log.error { 'Exception raised in reaction: '+e.message }
+        end
+      end
+    end
+
+    # Get an array of reactions for a given address
+    def reactions_for(address)
+      @address_map[address] if address_allowed?(address)
+    end
+
+    # Check whether the IP address is allowed.
+    #
+    # An IP address is allowed if the chain file specifies a "react_to" block
+    # with that address.
+    def address_allowed?(address)
+      @address_map.has_key? address
+    end
+
+  end
+end

data/lib/chain-reactor/server.rb

@@ -0,0 +1,94 @@
+module ChainReactor
+
+  require 'socket'
+  require 'parsers/parser'
+  require 'client_connection'
+
+  # Creates a server socket and listens for client connections on an infinite
+  # loop. Each connecting client creates a new thread, allowing multiple
+  # connections at the same time.
+  class Server
+    
+    # Create a new <tt>TCPServer</tt> listening on the given port.
+    def initialize(address,port,reactor,logger)
+      @server = TCPServer.open(address,port)
+      @reactor = reactor
+      @log = logger
+      @log.info { "Started ChainReactor v#{VERSION} server on #{address}:#{port.to_s}" }
+    end
+
+    # Start the server listening on an infinite loop.
+    #
+    # The multithreaded option allows each client connection to be opened
+    # in a new thread. 
+    #
+    # Keyboard interrupts are caught and handled gracefully.
+    def start(multithreaded)
+      if multithreaded
+        Thread.abort_on_exception = true
+        @log.info "Accepting concurrent connections with new threads"
+      end
+      begin
+        loop do
+          if multithreaded
+            Thread.new(@server.accept) do |client_sock|
+              handle_sock(client_sock)
+            end
+          else
+            handle_sock(@server.accept)
+          end
+        end
+      rescue Interrupt, SystemExit => e
+        @server.close
+        @log.info { "Shutting down the ChainReactor server" }
+        raise e
+      rescue Exception => e
+        @server.close
+        raise e
+      end
+    end
+
+    private
+
+    # Create a new ClientConnection when a socket is opened.
+    def handle_sock(client_sock)
+      begin
+        client = ClientConnection.new(client_sock,@log)
+        handle_client(client)
+      rescue ClientConnectionError => e
+        @log.error { "Client error: #{e.message}" }
+        client.close
+      end
+    end
+
+    # Handle a single client connection. 
+    #
+    # First, the IP address  is checked to determine whether it's 
+    # allowed to connect. Then the server sends a welcome 
+    # message so the client knows what it's connected to. Finally,
+    # data is read from the client and a reaction is executed.
+    def handle_client(client)
+      unless @reactor.address_allowed? client.ip
+        client.close
+        @log.warn { "Terminated connection from unauthorized client #{client.ip}" }
+        return
+      end
+
+      client.say("ChainReactor v#{VERSION}")
+
+      client_string = ''
+      while l = client.read
+        client_string += l
+      end
+
+      @log.debug { "Read from client #{client.ip}: #{client_string}" }
+      @log.info { "Finished reading from client #{client.ip}, closing connection" }
+
+      client.close
+
+      @reactor.react(client.ip,client_string)
+
+    end
+
+  end
+end

data/lib/chain-reactor/version.rb

@@ -0,0 +1,5 @@
+# The ChainReactor module encapsulates all classes in the gem.
+module ChainReactor
+  # Current gem version.
+  VERSION = "0.2.0"
+end

data/test/chainfile.test

@@ -0,0 +1,7 @@
+##########################################
+#     Chainfile for integration tests    #
+##########################################
+ 
+react_to('127.0.0.1') do |data|
+  puts data.inspect
+end

data/test/dummy_parser.rb

@@ -0,0 +1,9 @@
+
+module ChainReactor::Parsers
+  class DummyParser < Parser
+    def do_parse(string)
+      {}
+    end
+  end
+end
+

data/test/helpers.rb

@@ -0,0 +1,71 @@
+
+module ChainReactor
+  module TestHelpers
+    class Logger
+      def debug
+      end
+      def info
+      end
+      def warning
+      end
+      def error
+      end
+      def fatal
+      end
+    end
+
+    class Params
+      def initialize(hash_data)
+        @hash = hash_data
+      end
+
+      def method_missing(name, *args, &block)
+        @hash.send(name, *args, &block)
+      end
+
+      def fetch(key,&block)
+        begin
+          @hash.fetch(key,&block)
+        rescue KeyError => e
+          raise ::Main::Parameter::NoneSuch, key
+        end
+      end
+
+    end
+
+    class CliParam
+      def initialize(value)
+        @value = value
+        @given = true
+      end
+
+      def value
+        @value
+      end
+
+      def given=(given)
+        @given = given
+      end
+
+      def given?
+        @given
+      end
+    end
+
+    class File
+      def initialize(string)
+        @string = string
+      end
+
+      def read
+        @string
+      end
+    end
+
+    def get_logger
+      Logger.new
+    end
+
+  end
+end
+

data/test/test_chain_reactor_options.rb

@@ -0,0 +1,69 @@
+require 'test/unit'
+require 'rubygems'
+require 'open3'
+
+# Test case for the options of the chain reactor executable.
+class TestChainReactorOptions < Test::Unit::TestCase
+
+  def exec_with(arg_string)
+    bin_path = File.dirname(__FILE__)+'/../bin/chain-reactor'
+    Open3.popen3("#{bin_path} #{arg_string}")
+  end
+
+  def test_help_returns_help_in_stdout
+    out = exec_with('--help')
+    help = out[1].read
+    status = out[3].value
+
+    assert_equal 1, status.exitstatus
+    assert_match(/NAME\s*chain\-reactor/, help)
+    assert_match(/SYNOPSIS\s*chain\-reactor \(start|stop|template\) chainfile\.rb/, help)
+  end
+
+  def test_no_args_returns_help_in_stdout_and_fails
+    out = exec_with('')
+    help = out[1].read
+    status = out[3].value
+
+    assert_equal 1, status.exitstatus
+    assert_match(/NAME\s*chain\-reactor/, help)
+    assert_match(/SYNOPSIS\s*chain\-reactor \(start|stop|template\) chainfile\.rb/, help)
+  end
+
+  def test_invalid_mode_returns_help_and_fails
+    out = exec_with('ssaduhdui')
+    help = out[1].read
+    status = out[3].value
+
+    assert_equal 1, status.exitstatus
+    assert_match(/NAME\s*chain\-reactor/, help)
+    assert_match(/SYNOPSIS\s*chain\-reactor \(start|stop|template\) chainfile\.rb/, help)
+  end
+
+  def test_template_returns_chainfile_in_stdout
+    out = exec_with('template')
+    template = out[1].read
+    status = out[3].value
+
+    assert_equal 0, status.exitstatus
+    assert_match(/react_to\(/, template)
+  end
+
+  def test_start_without_chainfile_fails
+    out = exec_with('start')
+    error = out[2].read
+    status = out[3].value
+
+    assert_equal 1, status.exitstatus
+    assert_match(/chain-reactor: A valid chainfile must be supplied/, error)
+  end
+
+  def test_stop_without_chainfile_fails
+    out = exec_with('stop')
+    error = out[2].read
+    status = out[3].value
+
+    assert_equal 1, status.exitstatus
+    assert_match(/chain-reactor: A valid chainfile must be supplied/, error)
+  end
+end

data/test/test_chain_reactor_start.rb

@@ -0,0 +1,88 @@
+require 'test/unit'
+require 'rubygems'
+require 'open3'
+require 'sys/proctable'
+require 'client'
+
+# Test case for the options of the chain reactor executable.
+class TestChainReactorStart < Test::Unit::TestCase
+  include Sys
+
+  def setup
+    @test_path = File.dirname(__FILE__) 
+    @bin_path = @test_path + '/../bin/chain-reactor'
+    @chainfile_path = @test_path + '/chainfile.test'
+    @pid_path = @test_path + '/chain-reactor.pid'
+  end
+
+  def teardown
+    _,_,_,t = stop_chain_reactor
+    t.value
+    
+    $stdout = STDOUT
+  end
+
+  def start_chain_reactor(arg_string)
+    Open3.popen3("#{@bin_path} start #{@chainfile_path} #{arg_string} --pidfile #{@pid_path}")
+  end
+
+  def stop_chain_reactor
+    Open3.popen3("#{@bin_path} stop #{@chainfile_path} --pidfile #{@pid_path}")
+  end
+
+  def test_start_daemon
+    _, stdout, _, thread = start_chain_reactor('')
+    output = stdout.read
+
+    assert_match(/Registered 1 reactions/,output)
+    assert_match(/Starting daemon, PID file => #{@pid_path}/,output)
+    assert_match(/Daemon has started successfully/,output)
+
+    # Thread stopped as it's daemonized
+    assert_equal true, thread.stop?
+
+    assert File.file? @pid_path
+    pid = File.new(@pid_path).read.to_i
+    prc = ProcTable.ps(pid)
+
+    assert_not_nil prc
+    assert_match(/chain\-reactor start/,prc.cmdline)
+  end
+
+  def test_start_daemon_and_communicate_with_client
+    _, stdout, _, _ = start_chain_reactor('')
+    output = stdout.read
+    assert_match(/Daemon has started successfully/,output)
+
+    assert_nothing_raised ChainReactor::ClientError do
+      $stdout = File.new('/dev/null','w')
+      client = ChainReactor::Client.new('127.0.0.1',20000)
+      client.send_as_json({:hello => :world})
+    end
+  end
+
+  def test_start_daemon_with_port_override_and_communicate_with_client
+    _, stdout, _, _ = start_chain_reactor('--port 20100')
+    output = stdout.read
+    assert_match(/Daemon has started successfully/,output)
+
+    assert_nothing_raised ChainReactor::ClientError do
+      $stdout = File.new('/dev/null','w')
+      client = ChainReactor::Client.new('127.0.0.1',20100)
+      client.send({:hello => :world})
+    end
+  end
+
+  def test_start_daemon_with_address_override_and_communicate_with_client
+    _, stdout, _, _ = start_chain_reactor('--address 0.0.0.0')
+    output = stdout.read
+    assert_match(/Daemon has started successfully/,output)
+
+    assert_nothing_raised ChainReactor::ClientError do
+      $stdout = File.new('/dev/null','w')
+      client = ChainReactor::Client.new('0.0.0.0',20000)
+      client.send({:hello => :world})
+    end
+  end
+end
+