Sutto-marvin 0.1.20081120 → 0.2.0

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

@@ -0,0 +1,111 @@
+module Marvin::IRC::Server
+  class Channel
+    include Marvin::Dispatchable
+    
+    cattr_accessor :logger
+    self.logger = Marvin::Logger
+    
+    attr_accessor :name, :members, :name, :topic, :operators, :mode
+    
+    def inspect
+      "#<Marvin::IRC::Server::Channel name='#{name}' topic='#{@topic}' members=[#{self.members.map { |m| m.nick.inspect}.join(", ")}]>"
+    end
+    
+    def initialize(name)
+      @name      = name
+      @members   = []
+      @operators = []
+      @topic     = ""
+      @mode      = ""
+      logger.info "Created the channel #{name}"
+      dispatch :channel_created, :channel => self
+    end
+    
+    def member?(user)
+      @members.include?(user)
+    end
+    
+    def each_member(&blk)
+      members.each(&blk)
+    end
+    
+    def add(user)
+      logger.info "Adding user #{user.nick} to #{@name}"
+      @operators << user if needs_op?
+      @members << user
+    end
+    
+    def remove(user)
+      @members.delete(user)
+    end
+    
+    # Ind. operations on the room
+    
+    def join(user)
+      return false if member?(user)
+      # Otherwise, we add a user
+      add user
+      @members.each { |m| m.notify :join, @name, :prefix => user.prefix }
+      dispatch :outgoing_join, :target => @name, :nick => user.nick
+      return true
+    end
+    
+    def part(user, message = nil)
+      logger.debug "Getting part from #{user.inspect} w/ #{message}"
+      return false if !member?(user)
+      @members.each { |m| m.notify :part, @name, user.nick, message, :prefix => user.prefix }
+      remove user
+      # TODO: Remove channel from ChannelStore if it's empty.
+      dispatch :outgoing_part, :target => @name, :user => user, :message => message
+      check_emptyness!
+      return true
+    end
+    
+    def quit(user, message = nil)
+      remove user
+      @members.each { |m| m.notify :quit, @name, message, :prefix =>  user.prefix }
+      # TODO: Remove channel from the store if it's empty
+      dispatch :outgoing_quit, :target => @name, :user => user, :message => message
+      check_emptyness!
+    end
+    
+    def message(user, message)
+      @members.each { |m| m.notify :privmsg, @name, ":#{message}", :prefix => user.prefix unless user == m }
+      dispatch :outgoing_message, :target => self, :user => user, :message => message
+    end
+    
+    def notice(user, message)
+      @members.each { |m| m.notify :notice, @name, ":#{message}", :prefix => user.prefix unless user == m }
+      dispatch :outgoing_notice, :target => self, :user => user, :message => message
+    end
+    
+    def topic(user = nil, t = nil)
+      return @topic if t.blank?
+      logger.info "Getting topic for '#{@name}' - #{t.inspect}"
+      @topic = t
+      @members.each { |m| m.notify :topic, @name, ":#{t}", :prefix => user.prefix }
+      dispatch :outgoing_topic, :target => @name, :user => user, :topic => t
+      return @topic
+    end
+    
+    def mode(user)
+      @operators.include?(user) ? "@" : ""
+    end
+    
+    private
+    
+    def needs_op?
+      @operators.empty? && @members.empty?
+    end
+    
+    def check_emptyness!
+      destroy if @members.empty?
+    end
+    
+    def destroy
+      Marvin::IRC::Server::ChannelStore.delete(@name)
+      dispatch :channel_destroyed, :channel => self
+    end
+    
+  end
+end

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

@@ -0,0 +1,14 @@
+module Marvin::IRC::Server
+  class NamedStore
+    
+    def self.new(key_plural, ref_value, &blk)
+      klass = Class.new(Hash) do
+        alias_method :"each_#{ref_value}", :each_value
+        alias_method key_plural.to_sym, :keys
+      end
+      klass.class_eval(&blk) unless blk.blank?
+      return klass.new
+    end
+    
+  end
+end

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

@@ -0,0 +1,5 @@
+module Marvin::IRC::Server::User
+  
+  autoload :HandleMixin, 'marvin/irc/server/user/handle_mixin'
+  
+end

data/lib/marvin/irc/server/user/handle_mixin.rb

@@ -0,0 +1,138 @@
+module Marvin::IRC::Server::User::HandleMixin
+  
+  def handle_incoming_pass(opts = {})
+    @password = opts[:password]
+  end
+  
+  def handle_incoming_user(opts = {})
+    @user      = opts[:user]
+    @mode      = opts[:mode]
+    @real_name = opts[:real_name]
+    welcome_if_complete!
+  end
+
+  def handle_incoming_nick(opts = {})
+    nick = opts[:new_nick]
+    if !nick.blank? && !Marvin::IRC::Server::UserStore.nick_taken?(nick.downcase)
+      if !(new_nick = @nick.nil?)
+        logger.debug "Notifying all users of nick change: #{@nick} => #{nick}"
+        # Get all users and let them now we've changed nick from @nick to nick
+        users = [self]
+        @channels.each do |c|
+          users += c.members.values
+        end
+        users.uniq.each { |u| u.notify :NICK, nick, :prefix => prefix }
+        dispatch :outgoing_nick, :nick => @nick, :new_nick => nick
+      end
+      # Update the store values
+      Marvin::IRC::Server::UserStore.delete(@nick.downcase) unless @nick.blank?
+      Marvin::IRC::Server::UserStore[nick.downcase] = self
+      # Change the nick and reset the number of attempts
+      @nick = nick
+      @nick_attempts = 0
+      # Finally, update the prefix.
+      update_prefix!
+      welcome_if_complete! if new_nick
+    elsif Marvin::IRC::Server::UserStore[nick.downcase] != self
+      # The nick is taken
+      # TODO: Remove hard coded nick attempts limit
+      if @nick_attempts > 5
+        # Handle abort here.
+        logger.debug "User has gone over nick attempt limits - Killing connection."
+        kill_connection!
+        dispatch :outgoing_nick_killed, :client => self
+      else
+        logger.debug "Noting users nick is taken, warning"
+        err :NICKNAMEINUSE, "*", nick, ":Nickname is already in use."
+        @nick_attempts += 1
+      end
+    end
+  end
+
+  def handle_incoming_join(opts = {})
+    return if @prefix.blank?
+    opts[:target].split(",").each do |channel|
+      # If the channel name is invalud, let the user known and dispatch
+      # the correct event.
+      if channel !~ Marvin::IRC::Server::UserConnection::CHANNEL
+        logger.debug "Attempted to join invalid channel name '#{channel}'"
+        err :NOSUCHCHANNEL, channel, ":That channel doesn't exist"
+        dispatch :invalid_channel_name, :channel => channel, :client => self
+        return
+      end
+      chan = (Marvin::IRC::Server::ChannelStore[channel.downcase] ||= Marvin::IRC::Server::Channel.new(channel))
+      if chan.join(self)
+        rpl :TOPIC, channel, ":#{chan.topic.blank? ? "There is no topic" :  nchan.topic}"
+        rpl :NAMREPLY, "=", channel, ":#{chan.members.map { |m| m.nick }.join(" ")}"
+        rpl :ENDOFNAMES, channel, ":End of /NAMES list."
+        @channels << chan
+      else
+        logger.debug "Couldn't join channel '#{channel}'"
+      end
+    end
+  end
+  
+  def handle_incoming_ping(opts = {})
+    command :PONG, ":#{opts[:data]}"
+  end
+  
+  def handle_incoming_pong(opts = {})
+    # Decrease the ping count.
+    @ping_count -= 1
+    @ping_count = 0 if @ping_count < 0
+    logger.debug "Got pong: #{opts[:data]}"
+  end
+
+  def handle_incoming_message(opts = {})
+    return if @prefix.blank?
+    unless (t = target_from(opts[:target])).blank?
+      t.message self, opts[:message]
+    end
+  end
+
+  def handle_incoming_notice(opts = {})
+    return if @prefix.blank?
+    unless (t = target_from(opts[:target])).blank?
+      t.notice self, opts[:message]
+    end
+  end
+
+  def handle_incoming_part(opts = {})
+    t = opts[:target].downcase
+    if !(chan = Marvin::IRC::Server::ChannelStore[t]).blank?
+      if chan.part(self, opts[:message])
+        @channels.delete(chan)
+      else
+        err :NOTONCHANNEL, opts[:target], ":Not a member of that channel"
+      end
+    else
+      err :NOSUCHNICK, opts[:target], ":No such nick/channel"
+    end
+  end
+
+  def handle_incoming_quit(opts = {})
+    return unless @alive
+    @alive = false
+    @channels.each { |c| c.quit(self, opts[:message]) }
+    kill_connection!
+  end
+  
+  def handle_incoming_topic(opts = {})
+    return if @prefix.blank? || opts[:target].blank?
+    c = Marvin::IRC::Server::ChannelStore[opts[:target].downcase]
+    return if c.blank?
+    if !@channels.include?(c)
+      err :NOTONCHANNEL, opts[:target], ":Not a member of that channel"
+    elsif opts[:message].nil?
+      t = c.topic
+      if t.blank?
+        rpl :NOTOPIC, c.name, ":No topic is set"
+      else
+        rpl :TOPIC, c.name, ":#{t}"
+      end
+    else
+      c.topic self, opts[:message].strip
+    end
+  end
+  
+end

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

@@ -0,0 +1,127 @@
+module Marvin::IRC::Server
+  class UserConnection < AbstractConnection
+    USER_MODES    = "aAbBcCdDeEfFGhHiIjkKlLmMnNopPQrRsStUvVwWxXyYzZ0123459*@"
+    CHANNEL_MODES = "bcdefFhiIklmnoPqstv"
+    CHANNEL       = /^[\&\#]+/
+    include User::HandleMixin
+    
+    attr_accessor :nick, :host, :user, :prefix, :password, :mode,
+                  :real_name, :nick_attempts, :channels, :ping_count
+    
+    def inspect
+      "#<Marvin::IRC::Server::UserConnection nick='#{@nick}' host='#{@host}' real_name='#{@real_name}' channels=[#{self.channels.map { |c| c.name.inspect}.join(", ")}]>"
+    end
+    
+    def initialize(base, buffer = [])
+      super
+      @nick_attempts = 0
+      @channels      = []
+      @ping_count    = 0
+    end
+    
+    # Notify is essentially command BUT it
+    # requires that the prefix is set.
+    def notify(command, *args)
+      opts = args.extract_options!
+      return if opts[:prefix].blank?
+      command command, *(args << opts)
+    end
+    
+    # Notification messages
+    
+    def message(user, message)
+      notify :PRIVMSG, @nick, ":#{message}", :prefix => user.prefix
+      dispatch :outgoing_message, :user => user, :message => message, :target => self
+    end
+    
+    def notice(user, message)
+      notify :NOTICE, @nick, ":#{message}", :prefix => user.prefix
+      dispatch :outgoing_notice, :user => user, :message => message, :target => self
+    end
+    
+    # Get the user / channel targeted by a particular request.
+    
+    def target_from(target)
+      case target
+      when CHANNEL
+        chan = Marvin::IRC::Server::ChannelStore[target.downcase]
+        if chan.nil?
+          rpl :NOSUCHNICK, target, ":No such nick/channel"
+        elsif !chan.member?(self)
+          err :CANNOTSENDTOCHAN, target, ":Cannot send to channel"
+        else
+          return chan
+        end
+      else
+        user = Marvin::IRC::Server::UserStore[target.downcase]
+        if user.nil?
+          err :NOSUCHNICK, target, ":No suck nick/channel"
+        else
+          return user
+        end
+      end
+    end
+    
+    # Implementations for connect / disconnect
+    
+    def process_connect
+      super
+    end
+    
+    def process_disconnect
+      super
+    end
+    
+    def kill_connection!
+      @connection.kill_connection!
+    end
+    
+    protected
+    
+    def welcome_if_complete!
+      update_prefix!
+      # Next, send the MOTD and other misc. stuff
+      return if @welcomed || @prefix.blank?
+      rpl :WELCOME,   @nick, ":Welcome to Marvin Server - #{@prefix}"
+      rpl :YOURHOST,  @nick, ":Your host is #{server_host}, running version #{Marvin.version}"
+      rpl :CREATED,   @nick, ":This server was created #{@connection.started_at}"
+      rpl :MYINFO,    @nick, ":#{server_host} #{Marvin.version} #{USER_MODES} #{CHANNEL_MODES}"
+      rpl :MOTDSTART, @nick, ":- MOTD"
+      rpl :MOTD,      @nick, ":- Welcome to Marvin Server, a Ruby + EventMachine ircd."
+      rpl :ENDOFMOTD, @nick, ":- End of /MOTD command."
+      @welcomed = true
+    end
+    
+    def update_prefix!
+      @prefix = "#{@nick}!~#{@user}@#{peer_name}" if details_complete?
+    end
+    
+    def details_complete?
+      !@nick.nil? && !@user.nil?
+    end
+    
+    def server_host
+      @connection.host
+    end
+    
+    def server_port
+      @connection.port
+    end
+    
+    def rpl(number, *args)
+      numeric Marvin::IRC::Replies["RPL_#{number.to_s.upcase}"], *args
+    end
+    
+    def err(number, *args)
+      numeric Marvin::IRC::Replies["ERR_#{number.to_s.upcase}"], *args
+    end
+    
+    def numeric(number, *args)
+      args << {} unless args[-1].is_a?(Hash)
+      args[-1][:prefix] ||= server_host
+      args.unshift(@nick) unless args.first == @nick
+      command(number.to_s, *args)
+    end
+    
+  end
+end

data/lib/marvin/loader.rb

@@ -1,69 +1,144 @@
+require 'fileutils'
+require 'singleton'
+
 module Marvin
   class Loader
+    include Singleton
     
-    cattr_accessor :setup_block
+    # A Controller is any class e.g. a client / server
+    # which is provides the main functionality of the
+    # current client.
+    CONTROLLERS = {
+      :client             => Marvin::Settings.default_client,
+      :server             => Marvin::IRC::Server,
+      :ring_server        => Marvin::Distributed::RingServer,
+      :distributed_client => Marvin::Distributed::DRbClient,
+      :console            => nil
+    }
     
-    cattr_accessor :start_hooks, :stop_hooks
-    self.stop_hooks, self.start_hooks = [], []
+    # For each of the known types, define a method
+    # as Marvin::Loader.type? so we can easily do
+    # things like conditional registers.
+    class << self
+      CONTROLLERS.keys.each do |type|
+        define_method(:"#{type}?") { Marvin::Loader.type == type }
+      end
+    end
     
+    cattr_accessor :hooks, :boot, :type
+    self.hooks = {}
+    self.type = :client
+    
+    # Old style of registering a block to be run on startup
+    # for doing setup etc. now replaced by before_run
     def self.before_connecting(&blk)
-      self.setup_block = blk
+      Marvin::Logger.warn "Marvin::Loader.before_connecting is deprecated, please use before_run instead."
+      before_run(&blk)
     end
     
-    def setup_defaults
-      Marvin::Logger.setup
+    # Append a hook for a given type of hook in order
+    # to be called later on via invoke_hooks!
+    def self.append_hook(type, &blk)
+      self.hooks_for(type) << blk unless blk.blank?
     end
     
-    def self.before_run(&blk)
-      self.start_hooks << blk unless blk.blank?
+    # Return all of the existing hooks or an empty
+    # for a given hook type.
+    def self.hooks_for(type)
+      (self.hooks[type.to_sym] ||= [])
     end
     
-    def self.after_stop(&blk)
-      self.stop_hooks << blk unless blk.blank?
+    # Invoke (call) all of the hooks for a given
+    # type.
+    def self.invoke_hooks!(type)
+      hooks_for(type).each { |hook| hook.call }
     end
     
-    def load_handlers
-      handlers = Dir[Marvin::Settings.root / "handlers/**/*.rb"].map { |h| h[0..-4] }
-      handlers.each do |handler|
-        require handler
-      end
+    # Append a call back to be run at a specific stage.
+    
+    # Register a hook to be run before the controller
+    # has started running.
+    def self.before_run(&blk)
+      append_hook(:before_run, &blk)
     end
     
-    def load_settings
-      Marvin::Settings.setup
-      Marvin::Settings.default_client.configuration = Marvin::Settings.to_hash
-      Marvin::Settings.default_client.setup
+    # Register a hook to be run after the controller
+    # has stopped. Note that this will not guarantee
+    # all processing has completed.
+    def self.after_stop(&blk)
+      append_hook(:after_stop, &blk)
     end
     
-    def pre_connect_setup
-      Marvin::DataStore.load!
-      require(Marvin::Settings.root / "config/setup")
-      self.setup_block.call unless self.setup_block.blank?
+    def self.run!(type = :client)
+      self.type = type.to_sym
+      self.instance.run!
+    end
+    
+    def self.stop!(force = false)
+      self.instance.stop!(force)
     end
     
     def run!
-      Marvin::Options.parse!
-      self.setup_defaults
+      self.register_signals
+      Marvin::Options.parse! unless self.type == :console
+      Marvin::Daemon.daemonize! if Marvin::Settings.daemon?
+      Marvin::Logger.setup
       self.load_settings
+      require(Marvin::Settings.root / "config/setup")
       self.load_handlers
-      self.pre_connect_setup
-      self.start_hooks.each { |h| h.call }
-      Marvin::Settings.default_client.run
+      self.class.invoke_hooks!   :before_run
+      attempt_controller_action! :run
     end
     
-    def stop!
-      Marvin::Settings.default_client.stop
-      self.stop_hooks.each { |h| h.call }
-      Marvin::DataStore.dump!
+    def stop!(force = false)
+      if force || !@attempted_stop
+        self.class.invoke_hooks!   :before_stop
+        attempt_controller_action! :stop
+        self.class.invoke_hooks!   :after_stop
+        @attempted_stop = true
+      end
+      Marvin::Daemon.cleanup! if Marvin::Settings.daemon?
     end
     
-    def self.run!
-      self.new.run!
+    protected
+    
+    # Get the controller for the current type if
+    # it exists and attempt to class a given action.
+    def attempt_controller_action!(action)
+      klass = CONTROLLERS[self.type]
+      klass.send(action) unless klass.blank? || !klass.respond_to?(action, true)
     end
     
-    def self.stop!
-      self.new.stop!
+    # Load all of the handler's in the handlers subfolder
+    # of a marvin installation.
+    def load_handlers
+      Dir[Marvin::Settings.root / "handlers/**/*.rb"].each { |handler| require handler }
     end
     
+    def load_settings
+      Marvin::Settings.setup
+      case Marvin::Loader.type
+      # Perform client / type specific setup.
+      when :client
+        Marvin::Settings.default_client.configuration = Marvin::Settings.to_hash
+        Marvin::Settings.default_client.setup
+      when :distributed_client
+        Marvin::Settings.default_client = Marvin::Distributed::DRbClient
+      end
+    end
+    
+    def register_signals
+      ["INT", "TERM"].each do |sig|
+        trap sig do
+          Marvin::Loader.stop!
+          exit
+        end
+      end
+    end
+    
+    # Register to the Marvin::DataStore methods
+    before_run { Marvin::DataStore.load! if Marvin::Loader.type == :client }
+    after_stop { Marvin::DataStore.dump! if Marvin::Loader.type == :client }
+    
   end
 end