ircbot 0.0.2

data/lib/irc/localize.rb

@@ -0,0 +1,260 @@
+=begin header
+localization extension
+  IO supporting coding system conversion
+
+  $Author: igarashi $
+  $Date: 2001/01/02 00:21:18 $
+
+  Copyright (C) 1998-2001 Hiroshi IGARASHI
+=end
+
+require 'kconv'
+#require 'uconv'
+
+$vsave, $VERBOSE = $VERBOSE, FALSE
+
+module Kernel
+  private
+
+  def println(*args)
+=begin
+print with ln
+=end
+    STDOUT.println(*args)
+  end
+
+  def eprint(*args)
+=begin
+print to stderr
+=end
+    STDERR.print(*args)
+  end
+
+  def eprintln(*args)
+=begin
+eprint with ln
+=end
+    STDERR.println(*args)
+  end
+end
+
+# IO class extension
+class IO
+  def println(*args)
+=begin
+print with ln
+=end
+    if args.length > 0
+      print(*args)
+    end
+    print("\n")
+  end
+  public(:println)
+end
+
+class << ARGF
+  def lineno
+    $.
+  end
+  def path
+    filename
+  end
+end
+
+## available only if kconv ext module imported
+if defined?(Kconv)
+
+  module Kernel
+    private
+
+    # lreadline
+    def lreadline(*arg)
+      Kconv.tointern(readline(*arg))
+    end
+
+    # lgets
+    def lgets(*arg)
+      ret = gets(*arg)
+      unless ret.nil?
+	Kconv.tointern(ret)
+      else
+	nil
+      end
+    end
+
+    def p(*args)
+      args.each { |arg|
+	println(Kconv.toextern(arg.inspect))
+      }
+    end
+
+    # lprint
+    def lprint(*args)
+      STDOUT.lprint(*args)
+    end
+  
+    # lprint with ln
+    def lprintln(*args)
+      STDOUT.lprintln(*args)
+    end
+
+    # leprint
+    def leprint(*args)
+      STDERR.lprint(*args)
+    end
+
+    def leprintln(*args)
+=begin
+leprint with ln
+=end
+      STDERR.lprintln(*args)
+    end
+  end
+
+  # Kconv module extension
+  module Kconv
+    ## local encoding
+    case $KIOCODE
+    ## EUC
+    when 'EUC'
+      alias_method(:toextern, :toeuc)
+    ## JIS
+    when 'JIS'
+      alias_method(:toextern, :tojis)
+    ## SJIS
+    when 'SJIS'
+      alias_method(:toextern, :tosjis)
+    else
+      case $KCODE
+      ## EUC
+      when 'EUC'
+	alias_method(:toextern, :toeuc)
+      ## JIS
+      when 'JIS'
+	alias_method(:toextern, :tojis)
+      ## SJIS
+      when 'SJIS'
+	alias_method(:toextern, :tosjis)
+      when 'NONE'
+	def toextern(str)
+	  str
+	end
+      else
+	raise "Unknown coding system(\"#{$KIOCODE}\")."
+      end
+    end
+
+    case $KCODE
+    ## EUC
+    when 'EUC'
+      alias_method(:tointern, :toeuc)
+    ## SJIS
+    when 'SJIS'
+      alias_method(:tointern, :tosjis)
+    when 'NONE'
+      def tointern(str)
+	str
+      end
+    else
+      raise "Unknown coding system(\"#{$KCODE}\")."
+    end
+
+    alias_method(:tolocal, :toextern)
+    module_function(:toextern, :tolocal, :tointern)
+  end
+end
+
+class << ARGF
+
+  if defined?(Kconv)
+    # lreadline
+    def lreadline(*arg)
+      Kconv.tointern(readline(*arg))
+    end
+    # lgets
+    def lgets(*arg)
+      ret = gets(*arg)
+      unless ret.nil?
+	Kconv.tointern(ret)
+      else
+	nil
+      end
+    end
+  end
+
+end
+
+class IO
+
+  if defined?(Kconv)
+
+    # lreadline
+    def lreadline(*arg)
+      Kconv.tointern(readline(*arg))
+    end
+
+    # lgets
+    def lgets(*arg)
+      ret = gets(*arg)
+      unless ret.nil?
+	Kconv.tointern(ret)
+      else
+	nil
+      end
+    end
+
+    # convert to local encoding and print 
+    def lprint(*args)
+      args.each { |arg|
+	print(Kconv.toextern(arg.to_s))
+      }
+    end
+    def jisprint(*args)
+      args.each { |arg|
+	print(Kconv.tojis(arg.to_s))
+      }
+    end
+    def eucprint(*args)
+      args.each { |arg|
+	print(Kconv.toeuc(arg.to_s))
+      }
+    end
+    def sjisprint(*args)
+      args.each { |arg|
+	print(Kconv.tosjis(arg.to_s))
+      }
+    end
+
+    def lprintln(*args)
+      lprint(*args)
+      print("\n")
+    end
+
+    def set_codesys(codesys_name)
+      case codesys_name
+      ## JIS
+      when 'JIS'
+	class << self
+	  alias_method(:lprint, :jisprint)
+	end
+      ## EUC
+      when 'EUC'
+	class << self
+	  alias_method(:lprint, :eucprint)
+	end
+      ## SJIS
+      when 'SJIS'
+	class << self
+	  alias_method(:lprint, :sjisprint)
+	end
+      when 'NONE'
+	alias_method(:lprint, :print)
+      else
+	raise "Unknown coding system(\"#{codesys_name}\")."
+      end
+    end
+    public(:lreadline, :lprint, :lprintln)
+  end
+end
+
+$VERBOSE = $vsave

data/lib/ircbot.rb

@@ -0,0 +1,41 @@
+
+require 'nkf'
+require 'pathname'
+require 'rubygems'
+require 'active_support'
+
+######################################################################
+### Load path
+
+Thread.abort_on_exception = true
+__DIR__ = File.dirname(__FILE__)
+
+$LOAD_PATH.unshift __DIR__ unless
+  $LOAD_PATH.include?(__DIR__) ||
+  $LOAD_PATH.include?(File.expand_path(__DIR__))
+
+require 'ircbot/framework'
+
+
+######################################################################
+### IRC library
+
+require 'irc/irc'
+require 'irc/agent'
+require 'irc/client'
+
+
+######################################################################
+### Ircbot library
+
+require 'ircbot/core_ext/rand-polimorphism'
+require 'ircbot/core_ext/writefile'
+require 'ircbot/core_ext/digest'
+require 'ircbot/core_ext/irc'
+
+
+######################################################################
+### Ircbot 
+
+require 'ircbot/reply_client'
+

data/lib/ircbot/agent_manager.rb

@@ -0,0 +1,89 @@
+# -*- coding: euc-jp -*-
+
+module Ircbot
+  ######################################################################
+  ### agent ��������륯�饹
+  ### (ľ�� agent �����Ѥ��ʤ��Τϡ�agent �δ�����ʻ���ƹԤ�����)
+  ######################################################################
+  class AgentManager
+    attr :cpi, true
+    attr :name
+    attr :created
+    attr :alive
+
+    def initialize (name, obj, client, arg = nil)
+      @name	= name
+      @cpi	= obj
+      @created	= Time.now
+      @alive	= nil
+      @client	= client
+      @arg      = arg
+
+      method = :do_construct
+      if @cpi.respond_to?(method)
+	@cpi.send(method, client)
+      end
+    end
+
+    def notifyMessage (msg)
+      # NOP
+    end
+
+    def start (arg = nil)
+      @arg = arg if arg
+
+      method = :do_start
+      if @cpi.respond_to?(method)
+	@cpi.send(method, @arg)
+      end
+
+      @alive = true
+    end
+
+    def stop
+      method = :do_destruct
+      if @cpi.respond_to?(method)
+	@cpi.send(method, nil)
+      end
+      @alive = nil
+    end
+
+    def alive?
+      @alive
+    end
+
+    def send (method, *args)
+      if alive?
+	return @cpi.send(method, *args)
+      else
+	return nil
+      end
+    end
+
+    # ���ꤵ�줿�᥽�åɷ���缡�¹Ԥ���
+    # 1�ļ¹Ԥ����齪λ���ɤΥ᥽�åɤ�������Ƥʤ����� nil ���֤���
+    def apply_methods (msg, methods)
+      methods = [methods] unless methods.is_a? Array
+      methods.each do |method|
+	next unless @cpi.respond_to?(method)
+	begin
+	  if msg
+	    if (result = send(method, msg))
+	      return result
+	    end
+	  else
+	    if (result = send(method))
+	      return result
+	    end
+	  end
+	rescue Exception => err
+	  error = "error: #{err} in #{self.name}"
+	  @client.syslog(error, :error)
+	  @client.syslog($@.join("\n"), :error)
+	  return error
+	end
+      end
+      return nil
+    end
+  end
+end

data/lib/ircbot/config_client.rb

@@ -0,0 +1,369 @@
+# -*- coding: euc-jp -*-
+
+require 'ircbot/agent_manager'
+require 'ircbot/ordered_hash'
+
+module Ircbot
+  class ConfigClient < IRC::Client
+    include ActiveSupport::Rescuable
+
+    attr :config
+    attr :messages
+    attr :agents
+
+    PARAM_STRING = %w( nick server username realname password port log syslog help pidfile )
+    PARAM_ARRAY  = %w( agents channels )
+    PARAM_KEYS   = PARAM_STRING + PARAM_ARRAY
+
+    class << self
+      ######################################################################
+      ### config �ե����뤫�������ͤ��ɤ߹��ߡ�Client ���֥������Ȥ����
+      ######################################################################
+      def read_config(input, debug = nil)
+	case input
+	when IO			# already IO (NOP)
+	when String		# maybe file
+	  begin
+	    input = File.open(input)
+	  rescue Exception
+	    $stderr.puts("cannot read config file. (#{input})")
+	    exit
+	  end
+	else
+	  $stderr.puts("missing config file.")
+	  exit
+	end
+
+	params		= {}
+	param_regexp	= self::PARAM_KEYS.join('|')
+	while (line = input.gets)
+	  case line
+	  when /^#/		# ignore
+	  when /^(#{param_regexp})\s*=\s*/io
+	    key, val = $1.downcase, $'.chomp
+	    symbol = key.intern
+	    case key
+	    when *self::PARAM_STRING
+	      params[symbol] = val
+	    when *self::PARAM_ARRAY
+	      params[symbol] = val.split(/[,\s]+/)
+	    else		# IGNORE...
+	      $stderr.puts "ignore: #{key} = #{params[symbol].inspect}(#{params[symbol].class})"
+	    end
+	    if debug
+	      $stderr.puts "debug: #{key} = #{params[symbol].inspect}(#{params[symbol].class})"
+	    end
+	  end
+	end
+	self.new(params)
+      end
+    end
+
+    def initialize (hash = {})
+      @config	= hash
+
+      # ɬ�ܹ���
+      @nick	= hash[:nick]			|| missing_error(:nick)
+      @server	= hash[:server]			|| missing_error(:server)
+      @username = hash[:username] || @nick	|| missing_error(:username)
+      @realname = hash[:realname] || @nick	|| missing_error(:realname)
+      @channels	= hash[:channels]
+
+      @port	= hash[:port]		|| 6667
+      @password = hash[:password]	|| 'xxx'
+      @log	= hash[:log]
+      @syslog	= hash[:syslog]
+      @help	= hash[:help]		|| '�إ�פ�����ޤ���(config �� help �Ԥ򸫤ޤ�)'
+      @agents	= OrderedHash.new	# String��Agent
+
+      @agents_opt = {}          # ����������Ȥε�ư�����Ѥ��륪�ץ����
+
+      @mynames		= [@nick, @realname].compact.sort.uniq
+      @cachesize	= (hash[:cachesize].to_i < 1) ? 100 : hash[:cachesize].to_i
+      @last_message_id	= 0
+      @messages		= []
+
+      @last_ping_time	= nil   # �Ǹ�� CMD_PING �������ä�����
+    end
+
+    def each_agent
+      @agents.each_pair do |name, agent|
+	yield(agent)
+      end
+    end
+
+    def missing_error (arg)
+      syslog("#{arg}�����ꤵ��Ƥ��ޤ���", :fatal)
+    end
+
+    def syslog (message, level = :normal)
+      line = Time.now.strftime("%Y-%m-%d %H:%M:%S #{message}")
+      case level
+      when :normal
+	if @syslog
+	  File.open!(@syslog, "a+") {|file| file.puts line; file.flush}
+	end
+      when :error
+	syslog(message, :normal)
+	$stderr.puts line
+      when :fatal
+	syslog(message, :error)
+	exit 1
+      else
+	syslog("syslog: wrong level(#{level}): mes=[#{message}]", :error)
+      end
+    end
+
+    def write_pid_file
+      # write pid information to a file
+      filename = config[:pidfile]
+      pid = Process::pid
+      if filename
+	if exist_process?
+	  raise "another process is running. (pid=#{pid})"
+	end
+	File::write!(pid.to_s, filename, 'w+')
+	File::chmod(0664, filename)
+      end
+    end
+
+    def exist_process?
+      filename = config[:pidfile]	or return nil
+      File::exists?(filename)		or return nil
+      pid = File::open(filename).read	or return nil
+
+      begin
+	Process::getpgid(pid.to_i)
+	return pid.chomp
+      rescue Errno::ESRCH
+	return nil
+      end
+    end
+
+    def do_log (message)
+      begin
+	case @log
+	when NilClass
+	  return nil
+	when /\/$/
+	  format = "#{@log}/%Y%m/%d.log"
+	when String
+	  format = @log
+	else
+	  syslog("do_log: unknown type #{@log.class}", :error)
+	  @log = nil
+	  return nil
+	end
+
+	now  = Time.now
+	path = now.strftime(format)
+	from = message[:from]
+	to   = message[:to]
+	str  = message[:str]
+
+	File.open!(path, "a+") {|file|
+	  file.puts now.strftime("%H:%M <#{to}:#{from}> #{str}")
+	}
+	return nil
+      rescue
+	syslog("do_log: #{$!}", :error)
+	@log = nil
+      end
+    end
+
+
+    ######################################################################
+    ### IRC �Υ��ͥ������ط�
+    ######################################################################
+
+    def start
+      write_pid_file
+      syslog("#{self.class}: system starts.")
+
+      create_message_thread
+
+      # ����³�ΰ٤ˡ�initialize ��Ǥʤ������ǸƤӽФ���
+
+      connect
+      join
+
+      # ����������Ȥ���Ͽ
+      @config[:agents].each do |name|
+        registerAgent(name)
+      end
+      each_agent {|agent| agent.start}
+
+      startThreads
+      @message_thread.join
+      @log_thread.raise(Stop.new)
+      @log_thread.join
+
+    rescue Exception => e
+      begin
+        syslog("catch exception: #{e}(#{e.class})", :error)
+        rescue_with_handler(e) or raise
+      rescue Recover => recover
+        irc.stop
+        sleep recover.wait
+        retry
+      end
+    end
+
+    def ping_timeout
+      stop
+      exit
+    end
+
+    def startThreads
+      super
+      @ping_thread = Thread.start {
+        eprintln("ping_thread started.") if $DEBUG
+        #_putlog("debug", "ping_thread started.")
+        sec = 3600 # �����ÿ� PING ���ʤ��� ping_timeout��Ƥ�
+        while true
+          sleep 60
+          case @last_ping_time
+          when Time
+            if Time.now > @last_ping_time + sec
+              ping_timeout
+            end
+          end
+        end
+        eprintln("ping_thread stopped.") if $DEBUG
+        #_putlog("debug", "ping_thread stopped.")
+      }
+      eprintln("ping_thread created.") if $DEBUG
+    end
+
+    # derived from original ruby-irc::Client#stop
+    def stop
+      # Agent�����
+      each_agent do |agent|
+	agent.stop
+      end
+
+      disconnect
+      @message_thread.raise(IRC::Stop.new)
+      destroy_message_thread
+    end
+
+    # derived from original ruby-irc::Client's one.
+    def connect 
+      @log_queue	= Queue.new
+      @connection	= IRC::Connection::new(@log_queue)
+
+      @connection.connect(@server, @port.to_s)
+      @connection.sendPASS(@password)
+      @connection.sendNICK(@nick)
+      @connection.sendUSER(nil, @username, "hostname", "servername", @realname)
+    end
+
+    # derived from original ruby-irc::Client's one.
+    def disconnect 
+      @connection.sendQUIT(@nick, nil)
+      @connection.disconnect
+    end
+
+    def join
+      channels	= @channels.join(',')
+      @connection.send(CMD_JOIN, nil, @nick, channels, '')
+    end
+
+    def names (channel = nil)
+      @connection.sendNAMES(channel)
+    end
+
+    ######################################################################
+    ### Message Handling
+    ######################################################################
+
+    def handlePING(msg)
+#      p [:handlePING, Time.now]
+      super
+      @last_ping_time = Time.now
+    end
+
+    def add_message (msg)
+      index = (@last_message_id += 1) % @cachesize
+      @messages[index] = msg
+
+      return index
+    end
+
+    def previous_message (msg)
+      index = (@cachesize + msg[:id].to_i - 1) % @cachesize
+      @messages[index]
+    end
+
+    def last_messages (size)
+      mes = @messages[@last_message_id % @cachesize] or return []
+      array = []
+      i = 0
+      j = 0
+
+      while (size > 0)
+        j += 1
+        break if i > @cachesize # maybe looping. give up
+        break if j > 100
+        break unless mes
+
+        i += 1
+#        p [mes[:from],mes[:to],mes[:str], size, i, mes[:from] == mes[:to]]
+        unless mes[:from] == mes[:to]
+          array << mes
+          size -= 1
+        end
+        mes = mes.previous
+      end
+      return array
+    end
+
+    # created by yu-yan@4th.to
+    def create_message_thread
+      @message_last   = nil
+      @message_timer  = Time.now
+      @message_queue  = Queue.new
+      @message_thread = Thread.new(@message_timer, @message_queue) { |message_timer, message_queue|
+	loop {
+	  now           = Time.now
+	  message_timer = [message_timer, now].max + 2
+
+	  if (message_timer - now) > 15
+	    sleep(3)
+	  else
+	    sleep(0.1)
+	  end
+
+#	  STDERR.print("timer:#{message_timer.strftime('%H:%M:%S')} - now:#{now.strftime('%H:%M:%S')} = #{message_timer - now}\n")
+
+	  message, to = message_queue.pop
+	  privmsg(message, to)
+#	  STDERR.print("MSG:", message, "\n")
+	}
+      }
+    end
+
+    def destroy_message_thread
+      if @message_thread.is_a? Thread
+	@message_thread.kill
+      end
+    end
+
+    # derived from original ruby-irc::Client's one.
+    def handleMessageLoop 
+      loop do
+        msg = @connection.recv
+        if msg.nil?
+          syslog("handleMessageLoop: Abnormal terminated.", :error)
+	  abnormal_terminated
+        end
+        handleMessageInternal(msg)
+        distributeMessage(msg)
+      end
+    end
+
+    def abnormal_terminated
+      raise IRC::AbnormalTerminated
+    end
+  end
+end