rbot 0.9.10 → 0.9.12

data/lib/rbot/timer.rb

@@ -1,205 +1,270 @@
-module Timer
+# changes:
+#  1. Timer::Timer ---> Timer
+#  2. timer id is now the object_id of the action
+#  3. Timer resolution removed, we're always arbitrary precision now
+#  4. I don't see any obvious races [not that i did see any in old impl, though]
+#  5. We're tickless now, so no need to jerk start/stop
+#  6. We should be pretty fast now, wrt old impl
+#  7. reschedule/remove/block now accept nil as an action id (meaning "current")
+#  8. repeatability is ignored for 0-period repeatable timers
+#  9. configure() method superceeds reschedule() [the latter stays as compat]
 
-  # timer event, something to do and when/how often to do it
+require 'thread'
+require 'monitor'
+
+# Timer handler, manage multiple Action objects, calling them when required.
+# When the Timer is constructed, a new Thread is created to manage timed
+# delays and run Actions.
+#
+# XXX: there is no way to stop the timer currently. I'm keeping it this way
+# to weed out old Timer implementation legacy in rbot code. -jsn.
+class Timer
+
+  # class representing individual timed action
   class Action
-    
-    # when this action is due next (updated by tick())
-    attr_reader :in
-    
-    # is this action blocked? if so it won't be run
-    attr_accessor :blocked
-
-    # period:: how often (seconds) to run the action
-    # data::   optional data to pass to the proc
-    # once::   optional, if true, this action will be run once then removed
-    # func::   associate a block to be called to perform the action
-    # 
-    # create a new action
-    def initialize(period, data=nil, once=false, &func)
-      @blocked = false
-      @period = period
-      @in = period
-      @func = func
-      @data = data
-      @once = once
-      @last_tick = Time.new
-    end
 
-    def tick
-      diff = Time.new - @last_tick
-      @in -= diff
-      @last_tick = Time.new
-    end
+    # Time when the Action should be called next
+    attr_accessor :next
 
-    def inspect 
-      "#<#{self.class}:#{@period}s:#{@once ? 'once' : 'repeat'}>"
-    end
+    # Options are:
+    # start::    Time when the Action should be run for the first time.
+    #            Repeatable Actions will be repeated after that, see
+    #            :period. One-time Actions will not (obviously)
+    #            Default: Time.now + :period
+    # period::   How often repeatable Action should be run, in seconds.
+    #            Default: 1
+    # blocked::  if true, Action starts as blocked (i.e. will stay dormant
+    #            until unblocked)
+    # args::     Arguments to pass to the Action callback. Default: []
+    # repeat::   Should the Action be called repeatedly? Default: false
+    # code::     You can specify the Action body using &block, *or* using
+    #            this option.
+
+    def initialize(options = {}, &block)
+      opts = {
+        :period => 1,
+        :blocked => false,
+        :args => [],
+        :repeat => false
+      }.merge(options)
 
-    def due?
-      @in <= 0
+      @block = nil
+      debug("adding timer #{self} :period => #{opts[:period]}, :repeat => #{opts[:repeat].inspect}")
+      self.configure(opts, &block)
+      debug("added #{self}")
     end
 
-    # run the action by calling its proc
-    def run
-      @in += @period
-      # really short duration timers can overrun and leave @in negative,
-      # for these we set @in to @period
-      @in = @period if @in <= 0
-      if(@data)
-        @func.call(@data)
+    # Provides for on-the-fly reconfiguration of the Actions
+    # Accept the same arguments as the constructor
+    def configure(opts = {}, &block)
+      @period = opts[:period] if opts.include? :period
+      @blocked = opts[:blocked] if opts.include? :blocked
+      @repeat = opts[:repeat] if opts.include? :repeat
+
+      if block_given?
+        @block = block 
+      elsif opts[:code]
+        @block = opts[:code]
+      end
+
+      raise 'huh?? blockless action?' unless @block
+      if opts.include? :args
+        @args = Array === opts[:args] ? opts[:args] : [opts[:args]]
+      end
+
+      if opts[:start] and (Time === opts[:start])
+        self.next = opts[:start]
       else
-        @func.call
+        self.next = Time.now + (opts[:start] || @period)
       end
-      return @once
-    end
-  end
-  
-  # timer handler, manage multiple Action objects, calling them when required.
-  # The timer must be ticked by whatever controls it, i.e. regular calls to
-  # tick() at whatever granularity suits your application's needs.
-  # 
-  # Alternatively you can call run(), and the timer will spawn a thread and
-  # tick itself, intelligently shutting down the thread if there are no
-  # pending actions.
-  class Timer
-    def initialize(granularity = 0.1)
-      @granularity = granularity
-      @timers = Hash.new
-      @handle = 0
-      @lasttime = 0
-      @should_be_running = false
-      @thread = false
-      @next_action_time = 0
-    end
-    
-    # period:: how often (seconds) to run the action
-    # data::   optional data to pass to the action's proc
-    # func::   associate a block with add() to perform the action
-    # 
-    # add an action to the timer
-    def add(period, data=nil, &func)
-      debug "adding timer, period #{period}"
-      @handle += 1
-      @timers[@handle] = Action.new(period, data, &func)
-      start_on_add
-      return @handle
     end
 
-    # period:: how long (seconds) until the action is run
-    # data::   optional data to pass to the action's proc
-    # func::   associate a block with add() to perform the action
-    # 
-    # add an action to the timer which will be run just once, after +period+
-    def add_once(period, data=nil, &func)
-      debug "adding one-off timer, period #{period}"
-      @handle += 1
-      @timers[@handle] = Action.new(period, data, true, &func)
-      start_on_add
-      return @handle
+    # modify the Action period
+    def reschedule(period, &block)
+      self.configure(:period => period, &block)
     end
 
-    # remove action with handle +handle+ from the timer
-    def remove(handle)
-      @timers.delete(handle)
+    # blocks an Action, so it won't be run
+    def block
+      @blocked = true
     end
-    
-    # block action with handle +handle+
-    def block(handle)
-      @timers[handle].blocked = true
+
+    # unblocks a blocked Action
+    def unblock
+      @blocked = false
     end
 
-    # unblock action with handle +handle+
-    def unblock(handle)
-      @timers[handle].blocked = false
+    def blocked?
+      @blocked
     end
 
-    # you can call this when you know you're idle, or you can split off a
-    # thread and call the run() method to do it for you.
-    def tick 
-      if(@lasttime == 0)
-        # don't do anything on the first tick
-        @lasttime = Time.now
-        return
+    # calls the Action callback, resets .next to the Time of the next call,
+    # if the Action is repeatable.
+    def run(now = Time.now)
+      raise 'inappropriate time to run()' unless self.next && self.next <= now
+      self.next = nil
+      begin
+        @block.call(*@args)
+      rescue Exception => e
+        error "Timer action #{self.inspect}: block #{@block.inspect} failed!"
+        error e.pretty_inspect
+        debug e.backtrace.join("\n")
       end
-      @next_action_time = 0
-      diff = (Time.now - @lasttime).to_f
-      @lasttime = Time.now
-      @timers.each { |key,timer|
-        timer.tick
-        next if timer.blocked
-        if(timer.due?)
-          if(timer.run)
-            # run once
-            @timers.delete(key)
-          end
-        end
-        if @next_action_time == 0 || timer.in < @next_action_time
-          @next_action_time = timer.in
-        end
-      }
-      #debug "ticked. now #{@timers.length} timers remain"
-      #debug "next timer due at #{@next_action_time}"
-    end
 
-    # for backwards compat - this is a bit primitive
-    def run(granularity=0.1)
-      while(true)
-        sleep(granularity)
-        tick
+      if @repeat && @period > 0
+        self.next = now + @period
       end
+
+      return self.next
     end
+  end
+
+  # creates a new Timer and starts it.
+  def initialize
+    self.extend(MonitorMixin)
+    @tick = self.new_cond
+    @thread = nil
+    @actions = Hash.new
+    @current = nil
+    self.start
+  end
 
-    def running?
-      @thread && @thread.alive?
+  # Creates and installs a new Action, repeatable by default.
+  # _period_:: Action period
+  # _opts_::   options for Action#new, see there
+  # _block_::  Action callback code
+  #
+  # Returns the id of the created Action
+  def add(period, opts = {}, &block)
+    a = Action.new({:repeat => true, :period => period}.merge(opts), &block)
+    self.synchronize do
+      @actions[a.object_id] = a
+      @tick.signal
     end
+    return a.object_id
+  end
 
-    # return the number of seconds until the next action is due, or 0 if
-    # none are outstanding - will only be accurate immediately after a
-    # tick()
-    def next_action_time
-      @next_action_time
+  # Creates and installs a new Action, one-time by default.
+  # _period_:: Action delay
+  # _opts_::   options for Action#new, see there
+  # _block_::  Action callback code
+  #
+  # Returns the id of the created Action
+  def add_once(period, opts = {}, &block)
+    self.add(period, {:repeat => false}.merge(opts), &block)
+  end
+
+  # blocks an existing Action
+  # _aid_:: Action id, obtained previously from add() or add_once()
+  def block(aid)
+    debug "blocking #{aid}"
+    self.synchronize { self[aid].block }
+  end
+
+  # unblocks an existing blocked Action
+  # _aid_:: Action id, obtained previously from add() or add_once()
+  def unblock(aid)
+    debug "unblocking #{aid}"
+    self.synchronize do
+      self[aid].unblock
+      @tick.signal
     end
+  end
 
-    # start the timer, it spawns a thread to tick the timer, intelligently
-    # shutting down if no events remain and starting again when needed.
-    def start
-      return if running?
-      @should_be_running = true
-      start_thread unless @timers.empty?
+  # removes an existing blocked Action
+  # _aid_:: Action id, obtained previously from add() or add_once()
+  def remove(aid)
+    self.synchronize do
+      @actions.delete(aid) # or raise "nonexistent action #{aid}"
     end
+  end
+
+  alias :delete :remove
 
-    # stop the timer from ticking
-    def stop
-      @should_be_running = false
-      stop_thread
+  # Provides for on-the-fly reconfiguration of Actions
+  # _aid_::   Action id, obtained previously from add() or add_once()
+  # _opts_::  see Action#new
+  # _block_:: (optional) new Action callback code
+  def configure(aid, opts = {}, &block)
+    self.synchronize do
+      self[aid].configure(opts, &block)
+      @tick.signal
     end
-    
-    private
-    
-    def start_on_add
-      if running?
-        stop_thread
-        start_thread
-      elsif @should_be_running
-        start_thread
+  end
+
+  # changes Action period
+  # _aid_:: Action id
+  # _period_:: new period
+  # _block_:: (optional) new Action callback code
+  def reschedule(aid, period, &block)
+    self.configure(aid, :period => period, &block)
+  end
+
+  def start
+    raise 'already started' if @thread
+    @stopping = false
+    debug "starting timer #{self}"
+    @thread = Thread.new do
+      loop do
+        tmout = self.run_actions
+        break if tmout and tmout < 0
+        self.synchronize { @tick.wait(tmout) }
       end
     end
-    
-    def stop_thread
-      return unless running?
-      @thread.kill
-    end
-    
-    def start_thread
-      return if running?
-      @thread = Thread.new do
-        while(true)
-          tick
-          exit if @timers.empty?
-          sleep(@next_action_time)
+  end
+
+  def stop
+    raise 'already stopped' unless @thread
+    debug "stopping timer #{self}..."
+    @stopping = true
+    self.synchronize { @tick.signal }
+    @thread.join(60) or @thread.kill
+    debug "timer #{self} stopped"
+    @thread = nil
+  end
+
+  protected
+
+  def [](aid)
+    aid ||= @current
+    raise "no current action" unless aid
+    raise "nonexistent action #{aid}" unless @actions.include? aid
+    @actions[aid]
+  end
+
+  def run_actions(now = Time.now)
+    nxt = nil
+    @actions.keys.each do |k|
+      return -1 if @stopping
+      a = @actions[k]
+      next if (!a) or a.blocked?
+
+      if a.next <= now
+        begin
+          @current = k
+          v = a.run(now)
+        ensure
+          @current = nil
         end
+
+        unless v
+          @actions.delete k
+          next
+        end
+      else
+        v = a.next
       end
+
+      nxt = v if v and ((!nxt) or (v < nxt))
     end
 
+    if nxt
+      delta = nxt - now
+      delta = 0 if delta < 0
+      return delta
+    else
+      return nil
+    end
   end
+
 end

data/po/en_US/rbot-alias.po

@@ -0,0 +1,82 @@
+# Gettext template file for rbot
+# Copyright (C) 2007 Tom Gilbert
+# This file is distributed under the same license as the rbot package.
+# Yaohan Chen <yaohan.chen@gmail.com>, 2007.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: rbot\n"
+"POT-Creation-Date: 2008-06-20 01:49+0200\n"
+"PO-Revision-Date: 2007-07-14 00:06-0400\n"
+"Last-Translator: Yaohan Chen <yaohan.chen@gmail.com>\n"
+"Language-Team: English\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+#: data/rbot/plugins/alias.rb:50
+msgid "Data file is not found or corrupt, reinitializing data"
+msgstr ""
+
+#: data/rbot/plugins/alias.rb:58
+msgid "Invalid alias entry %{alias} : %{command} in %{filename}: %{reason}"
+msgstr ""
+
+#: data/rbot/plugins/alias.rb:74
+msgid "The definition you provided is invalid: %{reason}"
+msgstr ""
+
+#: data/rbot/plugins/alias.rb:85 data/rbot/plugins/alias.rb:102
+msgid "No such alias is defined"
+msgstr ""
+
+#: data/rbot/plugins/alias.rb:91
+msgid "No aliases defined"
+msgstr ""
+
+#: data/rbot/plugins/alias.rb:100
+msgid "Alias of %{command}"
+msgstr ""
+
+#: data/rbot/plugins/alias.rb:112
+msgid ""
+"The arguments in alias must match the substitutions in command, and vice "
+"versa"
+msgstr ""
+
+#: data/rbot/plugins/alias.rb:117
+msgid "Error mapping %{text} as command: %{error}"
+msgstr ""
+
+#: data/rbot/plugins/alias.rb:138
+msgid ""
+"The alias seems to have caused infinite recursion. Please examine your alias "
+"definitions"
+msgstr ""
+
+#: data/rbot/plugins/alias.rb:142
+msgid ""
+"Error handling the alias, The alias %{text} is not defined or has beeen "
+"removed. I will stop responding to it after rescan,"
+msgstr ""
+
+#: data/rbot/plugins/alias.rb:154
+msgid "Create and use aliases for commands. Topics: create, commands"
+msgstr ""
+
+#: data/rbot/plugins/alias.rb:163
+msgid ""
+"\"alias <text> => <command>\" => add text as an alias of command. Text can "
+"contain placeholders marked with : or * for :words and *multiword arguments. "
+"The command can contain placeholders enclosed with < > which will be "
+"substituded with argument values. For example: alias googlerbot *terms => "
+"google site:ruby-rbot.org <terms>"
+msgstr ""
+
+#: data/rbot/plugins/alias.rb:165
+msgid ""
+"alias list => list defined aliases | alias whatis <alias> => show definition "
+"of the alias | alias remove <alias> => remove defined alias | see the "
+"\"create\" topic about adding aliases"
+msgstr ""