rbot 0.9.10 → 0.9.12

data/lib/rbot/core/filters_ui.rb

@@ -0,0 +1,64 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: filters management from IRC
+#
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+
+class FiltersModule < CoreBotModule
+
+  def initialize
+    super
+    @bot.clear_filters
+    @bot.register_filter(:htmlinfo) { |s| Utils.get_html_info(s.to_s, s) }
+  end
+
+  def help(plugin, topic="")
+    "filters list [<group>] => list filters (in group <group>) | filters search <pat> => list filters matching regexp <pat>"
+  end
+
+  def do_list(m, params)
+    g = params[:group]
+    ar = @bot.filter_names(g).map { |s| s.to_s }.sort!
+    if ar.empty?
+      if g
+        msg = _("no filters in group %{g}") % {:g => g}
+      else
+        msg = _("no known filters")
+      end
+    else
+      msg = _("known filters: ") << ar.join(", ") 
+    end
+    m.reply msg
+  end
+
+  def do_listgroups(m, params)
+    ar = @bot.filter_groups.map { |s| s.to_s }.sort!
+    if ar.empty?
+      msg = _("no known filter groups")
+    else
+      msg = _("known filter groups: ") << ar.join(", ") 
+    end
+    m.reply msg
+  end
+
+  def do_search(m, params)
+    l = @bot.filter_names.map { |s| s.to_s }
+    pat = params[:pat].to_s
+    sl = l.grep(Regexp.new(pat))
+    if sl.empty?
+      msg = _("no filters match %{pat}") % { :pat => pat }
+    else
+      msg = _("filters matching %{pat}: ") % { :pat => pat }
+      msg << sl.sort!.join(", ")
+    end
+    m.reply msg
+  end
+
+end
+
+plugin = FiltersModule.new
+
+plugin.map "filters list [:group]", :action => :do_list
+plugin.map "filters search *pat", :action => :do_search
+plugin.map "filter groups", :action => :do_listgroups

data/lib/rbot/core/irclog.rb

@@ -0,0 +1,292 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: rbot IRC logging facilities
+#
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+
+class IrcLogModule < CoreBotModule
+
+  Config.register Config::IntegerValue.new('irclog.max_open_files',
+    :default => 20, :validate => Proc.new { |v| v > 0 },
+    :desc => "Maximum number of irclog files to keep open at any one time.")
+  Config.register Config::ArrayValue.new('irclog.no_log',
+    :default => [], :on_change => Proc.new { |bot, v|
+      bot.plugins.delegate 'event_irclog_list_changed', v, bot.config['irclog.do_log']
+    },
+    :desc => "List of channels and nicks for which logging is disabled. IRC patterns can be used too.")
+  Config.register Config::ArrayValue.new('irclog.do_log',
+    :default => [], :on_change => Proc.new { |bot, v|
+      bot.plugins.delegate 'event_irclog_list_changed', bot.config['irclog.no_log'], v
+    },
+    :desc => "List of channels and nicks for which logging is enabled. IRC patterns can be used too. This can be used to override wide patters in irclog.no_log")
+  Config.register Config::StringValue.new('irclog.filename_format',
+    :default => '%%{where}', :requires_rescan => true,
+    :desc => "filename pattern for the IRC log. You can put typical strftime keys such as %Y for year and %m for month, plus the special %%{where} key for location (channel name or user nick)")
+
+  attr :nolog_rx, :dolog_rx
+  def initialize
+    super
+    @queue = Queue.new
+    @thread = Thread.new { loggers_thread }
+    @logs = Hash.new
+    Dir.mkdir("#{@bot.botclass}/logs") unless File.exist?("#{@bot.botclass}/logs")
+    event_irclog_list_changed(@bot.config['irclog.no_log'], @bot.config['irclog.do_log'])
+    @fn_format = @bot.config['irclog.filename_format']
+  end
+
+  def can_log_on(where)
+    return true if @dolog_rx and where.match @dolog_rx
+    return false if @nolog_rx and where.match @nolog_rx
+    return true
+  end
+
+  def event_irclog_list_changed(nolist, dolist)
+    @nolog_rx = nolist.empty? ? nil : Regexp.union(*(nolist.map { |r| r.to_irc_regexp }))
+    debug "no log: #{@nolog_rx}"
+    @dolog_rx = dolist.empty? ? nil : Regexp.union(*(dolist.map { |r| r.to_irc_regexp }))
+    debug "do log: #{@dolog_rx}"
+    @logs.inject([]) { |ar, kv|
+      ar << kv.first unless can_log_on(kv.first)
+      ar
+    }.each { |w| logfile_close(w, 'logging disabled here') }
+  end
+
+  def logfile_close(where_str, reason = 'unknown reason')
+    f = @logs.delete(where_str) or return
+    stamp = Time.now.strftime '%Y/%m/%d %H:%M:%S'
+    f[1].puts "[#{stamp}] @ Log closed by #{@bot.myself.nick} (#{reason})"
+    f[1].close
+  end
+
+  # log IRC-related message +message+ to a file determined by +where+.
+  # +where+ can be a channel name, or a nick for private message logging
+  def irclog(message, where="server")
+    @queue.push [message, where]
+  end
+
+  def cleanup
+    @queue << nil
+    @thread.join
+    @thread = nil
+  end
+
+  def sent(m)
+    case m
+    when NoticeMessage
+      irclog "-#{m.source}- #{m.message}", m.target
+    when PrivMessage
+      logtarget = who = m.target
+      if m.ctcp
+        case m.ctcp.intern
+        when :ACTION
+          irclog "* #{m.source} #{m.logmessage}", logtarget
+        when :VERSION
+          irclog "@ #{m.source} asked #{who} about version info", logtarget
+        when :SOURCE
+          irclog "@ #{m.source} asked #{who} about source info", logtarget
+        when :PING
+          irclog "@ #{m.source} pinged #{who}", logtarget
+        when :TIME
+          irclog "@ #{m.source} asked #{who} what time it is", logtarget
+        else
+          irclog "@ #{m.source} asked #{who} about #{[m.ctcp, m.message].join(' ')}", logtarget
+        end
+      else
+        irclog "<#{m.source}> #{m.logmessage}", logtarget
+      end
+    when QuitMessage
+      m.was_on.each { |ch|
+        irclog "@ quit (#{m.message})", ch
+      }
+    end
+  end
+
+  def welcome(m)
+    irclog "joined server #{m.server} as #{m.target}", "server"
+  end
+
+  def listen(m)
+    case m
+    when PrivMessage
+      method = 'log_message'
+    else
+      method = 'log_' + m.class.name.downcase.match(/^irc::(\w+)message$/).captures.first
+    end
+    if self.respond_to?(method)
+      self.__send__(method, m)
+    else
+      warning "unhandled logging for #{m.pretty_inspect} (no such method #{method})"
+      unknown_message(m)
+    end
+  end
+
+  def log_message(m)
+    if m.ctcp
+      who = m.private? ? "me" : m.target
+      logtarget = m.private? ? m.source : m.target
+      case m.ctcp.intern
+      when :ACTION
+        if m.public?
+          irclog "* #{m.source} #{m.logmessage}", m.target
+        else
+          irclog "* #{m.source}(#{m.sourceaddress}) #{m.logmessage}", m.source
+        end
+      when :VERSION
+        irclog "@ #{m.source} asked #{who} about version info", logtarget
+      when :SOURCE
+        irclog "@ #{m.source} asked #{who} about source info", logtarget
+      when :PING
+        irclog "@ #{m.source} pinged #{who}", logtarget
+      when :TIME
+        irclog "@ #{m.source} asked #{who} what time it is", logtarget
+      else
+        irclog "@ #{m.source} asked #{who} about #{[m.ctcp, m.message].join(' ')}", logtarget
+      end
+    else
+      if m.public? 
+        irclog "<#{m.source}> #{m.logmessage}", m.target
+      else
+        irclog "<#{m.source}(#{m.sourceaddress})> #{m.logmessage}", m.source
+      end
+    end
+  end
+
+  def log_notice(m)
+    if m.private?
+      irclog "-#{m.source}(#{m.sourceaddress})- #{m.logmessage}", m.source
+    else
+      irclog "-#{m.source}- #{m.logmessage}", m.target
+    end
+  end
+
+  def motd(m)
+    m.message.each_line { |line|
+      irclog "MOTD: #{line}", "server"
+    }
+  end
+
+  def log_nick(m)
+    m.is_on.each { |ch|
+      irclog "@ #{m.oldnick} is now known as #{m.newnick}", ch
+    }
+  end
+
+  def log_quit(m)
+    m.was_on.each { |ch|
+      irclog "@ Quit: #{m.source}: #{m.logmessage}", ch
+    }
+  end
+
+  def modechange(m)
+    irclog "@ Mode #{m.logmessage} by #{m.source}", m.target
+  end
+
+  def log_join(m)
+    if m.address?
+      debug "joined channel #{m.channel}"
+      irclog "@ Joined channel #{m.channel}", m.channel
+    else
+      irclog "@ #{m.source} joined channel #{m.channel}", m.channel
+    end
+  end
+
+  def log_part(m)
+    if(m.address?)
+      debug "left channel #{m.channel}"
+      irclog "@ Left channel #{m.channel} (#{m.logmessage})", m.channel
+    else
+      irclog "@ #{m.source} left channel #{m.channel} (#{m.logmessage})", m.channel
+    end
+  end
+
+  def log_kick(m)
+    if(m.address?)
+      debug "kicked from channel #{m.channel}"
+      irclog "@ You have been kicked from #{m.channel} by #{m.source} (#{m.logmessage})", m.channel
+    else
+      irclog "@ #{m.target} has been kicked from #{m.channel} by #{m.source} (#{m.logmessage})", m.channel
+    end
+  end
+
+  # def log_invite(m)
+  #   # TODO
+  # end
+
+  def log_topic(m)
+    case m.info_or_set
+    when :set
+      if m.source == @bot.myself
+        irclog "@ I set topic \"#{m.topic}\"", m.channel
+      else
+        irclog "@ #{m.source} set topic \"#{m.topic}\"", m.channel
+      end
+    when :info
+      topic = m.channel.topic
+      irclog "@ Topic is \"#{m.topic}\"", m.channel
+      irclog "@ Topic set by #{topic.set_by} on #{topic.set_on}", m.channel
+    end
+  end
+
+  # def names(m)
+  #   # TODO
+  # end
+
+  def unknown_message(m)
+    irclog m.logmessage, ".unknown"
+  end
+
+  def logfilepath(where_str, now)
+    File.join(@bot.botclass, 'logs', now.strftime(@fn_format) % { :where => where_str })
+  end
+
+  protected
+  def loggers_thread
+    ls = nil
+    debug 'loggers_thread starting'
+    while ls = @queue.pop
+      message, where = ls
+      message = message.chomp
+      now = Time.now
+      stamp = now.strftime("%Y/%m/%d %H:%M:%S")
+      if where.class <= Server
+        where_str = "server"
+      else
+        where_str = where.downcase.gsub(/[:!?$*()\/\\<>|"']/, "_")
+      end
+      return unless can_log_on(where_str)
+
+      # close the previous logfile if we're rotating
+      if @logs.has_key? where_str
+        fp = logfilepath(where_str, now)
+        logfile_close(where_str, 'log rotation') if fp != @logs[where_str][1].path
+      end
+
+      # (re)open the logfile if necessary
+      unless @logs.has_key? where_str
+        if @logs.size > @bot.config['irclog.max_open_files']
+          @logs.keys.sort do |a, b|
+            @logs[a][0] <=> @logs[b][0]
+          end.slice(0, @logs.size - @bot.config['irclog.max_open_files']).each do |w|
+            logfile_close w, "idle since #{@logs[w][0]}"
+          end
+        end
+        fp = logfilepath(where_str, now)
+        FileUtils.mkdir_p File.dirname(fp)
+        f = File.new(fp, "a")
+        f.sync = true
+        f.puts "[#{stamp}] @ Log started by #{@bot.myself.nick}"
+        @logs[where_str] = [now, f]
+      end
+      @logs[where_str][1].puts "[#{stamp}] #{message}"
+      @logs[where_str][0] = now
+      #debug "[#{stamp}] <#{where}> #{message}"
+    end
+    @logs.keys.each { |w| logfile_close(w, 'rescan or shutdown') }
+    debug 'loggers_thread terminating'
+  end
+end
+
+ilm = IrcLogModule.new
+ilm.priority = -1
+

data/lib/rbot/core/remote.rb

@@ -0,0 +1,401 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Remote service provider for rbot
+#
+# Author:: Giuseppe Bilotta (giuseppe.bilotta@gmail.com)
+#
+# From an idea by halorgium <rbot@spork.in>.
+#
+# TODO find a way to manage session id (logging out, manually and/or
+# automatically)
+
+require 'drb/drb'
+
+module ::Irc
+class Bot
+
+  module Auth
+
+    # We extend the BotUser class to handle remote logins
+    #
+    class BotUser
+
+      # A rather simple method to handle remote logins. Nothing special, just a
+      # password check.
+      #
+      def remote_login(password)
+        if password == @password
+          debug "remote login for #{self.inspect} succeeded"
+          return true
+        else
+          return false
+        end
+      end
+    end
+
+    # We extend the ManagerClass to handle remote logins
+    #
+    class ManagerClass
+
+      MAX_SESSION_ID = 2**128 - 1
+
+      # Creates a session id when the given password matches the given
+      # botusername
+      #
+      def remote_login(botusername, pwd)
+        @remote_users = Hash.new unless defined? @remote_users
+        n = BotUser.sanitize_username(botusername)
+        k = n.to_sym
+        raise "No such BotUser #{n}" unless include?(k)
+        bu = @allbotusers[k]
+        if bu.remote_login(pwd)
+          raise "ran out of session ids!" if @remote_users.length == MAX_SESSION_ID
+          session_id = rand(MAX_SESSION_ID)
+          while @remote_users.has_key?(session_id)
+            session_id = rand(MAX_SESSION_ID)
+          end
+          @remote_users[session_id] = bu
+          return session_id
+        end
+        return false
+      end
+
+      # Returns the botuser associated with the given session id
+      def remote_user(session_id)
+        return everyone unless session_id
+        return nil unless defined? @remote_users
+        if @remote_users.has_key?(session_id)
+          return @remote_users[session_id]
+        else
+          return nil
+        end
+      end
+    end
+
+  end
+
+
+  # A RemoteMessage is similar to a BasicUserMessage
+  #
+  class RemoteMessage
+    # associated bot
+    attr_reader :bot
+
+    # when the message was received
+    attr_reader :time
+
+    # remote client that originated the message
+    attr_reader :source
+
+    # contents of the message
+    attr_accessor :message
+
+    def initialize(bot, source, message)
+      @bot = bot
+      @source = source
+      @message = message
+      @time = Time.now
+    end
+
+    # The target of a RemoteMessage
+    def target
+      @bot
+    end
+
+    # Remote messages are always 'private'
+    def private?
+      true
+    end
+  end
+
+  # The RemoteDispatcher is a kind of MessageMapper, tuned to handle
+  # RemoteMessages
+  #
+  class RemoteDispatcher < MessageMapper
+
+    # It is initialized by passing it the bot instance
+    #
+    def initialize(bot)
+      super
+    end
+
+    # The map method for the RemoteDispatcher returns the index of the inserted
+    # template
+    #
+    def map(botmodule, *args)
+      super
+      return @templates.length - 1
+    end
+
+    # The unmap method for the RemoteDispatcher nils the template at the given index,
+    # therefore effectively removing the mapping
+    #
+    def unmap(botmodule, handle)
+      tmpl = @templates[handle]
+      raise "Botmodule #{botmodule.name} tried to unmap #{tmpl.inspect} that was handled by #{tmpl.botmodule}" unless tmpl.botmodule == botmodule.name
+      debug "Unmapping #{tmpl.inspect}"
+      @templates[handle] = nil
+      @templates.clear unless @templates.nitems > 0
+    end
+
+    # We redefine the handle() method from MessageMapper, taking into account
+    # that @parent is a bot, and that we don't handle fallbacks.
+    #
+    # On failure to dispatch anything, the method returns false. If dispatching
+    # is successfull, the method returns a Hash.
+    #
+    # Presently, the hash returned on success has only one key, :return, whose
+    # value is the actual return value of the successfull dispatch.
+    # 
+    # TODO this same kind of mechanism could actually be used in MessageMapper
+    # itself to be able to handle the case of multiple plugins having the same
+    # 'first word' ...
+    #
+    #
+    def handle(m)
+      return false if @templates.empty?
+      failures = []
+      @templates.each do |tmpl|
+        # Skip this element if it was unmapped
+        next unless tmpl
+        botmodule = @parent.plugins[tmpl.botmodule]
+        options, failure = tmpl.recognize(m)
+        if options.nil?
+          failures << [tmpl, failure]
+        else
+          action = tmpl.options[:action]
+          unless botmodule.respond_to?(action)
+            failures << [tmpl, "#{botmodule} does not respond to action #{action}"]
+            next
+          end
+          auth = tmpl.options[:full_auth_path]
+          debug "checking auth for #{auth}"
+          # We check for private permission
+          if m.bot.auth.allow?(auth, m.source, '?')
+            debug "template match found and auth'd: #{action.inspect} #{options.inspect}"
+            return :return => botmodule.send(action, m, options)
+          end
+          debug "auth failed for #{auth}"
+          # if it's just an auth failure but otherwise the match is good,
+          # don't try any more handlers
+          return false
+        end
+      end
+      failures.each {|f, r|
+        debug "#{f.inspect} => #{r}"
+      }
+      debug "no handler found"
+      return false
+    end
+
+  end
+
+    # The Irc::Bot::RemoteObject class represents and object that will take care
+    # of interfacing with remote clients
+    #
+    # Example client session:
+    #
+    #   require 'drb'
+    #   rbot = DRbObject.new_with_uri('druby://localhost:7268')
+    #   id = rbot.delegate(nil, 'remote login someuser somepass')[:return]
+    #   rbot.delegate(id, 'some secret command')
+    #
+    # Of course, the remote login is only neede for commands which may not be available
+    # to everyone
+    #
+    class RemoteObject
+
+      # We don't want this object to be copied clientside, so we make it undumpable
+      include DRbUndumped
+
+      # Initialization is simple
+      def initialize(bot)
+        @bot = bot
+      end
+
+      # The delegate method. This is the main method used by remote clients to send
+      # commands to the bot. Most of the time, the method will be called with only
+      # two parameters (session id and a String), but we allow more parameters
+      # for future expansions.
+      #
+      # The session_id can be nil, meaning that the remote client wants to work as
+      # an anoynomus botuser.
+      #
+      def delegate(session_id, *pars)
+        warn "Ignoring extra parameters" if pars.length > 1
+        cmd = pars.first
+        client = @bot.auth.remote_user(session_id)
+        raise "No such session id #{session_id}" unless client
+        debug "Trying to dispatch command #{cmd.inspect} from #{client.inspect} authorized by #{session_id.inspect}"
+        m = RemoteMessage.new(@bot, client, cmd)
+        @bot.remote_dispatcher.handle(m)
+      end
+
+      private :instance_variables, :instance_variable_get, :instance_variable_set
+    end
+
+    # The bot also manages a single (for the moment) remote dispatcher. This method
+    # makes it accessible to the outside world, creating it if necessary.
+    #
+    def remote_dispatcher
+      if defined? @remote_dispatcher
+        @remote_dispatcher
+      else
+        @remote_dispatcher = RemoteDispatcher.new(self)
+      end
+    end
+
+    # The bot also manages a single (for the moment) remote object. This method
+    # makes it accessible to the outside world, creating it if necessary.
+    #
+    def remote_object
+      if defined? @remote_object
+        @remote_object
+      else
+        @remote_object = RemoteObject.new(self)
+      end
+    end
+
+  module Plugins
+
+    # We create a new Ruby module that can be included by BotModules that want to
+    # provide remote interfaces
+    #
+    module RemoteBotModule
+
+      # The remote_map acts just like the BotModule#map method, except that
+      # the map is registered to the @bot's remote_dispatcher. Also, the remote map handle
+      # is handled for the cleanup management
+      #
+      def remote_map(*args)
+        @remote_maps = Array.new unless defined? @remote_maps
+        @remote_maps << @bot.remote_dispatcher.map(self, *args)
+      end
+
+      # Unregister the remote maps.
+      #
+      def remote_cleanup
+        return unless defined? @remote_maps
+        @remote_maps.each { |h|
+          @bot.remote_dispatcher.unmap(self, h)
+        }
+        @remote_maps.clear
+      end
+
+      # Redefine the default cleanup method.
+      #
+      def cleanup
+        super
+        remote_cleanup
+      end
+    end
+
+    # And just because I like consistency:
+    #
+    module RemoteCoreBotModule
+      include RemoteBotModule
+    end
+
+    module RemotePlugin
+      include RemoteBotModule
+    end
+
+  end
+
+end
+end
+
+class RemoteModule < CoreBotModule
+
+  include RemoteCoreBotModule
+
+  Config.register Config::BooleanValue.new('remote.autostart',
+    :default => true,
+    :requires_rescan => true,
+    :desc => "Whether the remote service provider should be started automatically")
+
+  Config.register Config::IntegerValue.new('remote.port',
+    :default => 7268, # that's 'rbot'
+    :requires_rescan => true,
+    :desc => "Port on which the remote interface will be presented")
+
+  Config.register Config::StringValue.new('remote.host',
+    :default => '127.0.0.1',
+    :requires_rescan => true,
+    :desc => "Host on which the remote interface will be presented")
+
+  def initialize
+    super
+    @port = @bot.config['remote.port']
+    @host = @bot.config['remote.host']
+    @drb = nil
+    begin
+      start_service if @bot.config['remote.autostart']
+    rescue => e
+      error "couldn't start remote service provider: #{e.inspect}"
+    end
+  end
+
+  def start_service
+    raise "Remote service provider already running" if @drb
+    @drb = DRb.start_service("druby://#{@host}:#{@port}", @bot.remote_object)
+  end
+
+  def stop_service
+    @drb.stop_service if @drb
+    @drb = nil
+  end
+
+  def cleanup
+    stop_service
+    super
+  end
+
+  def handle_start(m, params)
+    if @drb
+      rep = "remote service provider already running"
+      rep << " on port #{@port}" if m.private?
+    else
+      begin
+        start_service(@port)
+        rep = "remote service provider started"
+        rep << " on port #{@port}" if m.private?
+      rescue
+        rep = "couldn't start remote service provider"
+      end
+    end
+    m.reply rep
+  end
+
+  def remote_test(m, params)
+    @bot.say params[:channel], "This is a remote test"
+  end
+
+  def remote_login(m, params)
+    id = @bot.auth.remote_login(params[:botuser], params[:password])
+    raise "login failed" unless id
+    return id
+  end
+
+end
+
+remote = RemoteModule.new
+
+remote.map "remote start",
+  :action => 'handle_start',
+  :auth_path => ':manage:'
+
+remote.map "remote stop",
+  :action => 'handle_stop',
+  :auth_path => ':manage:'
+
+remote.default_auth('*', false)
+
+remote.remote_map "remote test :channel",
+  :action => 'remote_test'
+
+remote.remote_map "remote login :botuser :password",
+  :action => 'remote_login'
+
+remote.default_auth('login', true)