genesisreactor 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4817f006c4e5a7f526e34621d7a2ade1dcf2d023
+  data.tar.gz: e5d4f096612c72f90d8e68045b2611f2f3e1b2b0
+SHA512:
+  metadata.gz: 7e9893694f8f69a7f1c872604f7c39ff12e06be91288999408eb0349131254c40d62be9afdad0b12bceae9dcf4fdd3da0e154c95540b2066fec190b69d278d6e
+  data.tar.gz: b093bd04764782ed939d155fd98c01f06eaf5c4e00338f1fcd8c099a4b032a60bc3ad9eb7794e3ec6495a9b216f259da2ee9228829a85bf2c2caced7cc08f283

data/lib/genesis/agent.rb

@@ -0,0 +1,25 @@
+module Genesis
+  # Interface for a GenesisAgent
+  # Allows subclasess specifying agents in a DSL
+  class Agent
+    class << self
+      attr_accessor :agents
+      def register_agent(**kwargs, &block)
+        @agents << { interval: kwargs[:interval] || 60, opts: kwargs, block: block }
+      end
+
+      def reset!
+        @agents = []
+      end
+
+      def inherited(subclass)
+        subclass.reset!
+        super
+      end
+
+      alias_method :schedule, :register_agent
+    end
+
+    reset!
+  end
+end

data/lib/genesis/handler.rb

@@ -0,0 +1,30 @@
+module Genesis
+  # Interface for a GenesisHandler
+  # Allows subclasess specifying routes and subscribers in a DSL
+  class Handler
+    class << self
+      attr_accessor :routes, :subscribers
+      def register_route(match, opts = {}, &block)
+        @routes[match] = { verb: __callee__.to_s, opts: opts, block: block }
+      end
+
+      def register_subscriber(*_args, &block)
+        @subscribers << { block: block }
+      end
+
+      def reset!
+        @subscribers = []
+        @routes = {}
+      end
+
+      def inherited(subclass)
+        subclass.reset!
+        super
+      end
+
+      alias_method :subscribe, :register_subscriber
+    end
+
+    reset!
+  end
+end

data/lib/genesis/protocol/echo/agent.rb

@@ -0,0 +1,10 @@
+require 'genesis/agent'
+
+module Genesis
+  module Echo
+    # Define an agent for Echo protocol
+    class Agent < Genesis::Agent
+      include Protocol
+    end
+  end
+end

data/lib/genesis/protocol/echo/handler.rb

@@ -0,0 +1,14 @@
+require 'genesis/handler'
+
+module Genesis
+  module Echo
+    # A test handler to demonstrate functionality and facilitate testing
+    class Handler < Genesis::Handler
+      include Protocol
+
+      class << self
+        alias_method :say, :register_route
+      end
+    end
+  end
+end

data/lib/genesis/protocol/echo/protocol.rb

@@ -0,0 +1,16 @@
+require 'genesis/protocol'
+
+module Genesis
+  module Echo
+    # Implement a simple protocol to demonstrate
+    # how to write a protocol, and facilitate testing.
+    # In keeping with event machine tradition, it's a simple 'echo' protocol.
+    module Protocol
+      include Genesis::Protocol
+
+      def self.protocol
+        :echo
+      end
+    end
+  end
+end

data/lib/genesis/protocol/echo/server.rb

@@ -0,0 +1,23 @@
+require 'genesis/server'
+
+module Genesis
+  module Echo
+    # Implement a test server to demonstrate functionality and facilitate testing
+    class Server < EM::Connection
+      include Genesis::Server
+      include Protocol
+      def receive_data(data)
+        @channel << data
+        @handle_routes.each do |verb, matchdata|
+          case verb
+          when 'say'
+            matchdata.each do |pattern, blockdata|
+              send_data blockdata[:block].call(data) if data =~ pattern
+            end
+          end
+        end
+        close_connection_after_writing
+      end
+    end
+  end
+end

data/lib/genesis/protocol/echo.rb

@@ -0,0 +1,4 @@
+require 'genesis/protocol/echo/protocol'
+require 'genesis/protocol/echo/server'
+require 'genesis/protocol/echo/handler'
+require 'genesis/protocol/echo/agent'

data/lib/genesis/protocol/http/async_monkeypatch.rb

@@ -0,0 +1,19 @@
+# Monkey-patch async sinatra to support all verb sinatra supports
+# Can remove if this patch gets merged:
+# https://github.com/raggi/async_sinatra/pull/39
+module Sinatra
+  # Monkey patch async to add some more methods
+  module Async
+    def apatch(path, opts = {}, &bk)
+      aroute('PATCH', path, opts, &bk)
+    end
+
+    def alink(path, opts = {}, &bk)
+      aroute('LINK', path, opts, &bk)
+    end
+
+    def aunlink(path, opts = {}, &bk)
+      aroute('UNLINK', path, opts, &bk)
+    end
+  end
+end

data/lib/genesis/protocol/http/handler.rb

@@ -0,0 +1,21 @@
+require 'genesis/handler'
+
+module Genesis
+  module Http
+    # Handle various HTTP verbs
+    class Handler < Genesis::Handler
+      include Protocol
+
+      class << self
+        alias_method :get, :register_route
+        alias_method :post, :register_route
+        alias_method :delete, :register_route
+        alias_method :head, :register_route
+        alias_method :options, :register_route
+        alias_method :patch, :register_route
+        alias_method :link, :register_route
+        alias_method :unlink, :register_route
+      end
+    end
+  end
+end

data/lib/genesis/protocol/http/protocol.rb

@@ -0,0 +1,19 @@
+require 'genesis/protocol'
+
+module Genesis
+  module Http
+    # Implement support for HTTP protocol
+    # Levering sinatra_async, and the fact that thin uses eventmachine
+    module Protocol
+      include Genesis::Protocol
+
+      def self.start_block
+        proc { Server.start_server }
+      end
+
+      def self.protocol
+        :http
+      end
+    end
+  end
+end

data/lib/genesis/protocol/http/server.rb

@@ -0,0 +1,88 @@
+require 'sinatra/async'
+require 'thin'
+
+require 'genesis/server'
+require 'async_monkeypatch'
+
+module Genesis
+  module Http
+    # Implement an HTTP server using async_sinatra and thin
+    class Server < Sinatra::Base
+      include Genesis::Server
+      include Protocol
+      register Sinatra::Async
+
+      # Block to actually start the server
+      def self.start_server
+        app = new(channel: @channel, routes: @handle_routes, views: @args[:views] || [])
+        dispatch = Rack::Builder.app do
+          map '/' do
+            run app
+          end
+        end
+
+        # Since Thin is backed by EventMachine's TCPserver anyways,
+        # This is just a TCPServer like any other - running inside the same EventMachine!
+        Thin::Server.new(@port, '0.0.0.0', dispatch).backend.start
+      end
+
+      # Inject the channel and extended routes
+      def initialize(app = nil, **kwargs)
+        super(app)
+        @channel = kwargs[:channel] || nil
+        @extended_routes = kwargs[:routes] || {}
+        @views = kwargs[:views] || []
+        initialize_routes
+      end
+
+      private
+
+      # Register all routes provided
+      def initialize_routes
+        @extended_routes.each do |verb, matches|
+          matches.each do |match, data|
+            register_route(verb, match, data[:args], data[:block])
+          end
+        end
+      end
+
+      # Injects a route into the sinatra class
+      def register_route(verb, match, opts, block)
+        async_verb = "a#{verb}" # force verb to async verb
+        self.class.send(async_verb, match, opts, &block)
+      end
+
+      helpers do
+        # Enable partial template rendering
+        def partial(template, locals = {})
+          erb(template, layout: false, locals: locals)
+        end
+
+        # Override template search directorys to add spells
+        def find_template(views, *a, &block)
+          Array(@views).each { |v| super(v, *a, &block) }
+        end
+
+        # Define our asynchronous scheduling mechanism, could be anything
+        # Chose EM.defer for simplicity
+        # This powers our asynchronous requests, and keeps us from blocking the main thread.
+        def native_async_schedule(&b)
+          EM.defer(&b)
+        end
+
+        # Needed to properly catch exceptions in async threads
+        def handle_exception!(context)
+          if context.message == 'Sinatra::NotFound'
+            error_msg = "Resource #{request.path} does not exist"
+            puts error_msg
+            ahalt(404, error_msg)
+          else
+            puts context.message
+            puts context.backtrace.join("\n")
+            ahalt(500, 'Uncaught exception occurred')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/genesis/protocol/http.rb

@@ -0,0 +1,3 @@
+require 'genesis/protocol/http/protocol'
+require 'genesis/protocol/http/server'
+require 'genesis/protocol/http/handler'

data/lib/genesis/protocol/snmp/agent.rb

@@ -0,0 +1,10 @@
+require 'genesis/agent'
+
+module Genesis
+  module Snmp
+    # Define an agent for Snmp protocol
+    class Agent < Genesis::Agent
+      include Protocol
+    end
+  end
+end

data/lib/genesis/protocol/snmp/handler.rb

@@ -0,0 +1,14 @@
+require 'genesis/handler'
+
+module Genesis
+  module Snmp
+    # Implement a handler for SNMP traps
+    class Handler < Genesis::Handler
+      include Protocol
+
+      class << self
+        alias_method :trap, :register_route
+      end
+    end
+  end
+end

data/lib/genesis/protocol/snmp/protocol.rb

@@ -0,0 +1,16 @@
+module Genesis
+  module Snmp
+    # Implement support for SNMP protocol using pure-ruby snmp.
+    module Protocol
+      include Genesis::Protocol
+
+      def self.start_block
+        proc { Server.start_server }
+      end
+
+      def self.protocol
+        :snmp
+      end
+    end
+  end
+end

data/lib/genesis/protocol/snmp/server.rb

@@ -0,0 +1,81 @@
+require 'snmp'
+require 'socket'
+
+require 'genesis/server'
+
+module Genesis
+  module Snmp
+    # Implement an SNMP trap handling server
+    class Server < EM::Connection
+      include Genesis::Server
+      include Protocol
+
+      attr_accessor :mib, :community
+
+      def self.start_server
+        commstr = @args[:community] || ''
+        mib_dir = @args[:mib_dir] || SNMP::MIB::DEFAULT_MIB_PATH
+        mib_mods = @args[:mib_mods] || SNMP::Options.default_modules
+        mib = load_modules(mib_mods, mib_dir)
+        EM.open_datagram_socket('0.0.0.0', @port, self) do |conn|
+          conn.mib = mib
+          conn.community = commstr
+          conn.channel = @channel
+          conn.handle_routes = @handle_routes
+        end
+      end
+
+      def self.load_modules(module_list, mib_dir)
+        mib = SNMP::MIB.new
+        module_list.each { |m| mib.load_module(m, mib_dir) }
+        mib
+      end
+
+      def receive_data(data)
+        snmp_trap = handle_trap(data)
+        @channel << snmp_trap
+        route_trap(snmp_trap)
+      end
+
+      private
+
+      def handle_trap(data)
+        source_port, source_ip = Socket.unpack_sockaddr_in(get_peername)
+
+        message = SNMP::Message.decode(data, @mib)
+        snmp_trap = message.pdu
+
+        # If we configured a community and the message wasn't from our community, bail
+        close_connection if @community != '' && @community != message.community
+
+        # Handle inform requests, which want a response
+        handle_inform(snmp_trap, message, source_ip, source_port)
+
+        # Append source ip and return
+        snmp_trap.source_ip = source_ip
+        snmp_trap
+      end
+
+      def handle_inform(snmp_trap, message, source_ip, source_port)
+        return unless snmp_trap.is_a?(SNMP::InformRequest)
+        UDPSocket.new.send(message.response.encode, 0, source_ip, source_port)
+      end
+
+      def route_trap(snmp_trap)
+        @handle_routes.each do |verb, matchdata|
+          case verb
+          when 'trap'
+            route_trap_handler(snmp_trap, matchdata)
+          end
+        end
+      end
+
+      def route_trap_handler(snmp_trap, matchdata)
+        trap_oid = snmp_trap.trap_oid.join('.')
+        matchdata.each do |oid, blockdata|
+          blockdata[:block].call(snmp_trap) if  oid =~ /#{trap_oid}/
+        end
+      end
+    end
+  end
+end

data/lib/genesis/protocol/snmp.rb

@@ -0,0 +1,55 @@
+require 'snmp'
+
+require 'genesis/protocol/snmp/protocol'
+require 'genesis/protocol/snmp/server'
+require 'genesis/protocol/snmp/handler'
+require 'genesis/protocol/snmp/agent'
+
+module Genesis
+  # Common helper methods for protocol
+  module Snmp
+    # Send an SNMP trap, returns the length of the trap message sent
+    def self.send_trap(sys_up_time, trap_oid, object_list = [], **kwargs)
+      manager(kwargs) do |mgr|
+        return mgr.trap_v2(sys_up_time, trap_oid, object_list)
+      end
+    end
+
+    # Send an SNMP get request
+    def self.get(oids = [], **kwargs)
+      manager(kwargs) do |mgr|
+        mgr.get(oids)
+      end
+    end
+
+    # FIXME: implement - these are tricky to test without an actual SNMP server
+    # # Send an SNMP set request
+    # def self.set(bindings = {}, **kwargs)
+    #   manager(kwargs) do |mgr|
+    #     bindings.each do |oid, value|
+    #       mgr.set(SNMP::VarBind.new(oid, value)) # FIXME maybe try and infer type for varbind from value's type to avoid leaky abstraction?
+    #     end
+    #   end
+    # end
+
+    # # Walk an OID table rooted at any oids provided
+    # def self.walk(oids = [], **kwargs)
+    #   manager(kwargs) do |mgr|
+    #     mgr.walk(oids)
+    #   end
+    # end
+
+    private
+
+    # Create a manager and yield it to perform the request
+    def self.manager(args)
+      host = args[:host] || '127.0.0.1'
+      port = args[:port] || 161
+      trapport = args[:trapport] || 162
+      community = args[:community] || 'public'
+      SNMP::Manager.open(Host: host, Port: port, TrapPort: trapport, Community: community) do |mgr|
+        yield mgr
+      end
+    end
+  end
+end

data/lib/genesis/protocol.rb

@@ -0,0 +1,20 @@
+module Genesis
+  # Use some metaprogramming to DRY up protocol definition
+  module Protocol
+    def self.included(base) # rubocop:disable Metrics/MethodLength
+      class << base
+        def included(base)
+          protocol = self
+          base.define_singleton_method(:protocol) { protocol.protocol }
+        end
+
+        def server
+          Kernel.const_get((to_s.split('::')[0..-2] << 'Server').join('::'))
+        end
+
+        def start_block
+        end
+      end
+    end
+  end
+end

data/lib/genesis/reactor.rb

@@ -0,0 +1,169 @@
+## We can dynamically adjust the threadpool like below, if we want to.
+## It should be possible to make the threadpool elastic very easily, though this may impact performance
+# module EventMachine
+#   def self.adjust_threadpool
+#
+#     unless @threadpool.size == @threadpool_size.to_i
+#       spawn_threadpool
+#     end
+#
+# end
+
+require 'em-synchrony'
+
+module Genesis
+  # Main reactor class
+  # rubocop:disable ClassLength
+  class Reactor
+    def initialize(**kwargs)
+      reset
+      @poolsize = kwargs[:threads] || 100 # maximum concurrency - larger = longer boot and shutdown time
+      @protocols = kwargs[:protocols] || {}
+      @views = kwargs[:views] || {}
+      register_handlers(kwargs[:handlers] || {})
+      register_agents(kwargs[:agents] || [])
+    end
+
+    # Convenience wrapper to run indefinitely as daemon
+    def start
+      EM.synchrony do
+        run
+      end
+    end
+
+    # Run the reactor - must be called from EM.run or EM.synchrony
+    def run
+      if running?
+        initialize_protocols
+        initialize_threadpool
+        initialize_sighandlers
+        return true
+      else
+        fail 'Must run from within reactor'
+      end
+    end
+
+    # Check if the reactor is running
+    def running?
+      EM.reactor_running?
+    end
+
+    # Stop the reactor
+    def stop
+      puts 'Shutting down'
+      EM.stop
+    end
+
+    private
+
+    # Reset / initialize instance variables
+    def reset
+      @protocols = {}
+      @servers = {}
+      @routes = {}
+      @subscribers = {}
+      @agents = {}
+      @channels = {}
+    end
+
+    # Initialize signal handlers to cleanly shutdown
+    def initialize_sighandlers
+      trap(:INT)  do
+        stop
+        exit
+      end
+    end
+
+    # Initialize servers for each protocol
+    def initialize_servers
+      @protocols.each do |protocol, _|
+        server = @servers[protocol.protocol]
+        block = server[:start]
+        server[:server].start(server[:port], @routes[protocol.protocol], views: @views, channel: @channels[protocol.protocol], &block)
+      end
+    end
+
+    # Initialize protocols to be handled
+    def initialize_protocols
+      @protocols.each do |protocol, _|
+        server = protocol.server
+        @servers[protocol.protocol] = { server: server, port: @protocols[protocol], start: protocol.start_block }
+        @channels[protocol.protocol] =  EM::Channel.new
+      end
+      initialize_servers
+      initialize_subscribers
+      initialize_agents
+    end
+
+    # Sets the initial size of the threadpool
+    def initialize_threadpool
+      EM.threadpool_size = @poolsize
+    end
+
+    # Sets up agents
+    def initialize_agents
+      @agents.each do |protocol, agents|
+        agents.each do |data|
+          EM.add_periodic_timer(data[:interval]) do
+            EM.defer { data[:block].call(@channels[protocol]) }
+          end
+        end
+      end
+    end
+
+    # Set up subscriptions to channels
+    def initialize_subscribers
+      @subscribers.each do |type, subscribers|
+        channel = @channels[type]
+        if channel
+          subscribers.each do |subscriber|
+            channel.subscribe do |message|
+              EM.defer { subscriber.call(message) }
+            end
+          end
+        end
+      end
+    end
+
+    # Registers all handlers
+    def register_handlers(handlers)
+      handlers.each do |handler|
+        (handler.routes || {}).each do |match, data|
+          register_route(handler.protocol, data[:verb], match, data[:opts], data[:block])
+        end
+
+        (handler.subscribers || []).each do |data|
+          register_subscriber(handler.protocol, data[:block])
+        end
+      end
+    end
+
+    # Registers all agenst
+    def register_agents(agents)
+      agents.each do |agent|
+        (agent.agents || {}).each do |data|
+          register_agent(agent.protocol, data)
+        end
+      end
+    end
+
+    # Registers a route for a given protocol
+    def register_route(protocol, verb, match, args, block)
+      @routes[protocol] ||= {}
+      @routes[protocol][verb] ||= {}
+      @routes[protocol][verb][match] = { block: block, args: args }
+    end
+
+    # Registers a handler for a given protocol
+    def register_subscriber(protocol, block)
+      @subscribers[protocol] ||= []
+      @subscribers[protocol] << block
+    end
+
+    # Registers an agent for a given protocol
+    def register_agent(protocol, method)
+      @agents[protocol] ||= []
+      @agents[protocol] << method
+    end
+  end
+end

data/lib/genesis/server.rb

@@ -0,0 +1,39 @@
+require 'eventmachine'
+
+module Genesis
+  # Abstract base class for all servers
+  module Server
+    attr_accessor :handle_routes, :channel
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Methods to be injected onto the class
+    module ClassMethods
+      def start(port, routes, **kwargs, &block)
+        @port = port
+        @handle_routes = routes || []
+        @channel = kwargs[:channel]
+        @args = kwargs
+
+        # Allow a custom, non EM, server to be run
+        if block_given? && block
+          yield
+        else
+          default_start
+        end
+      end
+
+      private
+
+      def default_start
+        # But default to an EM server if nothing else is provided
+        EM.start_server '0.0.0.0', @port, self do |conn|
+          conn.channel = @channel
+          conn.handle_routes = @handle_routes
+        end
+      end
+    end
+  end
+end

data/lib/genesisreactor.rb

@@ -0,0 +1,7 @@
+require 'find'
+
+Find.find(File.join(File.dirname(File.dirname(__FILE__)), 'lib')) do |f|
+  $LOAD_PATH << f if File.directory? f
+end
+
+require 'genesis/reactor'

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: genesisreactor
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dale Hamel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+- !ruby/object:Gem::Dependency
+  name: async_sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.3
+- !ruby/object:Gem::Dependency
+  name: snmp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: GenesisReactor provides a protocol agnostic framework for implementing
+  simple pub/sub message production and handling.
+email: dale.hamel@srvthe.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/genesis/agent.rb
+- lib/genesis/handler.rb
+- lib/genesis/protocol.rb
+- lib/genesis/protocol/echo.rb
+- lib/genesis/protocol/echo/agent.rb
+- lib/genesis/protocol/echo/handler.rb
+- lib/genesis/protocol/echo/protocol.rb
+- lib/genesis/protocol/echo/server.rb
+- lib/genesis/protocol/http.rb
+- lib/genesis/protocol/http/async_monkeypatch.rb
+- lib/genesis/protocol/http/handler.rb
+- lib/genesis/protocol/http/protocol.rb
+- lib/genesis/protocol/http/server.rb
+- lib/genesis/protocol/snmp.rb
+- lib/genesis/protocol/snmp/agent.rb
+- lib/genesis/protocol/snmp/handler.rb
+- lib/genesis/protocol/snmp/protocol.rb
+- lib/genesis/protocol/snmp/server.rb
+- lib/genesis/reactor.rb
+- lib/genesis/server.rb
+- lib/genesisreactor.rb
+homepage: http://rubygems.org/gems/genesisreactor
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Event driven infrastructor automation framework
+test_files: []
+has_rdoc: