marvin 0.8.0.0

data/lib/marvin/client/actions.rb

@@ -0,0 +1,104 @@
+module Marvin
+  class AbstractClient
+   
+    ## General IRC Functions / Actions
+    
+    # Sends a specified command to the server.
+    # Takes name (e.g. :privmsg) and all of the args.
+    # Very simply formats them as a string correctly
+    # and calls send_data with the results.
+    def command(name, *args)
+      # First, get the appropriate command
+      name = name.to_s.upcase
+      args = args.flatten
+      args << util.last_param(args.pop)
+      send_line "#{name} #{args.compact.join(" ").strip}\r\n"
+    end
+    
+    # Join one or more channels on the current server
+    # e.g.
+    #   client.join "#marvin-testing"
+    #   client.join ["#marvin-testing", "#rubyonrails"]
+    #   client.join "#marvin-testing", "#rubyonrails"
+    def join(*channels_to_join)
+      channels_to_join = channels_to_join.flatten.map { |c| util.channel_name(c) }
+      # If you're joining multiple channels at once, we join them together
+      command :JOIN, channels_to_join.join(",")
+      channels_to_join.each { |channel| dispatch :outgoing_join, :target => channel }
+      logger.info "Sent JOIN for channels #{channels_to_join.join(", ")}"
+    end
+    
+    # Parts a channel, with an optional reason
+    # e.g.
+    #    part "#marvin-testing"
+    #    part "#marvin-testing", "Ninjas stole by felafel"
+    def part(channel, reason = nil)
+      channel = util.channel_name(channel)
+      # Send the command anyway, even if we're not a
+      # a recorded member something might of happened.
+      command :part, channel, reason
+      if channels.include?(channel)
+        dispatch :outgoing_part, :target => channel, :reason => reason
+        logger.info "Parted channel #{channel} - #{reason.present? ? reason : "Non given"}"
+      else
+        logger.warn "Parted channel #{channel} but wasn't recorded as member of channel"
+      end
+    end
+    
+    # Quites from a server, first parting all channels if a second
+    # argument is passed as true
+    # e.g.
+    #    quit
+    #    quit "Going to grab some z's"
+    def quit(reason = nil, part_before_quit = false)
+      @disconnect_expected = true
+      # If the user wants to part before quitting, they should
+      # pass a second, true, parameter
+      if part_before_quit
+        logger.info "Preparing to part from channels before quitting"
+        channels.to_a.each { |chan| part(chan, reason) }
+        logger.info "Parted from all channels, quitting"
+      end
+      command :quit, reason
+      dispatch :outgoing_quit
+      # Remove the connections from the pool
+      connections.delete(self)
+      logger.info  "Quit from #{host_with_port}"
+    end
+    
+    # Sends a message to a target (either a channel or a user)
+    # e.g.
+    #    msg "#marvin-testing", "Hello there!"
+    #    msg "SuttoL", "Hey, I'm playing with marvin!"
+    def msg(target, message)
+      command :privmsg, target, message
+      dispatch :outgoing_message, :target => target, :message => message
+      logger.info "Message #{target} - #{message}"
+    end
+    
+    # Does a CTCP action in a channel (equiv. to doing /me in most IRC clients)
+    # e.g.
+    #    action "#marvin-testing", "is about to sleep"
+    #    action "SuttoL", "is about to sleep"
+    def action(target, message)
+      command :privmsg, target, "\01ACTION #{message.strip}\01"
+      dispatch :outgoing_action, :target => target, :message => message
+      logger.info "Action sent to #{target} - #{message}"
+    end
+    
+    def pong(data)
+      command :pong, data
+      dispatch :outgoing_pong
+      logger.info "PONG sent to #{host_with_port} w/ data - #{data}"
+    end
+    
+    def nick(new_nick)
+      logger.info "Changing nick to #{new_nick}"
+      command :nick, new_nick
+      @nickname = new_nick
+      dispatch :outgoing_nick, :new_nick => new_nick
+      logger.info "Nick changed to #{new_nick}"
+    end
+    
+  end
+end

data/lib/marvin/client/default_handlers.rb

@@ -0,0 +1,97 @@
+module Marvin
+  class AbstractClient
+    
+    # Default handlers
+    
+    # The default handler for all things initialization-related
+    # on the client. Usually, this will send the user command,
+    # set out nick, join all of the channels / rooms we wish
+    # to be in and if a password is specified in the configuration,
+    # it will also attempt to identify us.
+    def handle_client_connected(opts = {})
+      logger.info "About to handle client connected"
+      # If the pass is set
+      unless pass.blank?
+        logger.info "Sending pass for connection"
+        command :pass, pass
+      end
+      # IRC Connection is establish so we send all the required commands to the server.
+      logger.info "Setting default nickname"
+      nick nicks.shift
+      logger.info "Sending user command"
+      command :user, configuration.user, "0", "*", configuration.name
+    rescue Exception => e
+      Marvin::ExceptionTracker.log(e)
+    end
+    
+    # handle a bunch of default events that happen at a connection
+    # level instead of a per-app level.
+    
+    # The default response for PING's - it simply replies
+    # with a PONG.
+    def handle_incoming_ping(opts = {})
+      logger.info "Received Incoming Ping - Handling with a PONG"
+      pong(opts[:data])
+    end
+    
+    # TODO: Get the correct mapping for a given
+    # Code.
+    def handle_incoming_numeric(opts = {})
+      case opts[:code]
+        when Marvin::IRC::Replies[:RPL_WELCOME]
+          handle_welcome
+        when Marvin::IRC::Replies[:ERR_NICKNAMEINUSE]
+          handle_nick_taken
+        when Marvin::IRC::Replies[:RPL_TOPIC]
+          handle_channel_topic
+      end
+      code = opts[:code].to_i
+      args = Marvin::Util.arguments(opts[:data])
+      dispatch :incoming_numeric_processed, :code => code, :data => args
+    end
+    
+    def handle_welcome
+      logger.info "Welcome received from server"
+      # If a password is specified, we will attempt to message
+      # NickServ to identify ourselves.
+      say ":IDENTIFY #{self.configuration.password}", "NickServ" if configuration.password.present?
+      # Join the default channels IF they're already set
+      # Note that Marvin::IRC::Client.connect will set them AFTER this stuff is run.
+      join default_channels
+    end
+    
+    # The default handler for when a users nickname is taken on
+    # on the server. It will attempt to get the nicknickname from
+    # the nicknames part of the configuration (if available) and
+    # will then call #nick to change the nickname.
+    def handle_nick_taken
+      logger.info "Nickname '#{nickname}' on #{server} taken, trying next." 
+      logger.info "Available Nicknames: #{nicks.empty? ? "None" : nicks.join(", ")}"
+      if !nicks.empty?
+        logger.info "Getting next nickname to switch"
+        next_nick = nicks.shift # Get the next nickname
+        logger.info "Attemping to set nickname to '#{next_nick}'"
+        nick next_nick
+      else
+        logger.fatal "No Nicknames available - QUITTING"
+        quit
+      end
+    end
+    
+    # Only record joins when you've successfully joined the channel.
+    def handle_incoming_join(opts = {})
+      if opts[:nick] == @nickname
+        channels << opts[:target]
+        logger.info "Successfully joined channel #{opts[:target]}"
+      end
+    end
+    
+    # Make sure we show user server errors
+    def handle_incoming_error(opts = {})
+      if opts[:message].present?
+        logger.info "Got ERROR Message: #{opts[:message]}"
+      end
+    end
+    
+  end
+end

data/lib/marvin/command_handler.rb

@@ -0,0 +1,91 @@
+require 'set'
+
+module Marvin
+  class CommandHandler < Base
+    
+    class_inheritable_accessor :command_prefix
+    self.command_prefix  = ""
+    
+    @@exposed_method_mapping = Hash.new { |h,k| h[k] = [] }
+    @@method_descriptions    = Hash.new { |h,k| h[k] = {} }
+    @@registered_classes     = Set.new
+    
+    class << self
+      
+      def command(name, method_desc = nil, &blk)
+        exposes name
+        desc method_desc unless method_desc.blank?
+        define_method(name, &blk)
+      end
+      
+      def prefix_is(p)
+        self.command_prefix = p
+      end
+      
+      def exposes(*args)
+        args.each { |name| @@exposed_method_mapping[self] << name.to_sym }
+      end
+      
+      def exposed_methods
+        methods = []
+        klass   = self
+        while klass != Object
+          methods += @@exposed_method_mapping[klass]
+          klass = klass.superclass
+        end
+        return methods.uniq.compact
+      end
+      
+      def prefix_regexp
+        /^#{command_prefix}/
+      end
+      
+      def desc(description)
+        @last_description = description
+      end
+      
+      def exposed_name(method)
+        "#{command_prefix}#{method}"
+      end
+      
+    end
+    
+    on_event :incoming_message, :check_for_commands
+    
+    def check_for_commands
+      message = options.message.to_s.strip
+      data, command = nil, nil
+      if from_channel?
+        name, command, data = message.split(/\s+/, 2)
+        return if name !~ /^#{client.nickname}:/i
+      else
+        command, data = message.splt(/\s+/, 2)
+      end
+      data ||= ""
+      if (command_name = extract_command_name(command)).present?
+        logger.info "Processing command '#{command_name}' for #{from}"
+        send(command_name, data.to_s) if respond_to?(command_name)
+      end
+    end
+    
+    def extract_command_name(command)
+      re = self.class.prefix_regexp
+      if command =~ re
+        method_name = command.gsub(re, "").underscore.to_sym
+        return method_name if self.class.exposed_methods.include?(method_name)
+      end
+    end
+    
+    def exposed_name(name)
+      self.class.exposed_name(name)
+    end
+    
+    def self.method_added(name)
+      if @last_description.present?
+        @@method_descriptions[self][name.to_sym] = @last_description
+        @last_description = nil
+      end
+    end
+    
+  end
+end

data/lib/marvin/console.rb

@@ -0,0 +1,50 @@
+require 'irb'
+
+module Marvin
+  class Console
+    
+    module BaseExtensions
+      def parse(line)
+        Marvin::Settings.parser.parse(line)
+      end
+
+      def logger
+        Marvin::Logger.logger
+      end
+
+      def client
+        $client ||= Marvin::Settings.client.new(:port => 6667, :server => "irc.freenode.net")
+      end
+
+      def user(reset = false)
+        unless @user_created || reset
+          server.receive_line "NICK SuttoL"
+          server.receive_line "USER SuttoL 0 * :SuttoL"
+          @user_created = true
+        end
+        return server.connection_implementation
+      end
+    end
+    
+    def initialize(file = $0)
+      @file = file
+      setup_irb
+    end
+    
+    def setup_irb
+      # This is a bit hacky, surely there is a better way?
+      # e.g. some way to specify which scope irb runs in.
+      eval("include Marvin::Console::BaseExtensions", TOPLEVEL_BINDING)
+    end
+    
+    def run
+      ARGV.replace []
+      IRB.start
+    end
+    
+    def self.run
+      self.new.run
+    end
+    
+  end
+end

data/lib/marvin/core_commands.rb

@@ -0,0 +1,49 @@
+module Marvin
+  class CoreCommands < CommandHandler
+    
+    # Returns a hash of doccumented method names
+    def self.method_documentation
+      documented = Hash.new { |h,k| h[k] = [] }
+      @@method_descriptions.each_key do |klass| 
+        next unless klass.registered?
+        @@exposed_method_mapping[klass].each do |m|
+          desc = @@method_descriptions[klass][m]
+          documented[m.to_s] << desc if desc.present?
+        end
+      end
+      return documented
+    end
+    
+    def registered_and_exposed_handlers
+    end
+    
+    exposes :help
+    desc "Generates this usage statement"
+    def help(method)
+      method        = method.strip
+      documentation = self.class.method_documentation
+      names         = documentation.keys.sort
+      if method.blank?
+        display_names = names.map { |n| exposed_name(n) }
+        width         = display_names.map { |d| d.length }.max
+        say "Hello there, I know the following documented commands:"
+        names.each_with_index do |name, index|
+          say "#{display_names[index].ljust(width)} - #{documentation[name].join("; ")}"
+        end
+      else
+        if names.include? method
+          reply "#{exposed_name(method)} - #{documentation[method].join("; ")}"
+        else
+          reply "I'm sorry, I can't help with #{m} - it seems to be undocumented."
+        end
+      end
+    end
+    
+    exposes :about
+    desc "Displays the current marvin and ruby versions."
+    def about(*args)
+      reply "Marvin v#{Marvin::VERSION} running on Ruby #{RUBY_VERSION} (#{RUBY_PLATFORM})"
+    end
+    
+  end
+end

data/lib/marvin/distributed.rb

@@ -0,0 +1,8 @@
+module Marvin
+  module Distributed
+    autoload :Protocol, 'marvin/distributed/protocol'
+    autoload :Server,   'marvin/distributed/server'
+    autoload :Handler,  'marvin/distributed/handler'
+    autoload :Client,   'marvin/distributed/client'
+  end
+end

data/lib/marvin/distributed/client.rb

@@ -0,0 +1,225 @@
+require 'json'
+require 'digest/sha2'
+require 'eventmachine'
+require 'socket'
+
+module Marvin
+  module Distributed
+    class Client < Marvin::AbstractClient
+      
+      attr_accessor :em_connection, :remote_client_host, :remote_client_nick
+      
+      class RemoteClientProxy
+        is :loggable
+        
+        def initialize(conn, host_with_port, nickname)
+          @connection     = conn
+          @host_with_port = host_with_port
+          @nickname       = nickname
+        end
+        
+        def nickname
+          @nickname
+        end
+        
+        def host_with_port
+          @host_with_port
+        end
+        
+        def method_missing(name, *args)
+          logger.debug "Proxying #{name}(#{args.inspect[1..-2]}) to #{@host_with_port}"
+          @connection.send_message(:action, {
+            "action"      => name.to_s,
+            "arguments"   => args,
+            "client-host" => @host_with_port
+          })
+        end
+        
+      end
+      
+      class EMConnection < Marvin::Distributed::Protocol
+        
+        register_handler_method :event
+        register_handler_method :authentication_failed
+        register_handler_method :authenticated
+        register_handler_method :unauthorized
+        
+        cattr_accessor :stopping
+        self.stopping = false
+        
+        attr_accessor :client, :port, :connection_host, :connection_port, :configuration
+
+        def initialize(*args)
+          @configuration = args.last.is_a?(Marvin::Nash) ? args.pop : Marvin::Nash.new
+          super(*args)
+          @callbacks = {}
+          @client = Marvin::Distributed::Client.new(self)
+          @authenticated = false
+        end
+
+        def post_init
+          super
+          logger.info "Connected to distributed server"
+          if should_use_tls?
+            logger.info "Attempting to initialize tls"
+            start_tls
+          else
+            process_authentication
+          end
+        end
+        
+        def ssl_handshake_completed
+          logger.info "tls handshake completed"
+          process_authentication if should_use_tls?
+        end
+        
+        
+        def unbind
+          if self.stopping
+            logger.info "Stopping distributed client"
+          else
+            logger.info "Lost connection to distributed client - Scheduling reconnect"
+            EventMachine.add_timer(15) { EMConnection.connect(connection_host, connection_port, @configuration) }
+          end
+          super
+        end
+        
+        def process_authentication
+          if configuration.token?
+            logger.info "Attempting to authenticate..." 
+            send_message(:authenticate, {:token => configuration.token})
+          end
+        end
+        
+        def handle_event(options = {})
+          event       = options["event-name"]
+          client_host = options["client-host"]
+          client_nick = options["client-nick"]
+          options     = options["event-options"]
+          options     = {} unless options.is_a?(Hash)
+          return if event.blank?
+          begin
+            logger.debug "Handling #{event}"
+            @client.remote_client_host = client_host
+            @client.remote_client_nick = client_nick
+            @client.setup_handlers
+            @client.dispatch(event.to_sym, options)
+          rescue Exception => e
+            logger.warn "Got Exception - Forwarding to Remote"
+            Marvin::ExceptionTracker.log(e)
+            send_message(:exception, {
+              "name"      => e.class.name,
+              "message"   => e.message,
+              "backtrace" => e.backtrace
+            })
+          ensure
+            logger.debug "Sending completed message"
+            send_message(:completed)
+            @client.reset!
+          end
+        end
+        
+        def handle_unauthorized(options = {})
+          logger.warn "Attempted action when unauthorized. Stopping client."
+          Marvin::Distributed::Client.stop
+        end
+        
+        def handle_authenticated(options = {})
+          @authenticated = true
+          logger.info "Successfully authenticated with #{host_with_port}"
+        end
+        
+        def handle_authentication_failed(options = {})
+          logger.info "Authentication with #{host_with_port} failed. Stopping."
+          Marvin::Distributed::Client.stop
+        end
+        
+        def self.connect(host, port, config = Marvin::Nash.new)
+          logger.info "Attempting to connect to #{host}:#{port}"
+          EventMachine.connect(host, port, self, config) do |c|
+            c.connection_host = host
+            c.connection_port = port
+          end
+        end
+        
+        protected
+        
+        def options_for_callback(blk)
+          return {} if blk.blank?
+          cb_id = "callback-#{seld.object_id}-#{Time.now.to_f}"
+          count = 0
+          count += 1 while @callbacks.has_key?(Digest::SHA256.hexdigest("#{cb_id}-#{count}"))
+          final_id = Digest::SHA256.hexdigest("#{cb_id}-#{count}")
+          @callbacks[final_id] = blk
+          {"callback-id" => final_id}
+        end
+
+        def process_callback(hash)
+          if hash.is_a?(Hash) && hash.has_key?("callback-id")
+            callback = @callbacks.delete(hash["callback-id"])
+            callback.call(self, hash)
+          end
+        end
+
+        def host_with_port
+          @host_with_port ||= begin
+            port, ip = Socket.unpack_sockaddr_in(get_peername)
+            "#{ip}:#{port}"
+          end
+        end
+
+        def should_use_tls?
+          @using_tls ||= configuration.encrypted?
+        end
+
+      end
+   
+      def initialize(em_connection)
+        @em_connection = em_connection
+      end
+   
+      def remote_client
+        @remote_client ||= RemoteClientProxy.new(@em_connection, @remote_client_host, @remote_client_nick)
+      end
+      
+      def reset!
+        @remote_client = nil
+        @remote_client_nick = nil
+        @remote_client_host = nil
+        reset_handlers
+      end
+      
+      def setup_handlers
+        self.class.handlers.each { |h| h.client = remote_client if h.respond_to?(:client=) }
+      end
+      
+      def reset_handlers
+        self.class.handlers.each { |h| h.client = nil if h.respond_to?(:client=) }
+      end
+      
+      class << self
+        
+        def run
+          logger.info "Preparing to start distributed client"
+          EventMachine.kqueue
+          EventMachine.epoll
+          EventMachine.run do
+            opts = Marvin::Settings.distributed || Marvin::Nash.new
+            opts = opts.client || Marvin::Nash.new
+            host = opts.host  || "0.0.0.0"
+            port = (opts.port || 8943).to_i
+            EMConnection.connect(host, port, opts)
+          end
+        end
+        
+        def stop
+          logger.info "Stopping distributed client..."
+          EMConnection.stopping = true
+          EventMachine.stop_event_loop
+        end
+        
+      end
+      
+    end
+  end
+end