marvin 0.8.0.0

data/lib/marvin/distributed/handler.rb

@@ -0,0 +1,85 @@
+module Marvin
+  module Distributed
+    class Handler < Marvin::Base
+      
+      
+      EVENT_WHITELIST = [:incoming_message, :incoming_action]
+      QUEUE_PROCESSING_SPACING = 3
+      
+      attr_accessor :message_queue
+      
+      def initialize
+        super
+        @message_queue = []
+      end
+      
+      def handle(message, options)
+        return unless EVENT_WHITELIST.include?(message)
+        super(message, options)
+        dispatch(message, options)
+      end
+      
+      def dispatch(name, options, client = self.client)
+        return if client.blank?
+        server = Marvin::Distributed::Server.next
+        if server.blank?
+          logger.debug "Distributed handler is currently busy - adding to queue"
+          # TODO: Add to queued messages, wait
+          @message_queue << [name, options, client]
+          run! unless running?
+        else
+          server.dispatch(client, name, options)
+        end
+      rescue Exception => e
+        logger.warn "Error dispatching #{name}"
+        Marvin::ExceptionTracker.log(e)
+      end
+      
+      def process_queue
+        count = [@message_queue.size, Server.free_connections.size].min
+        logger.debug "Processing #{count} item(s) from the message queue"
+        count.times { |item| dispatch(*@message_queue.shift) }
+        if @message_queue.empty?
+          logger.debug "The message queue is now empty"
+        else
+          logger.debug "The message queue still has #{count} item(s)"
+        end
+        check_queue_progress
+      end
+      
+      def running?
+        @running_timer.present?
+      end
+      
+      def run!
+        @running_timer = EventMachine::PeriodicTimer.new(QUEUE_PROCESSING_SPACING) { process_queue }
+      end
+      
+      def check_queue_progress
+        if @message_queue.blank? && running?
+          @running_timer.cancel
+          @running_timer = nil
+        elsif @message_queue.present? && !running?
+          run!
+        end
+      end
+      
+      class << self
+        
+        def whitelist_event(name)
+          EVENT_WHITELIST << name.to_sym
+          EVENT_WHITELIST.uniq!
+        end
+        
+        def register!(*args)
+          # DO NOT register if this is  not a normal client.
+          return unless Marvin::Loader.client?
+          logger.info "Registering distributed handler on #{Marvin::Settings.client}"
+          super
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/marvin/distributed/protocol.rb

@@ -0,0 +1,88 @@
+module Marvin
+  module Distributed
+    class Protocol < EventMachine::Protocols::LineAndTextProtocol
+      is :loggable
+      
+      class_inheritable_accessor :handler_methods
+      self.handler_methods = {}
+      
+      attr_accessor :callbacks
+      
+      def receive_line(line)
+        line.strip!
+        logger.debug "<< #{line}"
+        response = JSON.parse(line)
+        handle_response(response)
+      rescue JSON::ParserError
+        logger.debug "JSON parsing error for #{line.inspect}"
+      rescue Exception => e
+        Marvin::ExceptionTracker.log(e)
+      end
+      
+      def send_message(name, arguments = {}, &callback)
+        logger.debug "Sending #{name.inspect} to #{self.host_with_port}"
+        payload = {
+          "message" => name.to_s,
+          "options" => arguments,
+          "sent-at" => Time.now
+        }
+        payload.merge!(options_for_callback(callback))
+        payload = JSON.dump(payload)
+        logger.debug ">> #{payload}"
+        send_data "#{payload}\n"
+      end
+      
+      def handle_response(response)
+        logger.debug "Handling response in distributed protocol (response => #{response.inspect})"
+        return unless response.is_a?(Hash) && response.has_key?("message")
+        options = response["options"] || {}
+        process_response_message(response["message"], options)
+      end
+      
+      def host_with_port
+        @host_with_port ||= begin
+          port, ip = Socket.unpack_sockaddr_in(get_peername)
+          "#{ip}:#{port}"
+        end
+      end
+      
+      protected
+      
+      def options_for_callback(blk)
+        return {} if blk.blank?
+        cb_id = "callback-#{seld.object_id}-#{Time.now.to_f}"
+        count = 0
+        count += 1 while @callbacks.has_key?(Digest::SHA256.hexdigest("#{cb_id}-#{count}"))
+        final_id = Digest::SHA256.hexdigest("#{cb_id}-#{count}")
+        @callbacks ||= {}
+        @callbacks[final_id] = blk
+        {"callback-id" => final_id}
+      end
+      
+      def process_callback(hash)
+        @callbacks ||= {}
+        if hash.is_a?(Hash) && hash.has_key?("callback-id")
+          callback = @callbacks.delete(hash["callback-id"])
+          callback.call(self, hash)
+        end
+      end
+      
+      def process_response_message(message, options)
+        method = self.handler_methods[message.to_s]
+        if method.present? && respond_to?(method)
+          logger.debug "Dispatching #{message} to #{method}"
+          send(method, options)
+        else
+          logger.warn "Got unknown message (#{message}) with options: #{options.inspect}"
+        end
+      end
+      
+      def self.register_handler_method(name, method = nil)
+        name = name.to_s
+        method ||= "handle_#{name}".to_sym
+        self.handler_methods[name] = method
+      end
+      
+    end
+  end
+end

data/lib/marvin/distributed/server.rb

@@ -0,0 +1,154 @@
+require 'json'
+require 'digest/sha2'
+require 'eventmachine'
+require 'socket'
+
+module Marvin
+  module Distributed
+    class Server < Protocol
+      
+      register_handler_method :completed
+      register_handler_method :exception
+      register_handler_method :action
+      register_handler_method :authenticate
+      
+      cattr_accessor :free_connections, :action_whitelist
+      self.free_connections = []
+      self.action_whitelist = [:nick, :pong, :action, :msg, :quit, :part, :join, :command]
+      
+      attr_accessor :processing, :configuration, :using_tls
+      
+      def initialize(*args)
+        @configuration = args.last.is_a?(Marvin::Nash) ? args.pop : Marvin::nash.new
+        super(*args)
+      end
+      
+      def post_init
+        super
+        @callbacks = {}
+        logger.info "Got distributed client connection with #{self.host_with_port}"
+        if should_use_tls?
+          start_tls
+        else
+          complete_processing
+        end
+      end
+      
+      def ssl_handshake_completed
+        complete_processing if should_use_tls?
+      end
+      
+      def unbind
+        logger.info "Lost distributed client connection with #{self.host_with_port}"
+        @@free_connections.delete(self)
+        super
+      end
+      
+      def dispatch(client, name, options)
+        @processing = true
+        send_message(:event, {
+          "event-name"    => name.to_s,
+          "event-options" => options,
+          "client-host"   => client.host_with_port,
+          "client-nick"   => client.nickname
+        })
+      end
+      
+      def handle_authenticate(options = {})
+        return unless requires_auth?
+        logger.info "Attempting authentication for distributed client"
+        if options["token"].present? && options["token"] == configuration.token
+          @authenticated = true
+          send_message(:authenticated)
+        else
+          send_message(:authentication_failed)
+        end
+      end
+      
+      def handle_completed(options = {})
+        return if fails_auth!
+        logger.debug "Completed message from #{self.host_with_port}"
+        complete_processing
+      end
+      
+      def handle_exception(options = {})
+        return if fails_auth!
+        logger.info "Handling exception on #{self.host_with_port}"
+        name      = options["name"]
+        message   = options["message"]
+        backtrace = options["backtrace"]
+        logger.warn "Error in remote client - #{name}: #{message}"
+        [*backtrace].each { |line| logger.warn "--> #{line}" } if backtrace.present?
+      end
+      
+      def handle_action(options = {})
+        return if fails_auth!
+        logger.debug "Handling action from on #{self.host_with_port}"
+        server    = lookup_client_for(options["client-host"])
+        action    = options["action"]
+        arguments = [*options["arguments"]]
+        return if server.blank? || action.blank?
+        begin
+          a = action.to_sym
+          if self.action_whitelist.include?(a)
+            server.send(a, *arguments) if server.respond_to?(a)
+          else
+            logger.warn "Client attempted invalid action #{a.inspect}"
+          end
+        rescue Exception => e
+          Marvin::ExceptionTracker.log(e)
+        end
+      end
+      
+      def complete_processing
+        @@free_connections << self
+        @processing = false
+      end
+      
+      def start_processing
+        @processing = true
+      end
+      
+      def lookup_client_for(key)
+        Marvin::IRC::Client.connections.detect do |c|
+          c.host_with_port == key
+        end
+      end
+      
+      def requires_auth?
+        configuration.token? && !authenticated?
+      end
+      
+      def authenticated?
+        @authenticated ||= false
+      end
+      
+      def should_use_tls?
+        @using_tls ||= configuration.encrypted?
+      end
+      
+      def fails_auth!
+        if requires_auth?
+          logger.debug "Authentication missing for distributed client"
+          send_message(:unauthorized)
+          close_connection_after_writing
+          return true
+        end
+      end
+      
+      def self.start
+        opts = Marvin::Settings.distributed || Marvin::Nash.new
+        opts = opts.server || Marvin::Nash.new
+        host = opts.host  || "0.0.0.0"
+        port = (opts.port || 8943).to_i
+        logger.info "Starting distributed server on #{host}:#{port} (requires authentication = #{opts.token?})"
+        EventMachine.start_server(host, port, self, opts)
+      end
+      
+      def self.next
+        @@free_connections.shift
+      end
+      
+    end
+  end
+end

data/lib/marvin/dsl.rb

@@ -0,0 +1,103 @@
+# Handy Dandy DSL style stuff for Marvin
+module Marvin
+  class DSL
+  
+    class Proxy < Perennial::Proxy
+      
+      def initialize(klass)
+        @prototype_klass = Class.new(klass)
+        @mapping         = {}
+      end
+      
+      def define_shortcut(name, method_name)
+        @mapping[name] = method_name
+      end
+      
+      def shortdef(hash = {})
+        hash.each_pair { |k,v| define_shortcut(k, v) }
+      end
+      
+      
+      
+      def initialize_class!
+        @klass = Class.new(@prototype_klass)
+      end
+      
+      def to_instance
+        @klass.new
+      end
+      
+      def to_class
+        @klass
+      end
+      
+      def method_missing(name, *args, &blk)
+        name = name.to_sym
+        if @mapping.has_key?(name)
+          @klass.define_method(@mapping[name], &blk)
+        else
+          @klass.send(name, *args, &blk)
+        end
+      end
+      
+    end
+  
+    def initialize(&blk)
+      instance_eval(&blk)
+    end
+    
+    def logging(&blk)
+      call_prototype(:logging, &blk).register!
+    end
+    
+    def handler(&blk)
+      call_prototype(:handler, &blk).register!
+    end
+    
+    def commands(&blk)
+      call_prototype(:commands, &blk).register!
+    end
+    
+    def configure(&blk)
+      Marvin::Settings.client.configure(&blk)
+    end
+    
+    def server(name, port = nil)
+      name = name.to_s.dup
+    end
+      
+    
+    
+    protected
+    
+    def initialize_prototypes
+      prototype_for(:logging, Marvin::LoggingHandler) do
+        shortdef :setup    => :setup_logging,
+                 :teardown => :teardown_logging,
+                 :incoming => :log_incoming,
+                 :outgoing => :log_outgoing,
+                 :message  => :log_message
+      end
+      prototype_for(:handler, Marvin::Base) do
+        map :on      => :on_event,
+            :numeric => :on_numeric
+      end
+      prototype_for(:handler, Marvin::CommandHandler)
+    end
+    
+    def prototype_for(name, klass, &blk)
+      @prototypes ||= {}
+      p = Proxy.new(klass)
+      p.instance_eval(&blk)
+      @prototypes[name] = p
+    end
+    
+    def call_prototype(name, &blk)
+      p = @prototypes[name]
+      p.initialize_class!
+      p.instance_eval(&blk)
+      return p.to_class
+    end
+    
+  end
+end

data/lib/marvin/exception_tracker.rb

@@ -0,0 +1,19 @@
+module Marvin
+  class ExceptionTracker
+  
+    is :loggable
+    
+    cattr_accessor :log_exception_proc
+    self.log_exception_proc = proc { |e| e }
+  
+    def self.log(e)
+      logger.fatal "Oh noes cap'n - we have an exception!."
+      logger.fatal "#{e.class.name}: #{e.message}"
+      e.backtrace.each do |line|
+        logger.fatal line
+      end
+      @@log_exception_proc.call(e)
+    end
+  
+  end
+end