hector 1.0.0

data/lib/hector/commands/whois.rb

@@ -0,0 +1,28 @@
+module Hector
+  module Commands
+    module Whois
+      def on_whois
+        nickname = request.args.first
+        if session = Session.find(nickname)
+          respond_to_whois_for(self.nickname, session)
+        else
+          raise NoSuchNickOrChannel, nickname
+        end
+      ensure
+        respond_with("318", self.nickname, nickname, "End of /WHOIS list.")
+      end
+
+      def respond_to_whois_for(destination, session)
+        respond_with("301", session.nickname, :text => session.away_message) if session.away?
+        respond_with("311", destination, session.nickname, session.whois)
+        respond_with("319", destination, session.nickname, :text => channels.map { |channel| channel.name }.join(" ")) unless channels.empty?
+        respond_with("312", destination, session.nickname, Hector.server_name, :text => "Hector")
+        respond_with("317", destination, session.nickname, session.seconds_idle, session.created_at, :text => "seconds idle, signon time")
+      end
+
+      def whois
+        "#{nickname} #{identity.username} #{Hector.server_name} * :#{realname}"
+      end
+    end
+  end
+end

data/lib/hector/concerns/authentication.rb

@@ -0,0 +1,45 @@
+module Hector
+  module Concerns
+    module Authentication
+      def on_user
+        @username = request.args.first
+        @realname = request.text
+        authenticate
+      end
+
+      def on_pass
+        @password = request.text
+        authenticate
+      end
+
+      def on_nick
+        @nickname = request.text
+        authenticate
+      end
+
+      protected
+        def authenticate
+          set_identity
+          set_session
+        end
+
+        def set_identity
+          if @username && @password && !@identity
+            Identity.authenticate(@username, @password) do |identity|
+              if @identity = identity
+                set_session
+              else
+                error InvalidPassword
+              end
+            end
+          end
+        end
+
+        def set_session
+          if @identity && @nickname
+            @session = UserSession.create(@nickname, self, @identity, @realname)
+          end
+        end
+    end
+  end
+end

data/lib/hector/concerns/keep_alive.rb

@@ -0,0 +1,24 @@
+module Hector
+  module Concerns
+    module KeepAlive
+      def initialize_keep_alive
+        @received_pong = true
+        @heartbeat = Hector::Heartbeat.new { on_heartbeat }
+      end
+
+      def on_heartbeat
+        if @received_pong
+          @received_pong = false
+          respond_with(:ping, Hector.server_name)
+        else
+          @quit_message = "Ping timeout"
+          connection.close_connection(true)
+        end
+      end
+
+      def destroy_keep_alive
+        @heartbeat.stop
+      end
+    end
+  end
+end

data/lib/hector/concerns/presence.rb

@@ -0,0 +1,59 @@
+module Hector
+  module Concerns
+    module Presence
+      def self.included(klass)
+        klass.class_eval do
+          attr_reader :created_at, :updated_at
+        end
+      end
+
+      def channels
+        Channel.find_all_for_session(self)
+      end
+
+      def initialize_presence
+        @created_at = Time.now
+        @updated_at = Time.now
+        deliver_welcome_message
+      end
+
+      def destroy_presence
+        deliver_quit_message
+        leave_all_channels
+      end
+
+      def seconds_idle
+        Time.now - updated_at
+      end
+
+      def peer_sessions
+        [self, *channels.map { |channel| channel.sessions }.flatten].uniq
+      end
+
+      def touch_presence
+        @updated_at = Time.now
+      end
+
+      protected
+        def deliver_welcome_message
+          respond_with("001", nickname, :text => "Welcome to IRC")
+          respond_with("422", :text => "MOTD File is missing")
+        end
+
+        def deliver_quit_message
+          broadcast(:quit, :source => source, :text => quit_message, :except => self)
+          respond_with(:error, :text => "Closing Link: #{nickname}[hector] (#{quit_message})")
+        end
+
+        def leave_all_channels
+          channels.each do |channel|
+            channel.part(self)
+          end
+        end
+
+        def quit_message
+          @quit_message || "Connection closed"
+        end
+    end
+  end
+end

data/lib/hector/connection.rb

@@ -0,0 +1,85 @@
+module Hector
+  class Connection < EventMachine::Protocols::LineAndTextProtocol
+    include Concerns::Authentication
+
+    attr_reader :session, :request, :identity
+
+    def post_init
+      log(:info, "opened connection")
+    end
+
+    def receive_line(line)
+      @request = Request.new(line)
+      log(:debug, "received", @request.to_s.inspect) unless @request.sensitive?
+
+      if session
+        session.receive(request)
+      else
+        if respond_to?(request.event_name)
+          send(request.event_name)
+        else
+          close_connection(true)
+        end
+      end
+
+    rescue IrcError => e
+      handle_error(e)
+
+    rescue Exception => e
+      log(:error, [e, *e.backtrace].join("\n"))
+
+    ensure
+      @request = nil
+    end
+
+    def unbind
+      session.destroy if session
+      log(:info, "closing connection")
+    end
+
+    def respond_with(response, *args)
+      response = Response.new(response, *args) unless response.is_a?(Response)
+      send_data(response.to_s)
+      log(:debug, "sent", response.to_s.inspect)
+    end
+
+    def handle_error(error)
+      respond_with(error.response)
+      close_connection(true) if error.fatal?
+    end
+
+    def error(klass, *args)
+      handle_error(klass.new(*args))
+    end
+
+    def log(level, *args)
+      Hector.logger.send(level, [log_tag, *args].join(" "))
+    end
+
+    def address
+      peer_info[1]
+    end
+
+    def port
+      peer_info[0]
+    end
+
+    protected
+      def peer_info
+        @peer_info ||= Socket.unpack_sockaddr_in(get_peername)
+      end
+
+      def log_tag
+        "[#{address}:#{port}]".tap do |tag|
+          tag << " (#{session.nickname})" if session
+        end
+      end
+  end
+
+  class SSLConnection < Connection
+    def post_init
+      log(:info, "opened SSL connection")
+      start_tls
+    end
+  end
+end

data/lib/hector/deference.rb

@@ -0,0 +1,11 @@
+module Hector
+  class << self
+    def defer(&block)
+      EM.defer(&block)
+    end
+
+    def next_tick(&block)
+      EM.next_tick(&block)
+    end
+  end
+end

data/lib/hector/errors.rb

@@ -0,0 +1,30 @@
+module Hector
+  class Error < ::StandardError; end
+  class LoadError < Error; end
+
+  class IrcError < Error
+    def response
+      Response.new(command, *options).tap do |response|
+        response.args.push(message) unless message == self.class.name
+      end
+    end
+  end
+
+  def self.IrcError(command, *options)
+    fatal = options.last.is_a?(Hash) && options.last.delete(:fatal)
+    Class.new(IrcError).tap do |klass|
+      klass.class_eval do
+        define_method(:command) { command.dup }
+        define_method(:options) { options.dup }
+        define_method(:fatal?) { fatal }
+      end
+    end
+  end
+
+  class NoSuchNickOrChannel < IrcError("401", :text => "No such nick/channel"); end
+  class NoSuchChannel       < IrcError("403", :text => "No such channel"); end
+  class CannotSendToChannel < IrcError("404", :text => "Cannot send to channel"); end
+  class ErroneousNickname   < IrcError("432", :text => "Erroneous nickname"); end
+  class NicknameInUse       < IrcError("433", "*", :text => "Nickname is already in use"); end
+  class InvalidPassword     < IrcError("464", :text => "Invalid password", :fatal => true); end
+end

data/lib/hector/heartbeat.rb

@@ -0,0 +1,25 @@
+module Hector
+  class Heartbeat
+    def self.create_timer(interval, &block)
+      EventMachine::PeriodicTimer.new(interval, &block)
+    end
+
+    def initialize(interval = 60, &block)
+      @interval, @block = interval, block
+      start
+    end
+
+    def start
+      @timer ||= self.class.create_timer(@interval) { pulse }
+    end
+
+    def pulse
+      @block.call
+    end
+
+    def stop
+      @timer.cancel
+      @timer = nil
+    end
+  end
+end

data/lib/hector/identity.rb

@@ -0,0 +1,23 @@
+module Hector
+  class Identity
+    attr_accessor :username
+
+    class << self
+      attr_accessor :adapter
+
+      def authenticate(username, password)
+        adapter.authenticate(username, password) do |authenticated|
+          yield authenticated ? new(username) : nil
+        end
+      end
+    end
+
+    def initialize(username)
+      @username = username
+    end
+
+    def ==(identity)
+      Identity.adapter.normalize(username) == Identity.adapter.normalize(identity.username)
+    end
+  end
+end

data/lib/hector/logging.rb

@@ -0,0 +1,16 @@
+module Hector
+  class NullLogger
+    def level=(l) end
+    def debug(*)  end
+    def info(*)   end
+    def warn(*)   end
+    def error(*)  end
+    def fatal(*)  end
+  end
+
+  class << self
+    attr_accessor :logger
+  end
+
+  self.logger = NullLogger.new
+end

data/lib/hector/request.rb

@@ -0,0 +1,42 @@
+module Hector
+  class Request
+    attr_reader  :line, :command, :args, :text
+    alias_method :to_s, :line
+
+    def initialize(line)
+      @line = line
+      parse
+    end
+
+    def event_name
+      "on_#{command.downcase}"
+    end
+
+    def sensitive?
+      command.downcase == "pass"
+    end
+
+    protected
+      def parse
+        source = line.dup
+        @command = extract!(source, /^ *([^ ]+)/, "").upcase
+        @text = extract!(source, / :(.*)$/)
+        @args = source.strip.split(" ")
+
+        if @text
+          @args.push(@text)
+        else
+          @text = @args.last
+        end
+      end
+
+      def extract!(line, regex, default = nil)
+        result = nil
+        line.gsub!(regex) do |match|
+          result = $~[1]
+          ""
+        end
+        result || default
+      end
+  end
+end

data/lib/hector/response.rb

@@ -0,0 +1,48 @@
+module Hector
+  class Response
+    attr_reader :command, :args, :source
+    attr_accessor :text
+
+    class << self
+      def apportion_text(args, *base_args)
+        base_response = Response.new(*base_args)
+        max_length = 510 - base_response.to_s.length
+
+        args.inject([args.shift.dup]) do |texts, arg|
+          if texts.last.length + arg.length + 1 >= max_length
+            texts << arg.dup
+          else
+            texts.last << " " << arg
+          end
+          texts
+        end.map do |text|
+          base_response.dup.tap do |response|
+            response.text = text
+          end
+        end
+      end
+    end
+
+    def initialize(command, *args)
+      @command = command.to_s.upcase
+      @args = args
+
+      options = args.pop if args.last.is_a?(Hash)
+      @text = options[:text] if options
+      @source = options[:source] if options
+    end
+
+    def event_name
+      "received_#{command.downcase}"
+    end
+
+    def to_s
+      [].tap do |line|
+        line.push(":#{source}") if source
+        line.push(command)
+        line.concat(args)
+        line.push(":#{text}") if text
+      end.join(" ")[0, 510] + "\r\n"
+    end
+  end
+end