Sutto-marvin 0.4.0 → 0.8.0.0

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

@@ -1,66 +0,0 @@
-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

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

@@ -1,115 +0,0 @@
-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, virtual = false)
-      @members.each do |m|
-        if virtual || user != m
-          m.notify(:privmsg, @name, ":#{message}", :prefix => user.prefix, :virtual => virtual)
-        end
-      end
-      dispatch :outgoing_message, :target => self, :user => user, :message => message, :virtual => virtual
-    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

@@ -1,14 +0,0 @@
-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/remote_interface.rb

@@ -1,77 +0,0 @@
-require 'drb'
-require 'rinda/ring'
-module Marvin
-  module IRC
-    module Server
-      
-      # Make sure that a proxy object is used vs. the real thing.
-      [Channel, AbstractConnection, User, NamedStore].each do |c|
-        c.class_eval { include DRbUndumped }
-      end
-      
-      # A DRb interface to post / receive messages from the
-      # a running server instance. Used for things such as
-      # posting status updated directly on the server.
-      class RemoteInterface
-        include DRbUndumped
-        
-        # Attempts to find a running IRC server,
-        # returning an instance of it if it exists.
-        def self.primary
-          DRb.start_service
-          begin
-            rs = Rinda::RingFinger.primary
-            server = rs.read_all([:marvin_server, Marvin::Settings.distributed_namespace, nil])
-            if server.empty?
-              return nil
-            else
-              # Return the first element in the list of servers, getting it's servers instance.
-              return server.first.last
-            end
-          rescue
-            return nil
-          end
-        end
-        
-        def self.start
-          DRb.start_service
-          instance = self.new # Create the new instance
-          begin
-            rs = Rinda::RingFinger.primary
-            renewer = Rinda::SimpleRenewer.new
-            tuple   = [:marvin_server, Marvin::Settings.distributed_namespace, instance]
-            Marvin::Logger.info "Publishing information about service to the tuplespace"
-            Marvin::Logger.debug "Pushing #{tuple.inspect} to #{rs.__drburi}"
-            rs.write(tuple, renewer)
-          rescue
-            Marvin::Logger.warn "No ring server found - remote interface not running"
-          end
-        end
-        
-        # Returns an array of all channels
-        def channels
-          Marvin::IRC::Server::ChannelStore.values
-        end
-        
-        # Returns the names of all channels
-        def channel_names
-          Marvin::IRC::Server::ChannelStore.keys
-        end
-        
-        # Returns the channel with the given name.
-        def channel(name)
-          Marvin::IRC::Server::ChannelStore[name]
-        end
-        
-        # Send an action from a user to a specific
-        # channel, using from nick as a facade.
-        def message(from_nick, target, contents)
-          u = (Marvin::IRC::Server::UserStore[from_nick.to_s.downcase] ||= VirtualUserConnection.new(from_nick))
-          Marvin::Logger.info "#{from_nick} (#{u.inspect}) messaging #{target}: #{contents}"
-          u.send_message(target, contents) unless u.blank?
-        end
-        
-      end
-    end
-  end
-end

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

@@ -1,140 +0,0 @@
-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.info "Reclaiming nick (if taken)"
-        Marvin::IRC::Server::UserStore.reclaim(nick)
-        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
-        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" :  chan.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[:topic].blank?
-      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[:topic].strip
-    end
-  end
-  
-end

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

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

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

@@ -1,134 +0,0 @@
-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 send_message(target, message)
-      t = target_from(target)
-      logger.debug "Sending #{t.inspect} #{message.inspect} from #{self.inspect}"
-      t.message(self, message) unless t.blank?
-    end
-    
-    def message(user, message, virtual = false)
-      notify :PRIVMSG, @nick, ":#{message}", :prefix => user.prefix, :virtual => virtual
-      dispatch :outgoing_message, :user => user, :message => message, :target => self, :virtual => virtual
-    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}!n=#{@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/irc/server/virtual_user_connection.rb

@@ -1,80 +0,0 @@
-module Marvin::IRC::Server
-  class VirtualUserConnection
-    include Marvin::Dispatchable
-    
-    CHANNEL = /^[\&\#]+/
-    
-    attr_accessor :nick, :channels
-    
-    def initialize(nick)
-      self.nick     = nick
-      self.channels = []
-    end
-    
-    def prefix
-      "#{@nick}!n=rruser@relayrelay.com"
-    end
-    
-    def notify(*args)
-      Marvin::Logger.debug "Virtual User #{self.nick} got notify w/ #{args.inspect}"
-    end
-    
-    # Notify the remote handler we've received a message
-    def message(user, message, virtual = false)
-      dispatch :received_message, :user => user, :message => message, :target => self unless virtual
-    end
-    
-    def send_message(target, message)
-      t = target_from(target)
-      Marvin::Logger.debug "DRb Message from #{self.nick} to #{t.inspect}: #{message.inspect}"
-      if t.blank?
-        Marvin::Logger.debug "Target not found"
-        return nil
-      else
-        Marvin::Logger.debug "Sending message to #{t.inspect}"
-        return t.message(self, message, true)
-      end
-    end
-    
-    def reclaim!
-      self.channels.each { |c| c.part(self, "Reclaiming nick for virtual user...") }
-      Marvin::IRC::Server::UserStore.delete(self.nick.downcase)
-    end
-    
-    def join(channel)
-      return nil if channel !~ CHANNEL
-      chan = (Marvin::IRC::Server::ChannelStore[channel.downcase] ||= Marvin::IRC::Server::Channel.new(channel))
-      if chan.join(self)
-        @channels << channel
-        return chan
-      end
-    end
-    
-    class << self
-      
-      def claimed?(nick)
-        Marvin::IRC::Server::UserStore.virtual?(nick)
-      end
-      
-      def claim(nick)
-        unless Marvin::IRC::Server::UserStore[nick.downcase].blank?
-          return(Marvin::IRC::Server::UserStore[nick.downcase] ||= Marvin::IRC::Server::VirtualUserConnection.new(nick))
-        end
-      end
-      
-    end
-    
-    private
-    
-    def target_from(target)
-      if target =~ CHANNEL
-        c = Marvin::IRC::Server::ChannelStore[target.downcase]
-        c = join(target) if c.nil? || !c.member?(self)
-        return c
-      else
-        return Marvin::IRC::Server::UserStore[target.downcase] ||= Marvin::IRC::Server::VirtualUserConnection.new(target)
-      end
-    end
-    
-  end
-end