Sutto-marvin 0.1.20081120 → 0.2.0

data/lib/marvin/distributed.rb

@@ -0,0 +1,14 @@
+require 'drb'
+require 'rinda/ring'
+
+
+module Marvin
+  # Distributed tools for Marvin instances.
+  # Uses a tuple space etc + DRb to provide
+  # IRC Processing across the network.
+  module Distributed
+    autoload :RingServer,      'marvin/distributed/ring_server'
+    autoload :DispatchHandler, 'marvin/distributed/dispatch_handler'
+    autoload :DRbClient,       'marvin/distributed/drb_client'
+  end
+end

data/lib/marvin/distributed/dispatch_handler.rb

@@ -0,0 +1,82 @@
+require 'rinda/ring'
+require 'rinda/tuplespace'
+
+DRb.start_service
+
+module Marvin
+  module Distributed
+    
+    # Handler to provide 
+    class DispatchHandler < Marvin::Base
+      
+      LOOKUP_TIMEOUT = 0.5
+      
+      # Tell the client that we shouldn't be dumped.
+      Marvin::AbstractClient.class_eval { include(DRbUndumped) }
+      
+      # Get the ring server - if it exists, we will return the current
+      # instance other wise it follows a few steps to try and find a new
+      # one. Since there can be a delay in getting a response, we'll only
+      # check every 5 messages.
+      def ring_server
+        if @@rs.nil? && (@lookup_attempts ||= 6) > 5
+          @lookup_attempts = 0
+          @@rs = Rinda::RingFinger.finger.lookup_ring(LOOKUP_TIMEOUT)
+          logger.info "Found new ring server => #{@@rs.__drburi}"
+        elsif @@rs.nil?
+          @lookup_attempts += 1
+        end
+        return @@rs
+      rescue RingNotFound
+        @@rs = nil
+      end
+      
+      # Takes an incoming messsage and does all the fancy
+      # Stuff with it.
+      def handle(message, options)
+        # Don't forward lines for the moment to halve the traffic.
+        return if message == :incoming_line
+        super(message, options)
+        dispatch(message, options)
+      end
+      
+      # Attempts to add a message to the current tuple space,
+      # adding it to a message queue if it can't be added.
+      # If there are many items, it will log a warning.
+      # TODO: Improve it to dump messages to disk at a predefined limit.
+      def dispatch(name, options)
+        options[:dispatched_at] ||= Time.now
+        tuple = [:marvin_event, name, options, self.client]
+        begin
+          (@queued_messages ||= []) << tuple
+          if self.ring_server.nil?
+            size = @queued_messages.size
+            if size > 0 && size % 25 == 0
+              logger.warn "Dispatch handler queue is currently holding #{size} items"
+            end
+          else
+            @queued_messages.dup.each do |t|
+              ring_server.write(t)
+              @queued_messages.delete(t)
+            end
+          end
+        rescue
+          # Reset the ring finger to the next choice.
+          logger.debug "Ring server unavailable, resetting..."
+          @@rs = nil
+        end
+      end
+      
+      # Register this as a handler, but only if we're
+      # running in "client mode" - in other words, we
+      # want to make sure it won't start up an infinite
+      # loop.
+      def self.register!(*args)
+        # DO NOT register if this is not a normal client.
+        return unless Marvin::Loader.type == :client
+        super
+      end
+      
+    end
+  end
+end

data/lib/marvin/distributed/drb_client.rb

@@ -0,0 +1,78 @@
+module Marvin
+  module Distributed
+    # A method for operating on marvin objects.
+    class DRbClient
+      
+      # Wait 1 second on a lookup.
+      LOOKUP_TIMEOUT = 1
+      
+      class << self
+        
+        @@handlers = []
+        attr_accessor :stopped
+        
+        def register_handler(handler)
+          @@handlers << handler unless handler.nil? || !handler.respond_to?(:handle)
+        end
+        
+        def dispatch(name, opts, client)
+          Marvin::Logger.debug "Processing Event: #{name}"
+          full_handler_name = :"handle_#{name.to_s.underscore}"
+          @@handlers.each do |handler|
+            has_client = handler.respond_to?(:client=)
+            handler.client = client if has_client
+            if handler.respond_to?(full_handler_name)
+              handler.send(full_handler_name, opts)
+            else
+              handler.handle name, opts
+            end
+            handler.client = nil if has_client
+          end
+        rescue HaltHandlerProcessing => e
+          Marvin::Logger.info "Halting processing chain"
+        rescue Exception => e
+          Marvin::ExceptionTracker.log(e)
+        end
+        
+        # Starts up a drb processor / client, and walks through the process of dealing
+        # with it / processing events.
+        def run
+          self.stopped = false
+          Marvin::Logger.info "Starting up DRb Client"
+          DRb.start_service
+          # Loop through, making sure we have a valid
+          # RingFinger and then process events as they
+          # appear.
+          enter_loop!
+        end
+        
+        def stop
+          self.stopped = true
+        end
+        
+        def ring_server
+          @ring_server = Rinda::RingFinger.finger.lookup_ring(LOOKUP_TIMEOUT) if @ring_server.nil?
+          return @ring_server
+        rescue RingNotFound
+          @ring_server = nil
+        end
+        
+        def enter_loop!
+          Marvin::Logger.info "Entering processing loop"
+          while !self.stopped
+            begin
+              unless self.ring_server.blank?
+                event = self.ring_server.take([:marvin_event, nil, nil, nil], 5)
+                dispatch(*event[1..-1]) unless event.blank?
+              end
+            rescue
+              # Reset the ring server on event of connection refused etc.
+              @ring_server = nil
+            end
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/marvin/distributed/ring_server.rb

@@ -0,0 +1,41 @@
+require 'rinda/ring'
+require 'rinda/tuplespace'
+
+module Marvin
+  module Distributed
+    class RingServer
+      
+      attr_accessor :tuple_space, :ring_server
+      cattr_accessor :logger
+      self.logger = Marvin::Logger
+      
+      def initialize
+        self.tuple_space = Rinda::TupleSpace.new
+        if Marvin::Settings.log_level == :debug
+          observer = self.tuple_space.notify('write', [:marvin_event, nil, nil, nil])
+          Thread.start do
+            observer.each do |i|
+              event_name, args = i[1][1..2]
+              Marvin::Logger.logger.debug "Marvin event added - #{event_name.inspect} w/ #{args.inspect}"
+            end
+          end
+        end
+        self.ring_server = Rinda::RingServer.new(self.tuple_space)
+      end
+      
+      def self.run
+        begin
+          logger.info "Starting up DRb"
+          drb_server = DRb.start_service
+          logger.info "Creating TupleSpace & Ring Server Instances - Running on #{DRb.uri}"
+          self.new
+          logger.info "Started - Joining thread."
+          DRb.thread.join
+        rescue
+          logger.fatal "Error starting ring server - please ensure another instance isn't already running."
+        end
+      end
+      
+    end
+  end
+end

data/lib/marvin/exception_tracker.rb

@@ -2,7 +2,7 @@ module Marvin
   class ExceptionTracker
   
     cattr_accessor :logger
-    self.logger = Marvin::Logger.logger
+    self.logger = Marvin::Logger
   
     def self.log(e)
       logger.fatal "Exception raised inside Marvin Instance."

data/lib/marvin/irc.rb

@@ -1,9 +1,8 @@
 module Marvin
   module IRC
-    autoload :Client,         'marvin/irc/client'
-    autoload :Event,          'marvin/irc/event'
-    autoload :AbstractServer, 'marvin/irc/abstract_server'
-    autoload :BaseServer,     'marvin/irc/base_server'
-    autoload :Replies,        'marvin/irc/replies'
+    autoload :Client,  'marvin/irc/client'
+    autoload :Event,   'marvin/irc/event'
+    autoload :Server,  'marvin/irc/server'
+    autoload :Replies, 'marvin/irc/replies'
   end
 end

data/lib/marvin/irc/client.rb

@@ -46,6 +46,8 @@ module Marvin::IRC
   # handler as the only argument.
   class Client < Marvin::AbstractClient
     cattr_accessor :stopped
+    self.stopped = false
+    
     attr_accessor :em_connection
     
     class EMConnection < EventMachine::Protocols::LineAndTextProtocol
@@ -84,10 +86,12 @@ module Marvin::IRC
     
     # Starts the EventMachine loop and hence starts up the actual
     # networking portion of the IRC Client.
-    def self.run
+    def self.run(force = false)
+      return if self.stopped && !force
       self.setup # So we have options etc
       settings = YAML.load_file(Marvin::Settings.root / "config/connections.yml")
       if settings.is_a?(Hash)
+        # Use epoll if available
         EventMachine.epoll
         EventMachine::run do
           settings.each do |name, options|
@@ -105,7 +109,6 @@ module Marvin::IRC
     def self.connect(opts = {})
       logger.info "Connecting to #{opts[:server]}:#{opts[:port]} - Channels: #{opts[:channels].join(", ")}"
       EventMachine::connect(opts[:server], opts[:port], EMConnection, opts)
-      logger.info "Connection created for #{opts[:server]}:#{opts[:port]}"
     end
     
     def self.stop
@@ -118,6 +121,14 @@ module Marvin::IRC
       self.stopped = true
     end
     
+    def self.add_reconnect(opts = {})
+      Marvin::Logger.warn "Adding entry to reconnect to #{opts[:server]}:#{opts[:port]} in 15 seconds"
+      EventMachine::add_timer(15) do
+        Marvin::Logger.warn "Attempting to reconnect to #{opts[:server]}:#{opts[:port]}"
+        Marvin::IRC::Client.connect(opts)
+      end
+    end
+    
     # Registers a callback handle that will be periodically run.
     def periodically(timing, event_callback)
       callback = proc { self.dispatch event_callback.to_sym }

data/lib/marvin/irc/server.rb

@@ -0,0 +1,57 @@
+module Marvin
+  module IRC
+    module Server
+      
+      # Server utilities
+      autoload :NamedStore,         'marvin/irc/server/named_store'
+      
+      # Store each user
+      UserStore = NamedStore.new(:nicks, :user) do
+        def nick_taken?(nick)
+          has_key?(nick)
+        end
+        
+        def each_user_except(user)
+          self.each_user do |u|
+            yield u unless user == u 
+          end
+        end
+      end
+      
+      # Store each channel
+      ChannelStore = NamedStore.new(:names, :channel)
+      
+      autoload :Channel,            'marvin/irc/server/channel'
+      # The actual network connection
+      autoload :BaseConnection,     'marvin/irc/server/base_connection'
+      # An our implementations of protocol-specific stuff.
+      autoload :AbstractConnection, 'marvin/irc/server/abstract_connection'
+      autoload :UserConnection,     'marvin/irc/server/user_connection'
+      autoload :ServerConnection,   'marvin/irc/server/server_connection'
+      # Extensions for each part
+      autoload :User,               'marvin/irc/server/user'
+      
+      # call start_server w/ the default options
+      # and inside an EM::run block.
+      def self.run
+        EventMachine::run do
+          Marvin::Logger.info "Starting server..."
+          start_server :bind_addr => "0.0.0.0"
+        end
+      end
+      
+      # Starts the server with a set of given options
+      def self.start_server(opts = {})
+        opts[:started_at] ||= Time.now
+        opts[:host]       ||= self.host_name
+        opts[:port]       ||= 6667
+        EventMachine::start_server(opts[:bind_addr] || opts[:host], opts[:port], BaseConnection, opts)
+      end
+      
+      def self.host_name
+        @@host_name ||= Socket.gethostname
+      end
+      
+    end
+  end
+end

data/lib/marvin/irc/server/abstract_connection.rb

@@ -0,0 +1,79 @@
+module Marvin::IRC::Server
+  class AbstractConnection
+    include Marvin::Dispatchable
+    
+    cattr_accessor :connections, :logger, :alive
+    self.connections = []
+    self.logger = Marvin::Logger
+    
+    attr_accessor :connection
+    
+    # Create a new connection with a given parent
+    # and an incoming buffer of messages
+    def initialize(parent, buffer = [])
+      @connection = parent
+      buffer.each { |line| receive_line(line) }
+    end
+  
+    def receive_line(line)
+      dispatch :incoming_line, :line => line
+      event = Marvin::Settings.default_parser.parse(line)
+      dispatch(event.to_incoming_event_name, event.to_hash) unless event.nil?
+    end
+    
+    def send_line(line)
+      @connection.send_line(line)
+    end
+    
+    def process_connect
+      @alive = true
+      # Send the welcome notice / auth command.
+      command :NOTICE, "AUTH", ":Marvin v#{Marvin.version} initialized, welcome."
+      dispatch :client_connected, :client => self
+    end
+    
+    def process_disconnect
+      @@connections.delete(self)
+      @alive = false
+      dispatch :client_disconnected, :client => self
+    end
+    
+    class << self
+      
+      # Return an array of all registered handlers, stored in the
+      # class variable @@handlers. Used inside the #handlers instance
+      # method as well as inside things such as register_handler.
+      def handlers
+        (@@handlers ||= {})[self] ||= []
+      end
+      
+      # Assigns a new array of handlers and assigns each.
+      def handlers=(new_value)
+        (@@handlers ||= {})[self] = []
+        new_value.to_a.each { |h| register_handler h }
+      end
+      
+    end
+    
+    private
+    
+    def command(name, *args)
+      opts = args.extract_options!
+      formatted = [name.to_s.upcase, *args].join(" ")
+      formatted = ":#{opts[:prefix]} #{formatted}" if opts[:prefix]
+      send_line formatted
+    end
+    
+    def peer_name
+      return @peer_name unless @peer_name.blank?
+      sock_addr = @connection.get_peername
+      begin
+        @peer_name = Socket.getnameinfo(sock_addr, Socket::NI_NAMEREQD).first
+      rescue
+        @peer_name = Socket.getnameinfo(sock_addr).first
+      end
+      return @peer_name
+    end
+  
+  end
+end

data/lib/marvin/irc/server/base_connection.rb

@@ -0,0 +1,66 @@
+require 'eventmachine'
+
+module Marvin
+  module IRC
+    module Server
+      class BaseConnection < EventMachine::Protocols::LineAndTextProtocol
+        
+        attr_accessor :port, :host, :started_at
+        
+        # Our initialize method
+        def initialize(opts = {})
+          super
+          @buffer = []
+          @port = opts[:port]
+          @host = opts[:host]
+          @started_at = opts[:started_at] || Time.now
+        end
+        
+        attr_accessor :connection_implementation, :buffer
+        
+        # Receive the line, processing as it needs to be.
+        # Not that we have a conditional check to setup
+        # the correct connection
+        def receive_line(line)
+          Marvin::Logger.debug "<< #{line}"
+          if !@connection_implementation.nil?
+            @connection_implementation.receive_line(line)
+          elsif line[0..3] == "USER"
+            @buffer << line
+            self.connection_implementation = UserConnection.new(self, @buffer)
+            @buffer = nil
+          elsif line[0..5] == "SERVER"
+            @buffer << line
+            self.connection_implementation = ServerConnection.new(self, @buffer)
+            @buffer = nil
+          else
+            @buffer << line
+          end
+        end
+        
+        def send_line(line)
+          Marvin::Logger.debug ">> #{line.strip}"
+          line += "\r\n" unless line[-2..-1] == "\r\n"
+          send_data line
+        end
+        
+        def kill_connection!
+          close_connection_after_writing
+        end
+        
+        # Do things on the unbind
+        def unbind
+          super # Call the old version
+          @connection_implementation.process_disconnect
+        end
+        
+        # Do things on the connection implementation
+        def post_init
+          super
+          send_line "NOTICE AUTH :Marvin Server v#{Marvin.version} initialized, welcome."
+        end
+        
+      end
+    end
+  end
+end