chain-reactor 0.2.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in chain-reactor.gemspec
+gemspec
+
+gem 'json'
+gem 'mocha'
+gem 'dante'
+gem 'log4r'
+
+gem 'xml-simple', :require => false
+
+group :test do
+  gem 'sys-proctable'
+end

data/LICENSE.txt

@@ -0,0 +1 @@
+See Ruby's license

data/README.rdoc

@@ -0,0 +1,54 @@
+= Chain Reactor
+
+Chain Reactor is a simple server that waits for incoming connections, then kicks off some code when one is made. Clients are locked down by IP address, so you will only recieve connections from known clients. Also, data can be passed via JSON, XML, or anything you like.
+
+The "reactions" are written in ruby code, like this:
+
+    react_to '192.168.0.1' do |data|
+      puts "Hello, 192.168.0.1, I'm going to do something now!"
+      puts data.inspect  #=> Prints a hash
+    end
+
+It really is that easy. Also, you can respond to multiple clients with the same code block:
+
+    react_to ['192.168.0.1','192.168.0.2'] do |data|
+      puts "Hello, I'm going to do something now!"
+    end
+
+It can be run as a daemon, multithreaded (each client connection in a new thread), and bind to different addresses and ports.
+
+== Why?
+
+This project started as a way of notifying other machines about builds happening on Jenkins, our continuous integration server. A chain reactor server would be sitting, listening for connections. When a build fails or passes on Jenkins, it lets the chain reactor server(s) know, pushing the build data. The chain reactor server then does what it likes, and the Jenkins server doesn't need to know.
+
+I'm sure this has plenty of other uses, but it works great with continuous integration set-ups.
+
+== Installation
+
+This can be installed through ruby gems:
+
+    $ gem install chain-reactor
+
+== Usage
+
+A chain file is required to run, as this specifies which clients to accept and what to do. Fortunately, it's easy to create a template:
+
+    $ chain-reactor template > Chainfile.rb
+
+Open it up and edit it to your liking. You might want to test it locally first, i.e. only react to 127.0.0.1 addresses. In one terminal, run:
+
+    $ chain-reactor start Chainfile.rb --ontop
+
+The --ontop option stops it from running as a daemon, making it easier to see what's happening. By default, the chain reactor server runs on port 1987, but that's configurable if you want to change it. In another terminal, run the client with:
+
+    $ chain-reactor-client --address 127.0.0.1
+
+Follow the instructions by adding key/value pair data to send to the server, then watch it react!
+
+== Contributing
+
+1. Fork it
+2. Create your feature branch (<tt>git checkout -b my-new-feature</tt>)
+3. Commit your changes (<tt>git commit -am 'Add some feature'</tt>)
+4. Push to the branch (<tt>git push origin my-new-feature</tt>)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,24 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'rdoc/task'
+
+# Test task ----------------------------
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib/chain-reactor'
+  t.libs << 'test'
+  t.libs << 'bin'
+end
+
+desc "Run tests"
+task :default => :test
+
+# RDoc task ----------------------------
+
+rd = RDoc::Task.new("rdoc") { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Chain Reactor"
+  rdoc.options << '--line-numbers' << '--main' << 'README.rdoc'
+  rdoc.rdoc_files.include('lib/**/*.rb', '[A-Z]*\.[a-z]*')
+}
+

data/bin/chain-reactor

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'chain-reactor/chain_reactor.rb'

data/bin/chain-reactor-client

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'chain-reactor/chain_reactor_client.rb'

data/chain-reactor.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chain-reactor/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "chain-reactor"
+  gem.version       = ChainReactor::VERSION
+  gem.license       = 'MIT'
+  gem.authors       = ["Jon Cairns"]
+  gem.email         = ["jon@joncairns.com"]
+  gem.description   = %q{Trigger events across networks using TCP/IP sockets}
+  gem.summary       = %q{A TCP/IP server that triggers code on connection}
+  gem.homepage      = "http://github.com/joonty/chain-reactor"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = %w(chain-reactor chain-reactor-client)
+  gem.test_files    = `git ls-files -- test/test_`.split($/)
+  gem.require_paths = ["lib"]
+end

data/lib/chain-reactor/chain_reactor.rb

@@ -0,0 +1,208 @@
+module ChainReactor
+
+  lib_dir = File.dirname(__FILE__)
+  $:.unshift lib_dir
+
+  require 'version'
+  require 'rubygems'
+  require 'main'
+  require 'create_log'
+  require 'conf'
+
+  # Set up command line options and usage with the main gem.
+  Main do
+    examples 'chain-reactor start chainfile.rb ', 
+             'chain-reactor stop chainfile.rb',
+             'chain-reactor template'
+
+    description 'Chain reactor is a server that responds to network events and runs ruby code. Run with the `start\' mode and \'--help\' to see options, or use the `template\' mode to create an example chainfile.'
+
+    # Show the command line options if run without a mode.
+    def run
+      help!
+    end
+
+    # Start the server, as a daemon or on top.
+    mode :start do
+
+      description 'Start the chain reactor server, as a daemon or (optionally) on top. Daemonizing starts a background process, creates a pid file and a log file.'
+
+      examples 'chain-reactor start chainfile.rb ', 
+               'chain-reactor start chainfile.rb --ontop',
+               'chain-reactor start chainfile.rb --pidfile /path/to/pidfile.pid'
+
+      input :chainfile do
+        description 'A valid chainfile - run with the template mode to create an example'
+        error do |e| 
+          STDERR.puts "chain-reactor: A valid chainfile must be supplied - run with the 'template' mode to generate an example"
+        end
+      end
+
+      option :debug do
+        log_levels = %w(debug info warn error fatal)
+        argument :required
+        validate { |str| log_levels.include? str }
+        synopsis '--debug=('+log_levels.join('|')+')  (0 ~> debug=info)'
+        defaults 'info'
+        description 'Type of messages to send to output'
+      end
+
+      option :pidfile do
+        argument :required
+        description 'Pid file for the daemonized process'
+        defaults Dir.pwd+'/chain-reactor.pid'
+      end
+
+      option :multithreaded do
+        cast :bool
+        defaults false
+        description 'Start each new connection in a separate thread'
+      end
+
+      option :ontop do
+        cast :bool
+        defaults false
+        description 'Keep the process on top instead of daemonizing'
+      end
+
+      option :logfile do
+        argument :required
+        description 'Log file to write messages to'
+        defaults Dir.pwd+'/chain-reactor.log'
+      end
+
+      option :address do
+        argument :required
+        defaults '127.0.0.1'
+        description 'IP address to bind to'
+      end
+
+      option :port do
+        argument :required
+        defaults 1987
+        description 'Port number to bind to'
+      end
+
+      # Run when using the 'start' mode from the command line.
+      def run
+        require 'controller'
+
+        conf = Conf.new(params)
+        log = ChainReactor.create_logger(params[:debug].value)
+
+        begin
+          Controller.new(conf,log).start
+        rescue Interrupt, SystemExit
+          exit_status exit_success
+        rescue ChainfileParserError => e
+          log.fatal { "Failed to parse chainfile {#{e.original.class.name}}: #{e.message}" }
+          exit_status exit_failure
+        rescue Exception => e
+          log.fatal { "Unexpected exception {#{e.class.name}}: #{e.message}" }
+          log.debug { $!.backtrace.join("\n\t") }
+          exit_status exit_failure
+        end
+      end
+    end
+
+    mode :stop do
+      description 'Stop a running chain reactor server daemon. Specify the path to the pid file to stop a specific chain reactor instance.'
+
+      input :chainfile do
+        description 'A valid chainfile - run with the template argument to create a template'
+        error do |e| 
+          STDERR.puts "chain-reactor: A valid chainfile must be supplied - run with the 'template' mode to generate an example"
+        end
+      end
+
+      option :debug do
+        log_levels = %w(debug info warn error fatal)
+        argument :required
+        validate { |str| log_levels.include? str }
+        synopsis '--debug=('+log_levels.join('|')+')  (0 ~> debug=info)'
+        defaults 'info'
+        description 'Type of messages to send to output'
+      end
+
+      option :pidfile do
+        argument :required
+        description 'Pid file for the daemonized process'
+        defaults Dir.pwd+'/chain-reactor.pid'
+      end
+
+      # Run when using the 'stop' mode from the command line.
+      def run
+        require 'controller'
+
+        log = ChainReactor.create_empty_logger(params[:debug].value)
+        conf = Conf.new(params)
+
+        puts "Attempting to stop chain reactor server with pid file: #{conf.pid_file}"
+        c = Controller.new(conf,log)
+        failed = c.stop
+
+        exit_status(exit_failure) if failed
+      end
+
+    end
+
+    mode 'template' do
+      description 'Create a template chainfile, to see examples of configuration options and reaction syntax.'
+
+      examples 'chain-reactor template'
+
+      # Run when using the 'template' mode from the command line.
+      def run
+        puts <<-eos
+#####################
+#     Chainfile     #
+#####################
+ 
+# Do something when 127.0.0.1 sends a JSON
+react_to('127.0.0.1') do |data|
+
+  # The JSON string sent by the client is now a ruby hash
+  puts data.inspect
+
+end
+
+# Use the same reaction for multiple clients, and require keys to exist
+react_to( ['127.0.0.1','192.168.0.2'], :requires => [:mykey] ) do |data|
+
+  # You can be sure this exists
+  puts data[:mykey]
+
+end
+
+# Change the parser, if the client sends something other than a JSON
+react_to('192.168.0.2', :parser => :xml_simple) do |data|
+
+  # The XML string sent by the client is now a ruby hash
+  puts data.inspect
+
+end
+
+## Everything from here on is optional, and  can be overridden 
+## by equivalent command line parameters
+
+## Address to bind to
+address '127.0.0.1'
+
+## Port to listen on
+port 1987
+
+## Location of pid file, for daemon
+# pidfile '/var/run/chain-reactor.pid'
+
+## Location of log file, for daemon
+# logfile '/var/log/chain-reactor.log'
+
+## Whether to accept each client in a separate thread.
+# multithreaded true
+
+        eos
+      end
+    end
+  end
+
+end

data/lib/chain-reactor/chain_reactor_client.rb

@@ -0,0 +1,83 @@
+
+module ChainReactor
+  lib_dir = File.dirname(__FILE__)
+  $:.unshift lib_dir
+
+  require 'version'
+  require 'rubygems'
+  require 'main'
+
+  Main do
+    input :data do
+      optional
+    end
+
+    option :address do
+      argument_required
+      required
+      cast :string
+      description 'Chain reactor server address'
+    end
+
+    option :port do
+      argument_required
+      required
+      cast :int
+      description 'Chain reactor server port number'
+      defaults 1987
+    end
+
+    # Connect to a running chain reactor server and send data.
+    def run
+      require 'client'
+
+      begin
+        client = Client.new params[:address].value, params[:port].value
+        puts "Connected to Chain Reactor server, version #{client.version}"
+        data_input = params[:data].value
+
+        if data_input
+          client.send(data_input.gets.strip)
+        else
+          client.send_as_json(get_hash_from_stdin)
+          client.close()
+        end
+        exit_status exit_success
+      rescue ClientError => e
+        STDERR.puts e.message
+        exit_status exit_failure
+      rescue SystemExit, Interrupt
+        STDERR.puts "Caught exit signal" 
+        exit_status exit_failure
+      rescue Exception => e
+        STDERR.puts "An error occured {#{e.class.name}}: #{e.message}" 
+        exit_status exit_failure
+      end
+    end
+
+    # Ask the user for key value pairs, and return as a hash.
+    def get_hash_from_stdin
+      STDOUT.sync = true
+      hash_to_send = {}
+      puts "No data supplied, what do you want to send? (Leave key blank to end)"
+      incr = 1
+
+      loop do
+        print "Key ##{incr}: "
+        key = STDIN.gets.chomp
+
+        if key == ""
+          break
+        end
+
+        print "Value ##{incr}: "
+        value = STDIN.gets.chomp
+
+        hash_to_send[key] = value
+        incr += 1
+      end
+      hash_to_send
+    end
+  end
+
+end

data/lib/chain-reactor/chainfile_parser.rb

@@ -0,0 +1,81 @@
+module ChainReactor
+
+  require 'reactor'
+
+  # Error raised when there's a error parsing the chain file.
+  #
+  # This contains the original exception raised by eval().
+  class ChainfileParserError < StandardError
+    attr_reader :original
+    def initialize(original)
+      @original = original
+      super(original.message.gsub(/\sfor #<ChainReactor.*>/,''))
+    end
+  end
+
+  # Parse the chain file and register reaction code blocks and network addresses.
+  class ChainfileParser
+
+    # Set up a parser with a File object representing the chain file.
+    def initialize(chainfile,config,logger)
+      @file = chainfile
+      @config = config
+      @reactions = 0
+      @reactor = Reactor.new(logger)
+      @log = logger
+    end
+
+    # Parse the chain file and return a reactor object.
+    #
+    # A ChainfileParserError is raised if the chain file has invalid syntax.
+    def parse
+      begin
+        eval @file.read
+      rescue Exception => e
+        raise ChainfileParserError, e
+      end
+
+      if @reactions.zero?
+        @log.error { "No reactions registered, no reason to continue" }
+        raise 'No reactions registered, no reason to continue'
+      else
+        @log.info { "Registered #{@reactions} reactions in the chain file" }
+      end
+
+      @reactor
+    end
+
+    # Register a reaction block, with IP addresses, arguments and a code block
+    def react_to(addresses,args = {},&block)
+      addresses = [*addresses]
+      @reactions += 1
+      @reactor.add(addresses,args,block)
+    end
+
+    # Set the address to bind to.
+    def address(addr)
+      @config.address = addr
+    end
+
+    # Set the port to listen on.
+    def port(port)
+      @config.port = port
+    end
+
+    # Set the pid file path.
+    def pidfile(pidfile)
+      @config.pidfile = pidfile
+    end
+    #
+    # Set the log file path.
+    def logfile(logfile)
+      @config.logfile = logfile
+    end
+
+    # Set whether to run multithreaded.
+    def multithreaded(multithreaded = true)
+      @config.multithreaded = !!multithreaded
+    end
+
+  end
+end