crossroads 0.0.1

data/bin/crossroads

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'crossroads'
+require 'optparse'
+
+configfile = "/etc/crossroads/crossroads.yaml"
+daemon = false
+pidfile = nil
+
+Version = Crossroads.version
+
+opt = OptionParser.new
+
+opt.on("--config [FILE]", "Configuration File") do |v|
+    configfile = v
+end
+
+opt.on("--daemonize", "-d", "Daemonize the process") do |v|
+    daemon = true
+end
+
+opt.on("--pid [PIDFILE]", "-p", "Write a pidfile") do |v|
+    pidfile = v
+end
+
+opt.parse!
+
+raise "The directory #{configfile} does not exist" unless File.exist?(configfile)
+
+def stop_and_exit(daemon, pidfile, signal)
+    Crossroads::Log.info("Exiting after signal #{signal}")
+
+    if daemon && pidfile
+        File.unlink(pidfile)
+    end
+
+    exit
+end
+
+Signal.trap('INT') { stop_and_exit(daemon, pidfile, :int) }
+Signal.trap('TERM') { stop_and_exit(daemon, pidfile, :term) }
+
+cr = Crossroads.runner("t.yaml")
+
+if daemon
+    raise "Pidfile #{pidfile} exist" if pidfile && File.exist?(pidfile)
+
+    Crossroads.daemonize do
+        if pidfile
+            begin
+                File.open(pidfile, 'w') {|f| f.write(Process.pid) }
+            rescue
+            end
+        end
+
+        cr.run!
+    end
+else
+    cr.run!
+end

data/lib/crossroads.rb

@@ -0,0 +1,29 @@
+module Crossroads
+  VERSION = "0.0.1"
+
+  ["jgrep", "logger", "yaml", "json", "stomp", "crossroads/route", "crossroads/router",
+    "crossroads/log", "crossroads/runner", "crossroads/stomp"].each do |r|
+    require r
+   end
+
+  def self.version
+    VERSION
+  end
+
+  def self.runner(configfile)
+    Runner.new(configfile)
+  end
+
+  def self.daemonize
+    fork do
+      Process.setsid
+      exit if fork
+      Dir.chdir('/tmp')
+      STDIN.reopen('/dev/null')
+      STDOUT.reopen('/dev/null', 'a')
+      STDERR.reopen('/dev/null', 'a')
+
+      yield
+    end
+  end
+end

data/lib/crossroads/log.rb

@@ -0,0 +1,43 @@
+module Crossroads
+    class Log
+        @configured = false
+
+        class << self
+            def log(msg, severity=:debug)
+                configure unless @configured
+
+                @logger.add(valid_levels[severity.to_sym]) { "#{from} #{msg}" }
+            rescue Exception => e
+                STDERR.puts("Failed to log: #{e.class}: #{e}: original log message: #{severity}: #{msg}")
+                STDERR.puts(e.backtrace.join("\n\t"))
+            end
+
+            def configure(logfile, keep=10, maxsize=1024, level=:info)
+                @logger = Logger.new(logfile, keep, maxsize)
+                @logger.formatter = Logger::Formatter.new
+                @logger.level = valid_levels[level.to_sym]
+                @configured = true
+            end
+
+            # figures out the filename that called us
+            def from
+                from = File.basename(caller[4])
+            end
+
+            def valid_levels
+                {:info  => Logger::INFO,
+                 :warn  => Logger::WARN,
+                 :debug => Logger::DEBUG,
+                 :fatal => Logger::FATAL,
+                 :error => Logger::ERROR}
+            end
+
+            def method_missing(level, *args, &block)
+                super unless [:info, :warn, :debug, :fatal, :error].include?(level)
+
+                log(args[0], level)
+            end
+        end
+    end
+end
+

data/lib/crossroads/route.rb

@@ -0,0 +1,48 @@
+module Crossroads
+  # expression "headers.foo = 1 and body.bar = 1"
+  #
+  # processor do |headers, body|
+  #   target "/queue/foo" if body....
+  # end
+  class Route
+    def initialize(name)
+      @name = name
+      @jgrep = JGrep::JGrep.new
+      @expression = nil
+      @processor = nil
+      @route_count = 0
+    end
+
+    def load_route(file)
+      Log.info("Loading route from file #{file} for router #{@name}")
+      eval(File.read(file))
+    end
+
+    def route!(msg)
+      @targets = []
+
+      @start = Time.now
+
+      if @expression && @processor && @jgrep.match_value({"headers" => msg.headers, "body" => JSON.parse(msg.body)})
+        @processor.call(msg.headers, msg.body)
+      end
+
+      @route_count += 1
+
+      @targets
+    end
+
+    def target(trgt)
+      @targets << {:target => trgt, :name => @name, :process_time => (Time.now - @start).to_f}
+    end
+
+    def processor(&blk)
+      @processor = blk
+    end
+
+    def expression(exp)
+      @expression = exp
+      @jgrep.expression = exp
+    end
+  end
+end

data/lib/crossroads/router.rb

@@ -0,0 +1,69 @@
+module Crossroads
+  class Router
+    def initialize(dir)
+      raise "Cannot find routers directory #{dir}" unless File.directory?(dir)
+
+      @routesdir = dir
+      @triggerfile = File.join(@routesdir, "reload.txt")
+      @checktime = 0
+
+      loadroutes
+    end
+
+    def reload_routes
+      if (Time.now - @checktime).to_i > 30
+        if File.exist?(@triggerfile)
+          triggermtime = File::Stat.new(@triggerfile).mtime
+          if triggermtime > @loadtime
+            loadroutes
+          end
+        end
+
+        @checktime = Time.now
+      end
+    end
+
+    def route(msg)
+      reload_routes
+
+      targets = []
+
+      @routes.each do |r|
+        begin
+          targets.concat(r.route!(msg))
+        rescue
+        end
+      end
+
+      targets
+    end
+
+    def routefiles
+      Dir.entries(@routesdir).grep(/\.route$/).map do |f|
+        File.join([@routesdir, f])
+      end.sort
+    end
+
+    def loadroute(route)
+      route_name = File.basename(route, ".route")
+
+      r = Route.new(route_name)
+      r.load_route(route)
+
+      @routes << r
+    rescue Exception => e
+      STDERR.puts "Failed to load route #{route}"
+      @routers.delete route_name rescue nil
+    end
+
+    def loadroutes
+      @routes = []
+
+      routefiles.each do |route|
+        loadroute route
+      end
+
+      @loadtime = Time.now
+    end
+  end
+end

data/lib/crossroads/runner.rb

@@ -0,0 +1,75 @@
+module Crossroads
+  class Runner
+    attr_reader :router
+
+    def initialize(configfile)
+      defaults = {:configdir  => "/etc/crossroads",
+                  :consume    => nil,
+                  :logfile    => "/dev/stderr",
+                  :loglevel   => :info,
+                  :keeplogs   => 10,
+                  :maxlogsize => 1024,
+                  :daemonie   => false,
+                  :stomp      => [{:server   => "localhost",
+                                  :port     => 61613,
+                                  :user     => nil,
+                                  :password => nil}]}
+
+      @config = defaults.merge(YAML.load_file(configfile))
+
+      raise "Config file does not have input sources defined" unless @config[:consume]
+
+      Log.configure(@config[:logfile], @config[:keeplogs], @config[:maxlogsize], @config[:loglevel])
+
+      Log.info("Crossroads version #{Crossroads.version} starting with configfile #{configfile}")
+
+      @router = Router.new(@config[:configdir])
+
+      subscribe
+    end
+
+    def run!
+      process
+    end
+
+    def process
+      loop do
+        begin
+          msg = @stomp.receive
+
+          targets = route(msg)
+
+          targets.each do |target|
+            headers = msg.headers.merge({"crossroads_route" => target[:name], "crossroads_time" => target[:process_time]})
+
+            ["destination", "timestamp", "message-id"].each do |h|
+              headers["crossroads_orig_#{h}"] = headers[h]
+              headers.delete h
+            end
+
+            @stomp.publish(target[:target], msg.body, headers)
+          end
+        rescue Interrupt, SystemExit
+          break
+        rescue Exception => e
+          Log.error("Failed to consume from the middleware: #{e.class}: #{e}")
+
+          sleep 1
+          retry
+        end
+      end
+    end
+
+    def subscribe
+      @stomp = Stomp.new(@config[:stomp])
+
+      [@config[:consume]].flatten.each do |source|
+        @stomp.subscribe source
+      end
+    end
+
+    def route(msg)
+      @router.route(msg)
+    end
+  end
+end

data/lib/crossroads/stomp.rb

@@ -0,0 +1,85 @@
+module Crossroads
+  class Stomp
+    attr_reader :subscriptions
+
+    class EventLogger
+      def on_connecting(params=nil)
+        Log.info("Connection attempt %d to %s" % [params[:cur_conattempts], stomp_url(params)])
+      rescue
+      end
+
+      def on_connected(params=nil)
+        Log.info("Conncted to #{stomp_url(params)}")
+      rescue
+      end
+
+      def on_disconnect(params=nil)
+        Log.info("Disconnected from #{stomp_url(params)}")
+      rescue
+      end
+
+      def on_connectfail(params=nil)
+        Log.info("Connction to #{stomp_url(params)} failed on attempt #{params[:cur_conattempts]}")
+      rescue
+      end
+
+      def on_miscerr(params, errstr)
+        Log.debug("Unexpected error on connection #{stomp_url(params)}: #{errstr}")
+      rescue
+      end
+
+      def stomp_url(params)
+        "stomp://%s@%s:%d" % [params[:cur_login], params[:cur_host], params[:cur_port]]
+      end
+    end
+
+    def initialize(config)
+      connect(config)
+
+      @subscriptions = []
+    end
+
+    def connect(config)
+      hosts = []
+
+      [config].flatten.each do |c|
+        host = {}
+
+        host[:host] = c[:server]
+        host[:port] = c[:port]
+        host[:login] = c[:user] if c[:user]
+        host[:passcode] = c[:password] if c[:password]
+
+        hosts << host
+      end
+
+      raise "No hosts defined for Stomp connection" if hosts.size == 0
+
+      connection = {:hosts => hosts, :logger => EventLogger.new}
+
+      @connection = ::Stomp::Connection.new(connection)
+    end
+
+    def subscribe(source)
+      Log.info("Subscribing to #{source}")
+
+      @connection.subscribe source
+      @subscriptions << source
+    end
+
+    def unsubscribe(source)
+      Log.info("Unsubscribing from #{source}")
+
+      @connection.unsubscribe source
+      @subscriptions.delete source
+    end
+
+    def publish(target, msg, headers)
+      @connection.publish(target, msg, headers)
+    end
+
+    def receive
+      @connection.receive
+    end
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: crossroads
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- R.I.Pienaar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-15 00:00:00 +00:00
+default_executable: crossroads
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: stomp
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: jgrep
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 1
+        - 3
+        - 1
+        version: 1.3.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: A router that consumes STOMP middleware and routes data to other destinations based on simple rules expressed in Ruby
+email: rip@devco.net
+executables: 
+- crossroads
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/crossroads
+- lib/crossroads/stomp.rb
+- lib/crossroads/router.rb
+- lib/crossroads/route.rb
+- lib/crossroads/log.rb
+- lib/crossroads/runner.rb
+- lib/crossroads.rb
+has_rdoc: true
+homepage: https://github.com/ripienaar/crossroads/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Routing system for JSON messages on STOMP middleware
+test_files: []
+