Sutto-marvin 0.4.0 → 0.8.0.0

data/handlers/logging_handler.rb

@@ -1,89 +0,0 @@
-# A Simple Channel Logger, built for the 
-# #offrails community. Please note that this
-# relies on models etc. inside the Rails App.
-# it's suited for modification of subclassing
-# if you wish to write your own Channel Logger.
-# I plan on open sourcing the app sometime in
-# the near future.
-class LoggingHandler < Marvin::CommandHandler
-  
-  class_inheritable_accessor :connection, :setup
-  attr_accessor :listening, :users
-  
-  def initialize
-    super
-    logger.debug "Setting up LoggingHandler"
-    self.setup!
-    self.users = {}
-  end
-  
-  # Control
-  
-  exposes :listen, :earmuffs
-  
-  desc "Makes me listen up and take not of what you're saying."
-  def listen(data)
-    unless listening?
-      @listening = true
-      reply "Busted! I heard _everything_ you said ;)"
-    else
-      reply "Uh, You never asked me to put my earmuffs on?"
-    end
-  end
-  
-  desc "Sends me off into a corner with my ear muffs so you can have your discussions in peace"
-  def earmuffs(data)
-    if listening?
-      @listening = false
-      reply "Oh hai, I'm not listening anymore."
-    else
-      reply "I've already put the earmuffs on!"
-    end
-  end
-  
-  def listening?
-    @listening
-  end
-  
-  # The actual logging
-  
-  on_event :incoming_message do
-    log_message(options.nick, options.target, options.message)
-  end
-  
-  on_event :outgoing_message do
-    log_message(client.nickname, options.target, options.message)
-  end
-  
-  on_event :incoming_action do
-    log_message(options.nick, options.target, "ACTION \01#{options.message}\01")
-  end
-  
-  def log_message(from, to, message)
-    return unless listening?
-    ensure_connection_is_alive # Before Logging, ensure that the connection is alive.
-    self.users[from.strip] ||= IrcHandle.find_or_create_by_name(from.strip)
-    self.users[from.strip].messages.create :message => message, :target => to
-  end
-  
-  # Our General Tasks
-  
-  def setup!
-    return true if self.setup
-    load_prerequisites
-    self.setup = true
-    self.listening = true
-  end
-  
-  def load_prerequisites
-    require File.join(Marvin::Settings.rails_root, "config/environment")
-  end
-  
-  def ensure_connection_is_alive
-    unless ActiveRecord::Base.connection.active?
-      ActiveRecord::Base.connection.reconnect!
-    end
-  end
-  
-  
-end

data/lib/marvin/core_ext.rb

@@ -1,11 +0,0 @@
-class File
-  def self.present_dir
-    File.dirname(__FILE__)
-  end
-end
-
-class String
-  def /(*args)
-    File.join(self, *args)
-  end
-end

data/lib/marvin/daemon.rb

@@ -1,71 +0,0 @@
-module Marvin
-  class Daemon
-    class << self
-      
-      def alive?(pid)
-        return Process.getpgid(pid) != -1
-      rescue Errno::ESRCH
-        return false
-      end
-      
-      def kill_all(type = :all)
-        if type == :all
-          files = Dir[Marvin::Settings.root / "tmp/pids/*.pid"]
-          files.each { |f| kill_all_from f }
-        elsif type.is_a?(Symbol)
-          kill_all_from(pid_file_for(type))
-        end
-        return nil
-      end
-      
-      def daemonize!
-        exit if fork
-        Process.setsid
-        exit if fork
-        self.write_pid
-        File.umask 0000
-        STDIN.reopen  "/dev/null"
-        STDOUT.reopen "/dev/null", "a"
-        STDERR.reopen STDOUT
-        Marvin::Settings.verbose = false
-      end
-      
-      def cleanup!
-        f = pids_file_for(Marvin::Loader.type)
-        FileUtils.rm_f(f) if (pids_from(f) - Process.pid).blank?
-      end
-      
-      def pids_for_type(type)
-        pids_from(pid_file_for(type))
-      end
-      
-      protected
-
-      def kill_all_from(file)
-        pids = pids_from(file)
-        pids.each { |p| Process.kill("TERM", p) unless p == Process.pid }
-        FileUtils.rm_f(file)
-      rescue => e
-        STDOUT.puts e.inspect
-      end
-
-      def pid_file_for(type)
-        Marvin::Settings.root / "tmp" / "pids" / "marvin-#{type.to_s.underscore}.pid"
-      end
-
-      def pids_from(file)
-        return [] unless File.exist?(file)
-        pids = File.read(file)
-        pids = pids.split("\n").map { |l| l.strip.to_i(10) }.select { |p| alive?(p) }
-      end
-
-      def write_pid
-        f = pid_file_for(Marvin::Loader.type)
-        pids = pids_from(f)
-        pids << Process.pid unless pids.include?(Process.pid)
-        File.open(f, "w+") { |f| f.puts pids.join("\n") }
-      end
-      
-    end
-  end
-end

data/lib/marvin/data_store.rb

@@ -1,73 +0,0 @@
-require 'json'
-
-module Marvin
-  # Implements a simple datastore interface, designed to make
-  # it easy to develop handlers which have persistent data.
-  class DataStore
-    
-    cattr_accessor :logger, :registered_stores
-    self.logger = Marvin::Logger.logger
-    self.registered_stores = {}
-    
-    # Returns the path to the data store relative to this file.
-    # Used when loading / dumping the data.
-    def self.datastore_location
-      path =  Marvin::Settings[:datastore_location] ? Marvin::Settings.datastore_location : "tmp/datastore.json"
-      return Marvin::Settings.root / path
-    end
-    
-    # Dump the current data store contents to file.
-    def self.dump!
-      File.open(self.datastore_location, "w+") do |f|
-        f.write self.registered_stores.to_json
-      end
-    end
-    
-    # Load the current data store contents from file.
-    def self.load!
-      results = {}
-      if File.exists?(self.datastore_location)
-        begin
-          json = JSON.load(File.read(self.datastore_location))
-          results = json if json.is_a?(Hash)
-        rescue JSON::ParserError
-        end
-      end
-      self.registered_stores = results
-    end
-    
-    
-    # For each individual datastore.
-    
-    attr_accessor :name
-    
-    def initialize(name)
-      self.name = name.to_s
-      self.registered_stores ||= {}
-      self.registered_stores[self.name] ||= {}
-    end
-    
-    def [](key)
-      ((self.registered_stores||={})[self.name]||={})[key.to_s]
-    end
-    
-    def []=(key,value)
-      self.registered_stores[self.name][key.to_s] = value
-    end
-    
-    def method_missing(name, *args, &blk)
-      if name.to_s =~ /^(.*)=$/i
-        self[$1.to_s] = args.first
-      elsif self.registered_stores[self.name].has_key?(name.to_s)
-        return self.registered_stores[self.name][name.to_s]
-      else
-        super(name, *args, &blk)
-      end
-    end
-    
-    def to_hash
-      self.registered_stores[self.name]
-    end
-    
-  end
-end

data/lib/marvin/dispatchable.rb

@@ -1,99 +0,0 @@
-module Marvin
-  # = Marvin::Dispatchable
-  # A Generic mixin which lets you define an object
-  # Which accepts handlers which can have arbitrary
-  # events dispatched.
-  # == Usage
-  #
-  #   class X
-  #     include Marvin::Dispatchable
-  #     self.handlers << SomeHandler.new
-  #   end
-  #   X.new.dispatch(:name, {:args => "Values"})
-  #
-  # Will first check if SomeHandler#handle_name exists,
-  # calling handle_name({:args => "Values"}) if it does,
-  # otherwise calling SomeHandler#handle(:name, {:args => "Values"})
-  module Dispatchable
-    
-    def self.included(parent)
-      parent.class_eval do
-        include InstanceMethods
-        extend  ClassMethods
-      end
-    end
-    
-    module InstanceMethods
-      
-      # Returns the handlers registered on this class,
-      # used inside +dispatch+. Note that it will call
-      # dup on each of the objects to get a new instance.
-      # please ensure your object acts accordingly.
-      def handlers
-        @handlers ||= self.class.handlers.map { |h| h.dup }
-      end
-      
-      # Dispatch an 'event' with a given name to the handlers
-      # registered on the current class. Used as a nicer way of defining
-      # behaviours that should occur under a given set of circumstances.
-      # == Params
-      # +name+: The name of the current event
-      # +opts+: an optional hash of options to pass
-      def dispatch(name, opts = {})
-        # The full handler name is the method we call given it exists.
-        full_handler_name = :"handle_#{name.to_s.underscore}"
-        # First, dispatch locally if the method is defined.
-        if self.respond_to?(full_handler_name)
-          self.send(full_handler_name, opts)
-        end
-        # Iterate through all of the registered handlers,
-        # If there is a method named handle_<event_name>
-        # defined we sent that otherwise we call the handle
-        # method on the handler. Note that the handle method
-        # is the only required aspect of a handler. An improved
-        # version of this would likely cache the respond_to?
-        # call.
-        self.handlers.each do |handler|
-          if handler.respond_to?(full_handler_name)
-            handler.send(full_handler_name, opts)
-          else
-            handler.handle name, opts
-          end
-        end
-      # If we get the HaltHandlerProcessing exception, we
-      # catch it and continue on our way. In essence, we
-      # stop the dispatch of events to the next set of the
-      # handlers.
-      rescue HaltHandlerProcessing => e
-        Marvin::Logger.info "Halting processing chain"
-      rescue Exception => e
-        Marvin::ExceptionTracker.log(e)
-      end
-      
-    end
-    
-    module ClassMethods
-      
-      # 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 ||= []
-      end
-      
-      # Assigns a new array of handlers and assigns each.
-      def handlers=(new_value)
-        @@handlers = []
-        new_value.to_a.each { |h| register_handler h }
-      end
-      
-      # Appends a handler to the list of handlers for this object.
-      # Handlers are called in the order they are registered.
-      def register_handler(handler)
-        self.handlers << handler unless handler.nil? || !handler.respond_to?(:handle)
-      end
-      
-    end
-    
-  end
-end

data/lib/marvin/distributed/dispatch_handler.rb

@@ -1,83 +0,0 @@
-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, Marvin::Settings.distributed_namespace, 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
-            logger.debug "Writing #{@queued_messages.size} message to the ring server"
-            @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

@@ -1,78 +0,0 @@
-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, Marvin::Settings.distributed_namespace, nil, nil, nil], 2)
-                dispatch(*event[2..-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

@@ -1,41 +0,0 @@
-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, Marvin::Settings.distributed_namespace, nil, nil, nil])
-          Thread.start do
-            observer.each do |i|
-              event_name, args = i[1][2..3]
-              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/handler.rb

@@ -1,12 +0,0 @@
-module Marvin
-  module Handler
-    
-    # Received a given +message+ with a set of default
-    # +opts+ (defaulting back to an empty hash), which
-    # will be used to perform some sort of action.
-    def handle(message, opts = {})
-      Marvin::Logger.debug "NOP handle - got message #{message.inspect}"
-    end
-    
-  end
-end

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

@@ -1,84 +0,0 @@
-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
-    
-    def dispatch(name, opts = {})
-      opts[:connection] ||= self
-      super
-    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