rumpy 0.9.17 → 0.9.19

data/README.rdoc

@@ -1,61 +1,90 @@
-== Welcome to Rumpy
+= Welcome to Rumpy
 
 Rumpy is some kind of framework to make up your own jabber bot quickly.
 It uses {ActiveRecord}[https://github.com/rails/rails/tree/master/activerecord] and {XMPP4R}[http://home.gna.org/xmpp4r/].
 
-Our goal is 'DO NOT REINVENT THE WHEEL'.
+Our goal is <b>'DO NOT REINVENT THE WHEEL'</b>.
 
-== Features
+= Features
 
-* Forget about xmpp-related things. Just set your login & password.
+* Forget about xmpp-related things. Just set your login and password.
 * Forget about database-related things. Just set your database preferences.
 * Write logic using ActiveRecord and callback functions.
 
-== Getting started
-
-* Rumpy uses 3 configs:
-  +database.yml+  ::  Your bot's database preferences.
-  +lang.yml+      ::  Your bot's responces. Append to existing keys more answers and use them like @lang['someanswer]. **There must be at least 3 keys : hello /used when somebody add bot/, stranger /when somebody trying talk to bot without authorization/, authorized /when bot get authorized/.
-  +xmpp.yml+      ::  Your bot's account settings.
-  Look at Examples section to see this configs.
-* Implement your ActiveRecord models in one directory. You have to implement at least one model, for users.
-* Prepare your database.
-* Start writing your class:
-  * Mix in Rumpy::Bot module
-
-    include Rumpy::Bot
-  * Define some instance variables:
-    @models_path    ::  Path to directory, containing all ruby files with models.
-    @config_path    ::  Path to directory, containing all ruby config files
-    @main_model     ::  Symbol, that stands for main model. If your main model is, e.g. +User+, set @main_model to +:user+
-    @pid_file       ::  Optional variable, sets location of the file to which pid of detached process will be saved. If not set, it equals +NameOfYourBotClass.downcase+ + '.pid'.
-    @log_file       ::  Optional variable, sets location of the file for errors. Default is +STDERR+.
-    @log_level      ::  Optional variable, sets the logging severity threshold. Possible values are Logger::DEBUG < Logger::INFO < Logger::WARN < Logger::ERROR < Logger::FATAL < Logger::UNKNOWN. Default is Logger::INFO.
-    @log_shift_age  ::  Optional variable, sets number of old log files to keep, or frequency of rotation (daily, weekly or monthly).
-    @log_shift_size ::  Optional variable, sets maximum logfile size.
-    @log_progname   ::  Optional variable, sets logging program name.
-    @log_formatter  ::  Optional variable, sets logging formatter. @log_formatter#call is invoked with 4 arguments; +severity+, +time+, +progname+ and +msg+ for each log.
-    @bot_name       ::  Optional name of the bot. Default is name of bot's class.
-    @bot_version    ::  Optional version of the bot. Default is 1.0.0.
-  * Write 3 methods:
-    backend_func() -> [[receiver, message]*]    :: This optional method is running all the time in the loop. Returns array of pairs [receiver, message].
-    parser_func(msg) -> +pars_result+           :: This method parses any incoming message and returs results.
-    do_func(usermodel, pars_results) -> +msg+  :: This method uses results from +parser_func+, doing some stuff with model of user, from whom message was received. Returns message to be send to this user
-* Run bot:
-  You can run your bot without detaching:
-    Rumpy.run YourBotClassName
-  Or with detaching:
-    #To start your bot:
-    Rumpy.start YourBotClassName
-    #To stop it:
-    Rumpy.stop YourBotClassName
-
-== Example
-
-Look at {CuteBot}[https://github.com/MPogoda/CuteBot], {yatodo}[https://github.com/MPogoda/yatodo], {Noty}[https://github.com/Ximik/Noty].
-
-Feel free to contact us about any questions related to Rumpy.
-
-== License
+= Getting started
+
+== Configs
+
+Rumpy uses 3 configs:
++database.yml+  ::  Your bot's database preferences.
++lang.yml+      ::  Your bot's responces. Append to existing keys more answers and use them like <tt>@lang['someanswer']</tt>. There *MUST* be at least 3 keys: +hello+ (<em>used when somebody adds bot</em>), +stranger+ (<em>used when somebody trying to speak with bot without authorization</em>) and +authorized+ (<em>used when bot gets authorization</em>).
++xmpp.yml+      ::  Your bot's jabber account settings.
+Look at Examples section to see this configs.
+
+== ActiveRecord models
+
+Implement your *ActiveRecord* models.
+You have to implement at least one model, for users.
+
+== Prepare your database
+
+== Your bot's class
+
+=== Rumpy::Bot module
+
+You have to mix in your bot's class the <tt>Rumpy::Bot</tt> module:
+
+  include Rumpy::Bot
+
+=== Instance variables
+
++Rumpy+ uses next instance variables:
+<tt>@models_files</tt>    ::  Array of your models files.
+<tt>@config_path</tt>     ::  Path to directory, containing all ruby config files. Default is +config+.
+<tt>@main_model</tt>      ::  Symbol, that stands for main model. For example, if your main model is +User+, you have to set <tt>@main_model</tt> to <tt>:user</tt>. Default is <tt>:user</tt>.
+<tt>@pid_file</tt>        ::  Location of the file to which pid of detached process will be saved. Default is <tt>NameOfYourBotClass.downcase + '.pid'</tt>.
+<tt>@log_file</tt>        ::  Location of the logfile. Default is +STDERR+.
+<tt>@log_level</tt>       ::  Logging severity threshold. Possible values are the same the logger from standard library has. Default is <tt>Logger::INFO</tt>.
+<tt>@log_shift_age</tt>   ::  Number of old log files to keep, or frequency of rotation (_daily_, _weekly_ or _monthly_). Default is +0+.
+<tt>@log_shift_size</tt>  ::  Maximum logfile size. Default is +1048576+.
+<tt>@logger</tt>          ::  If you need more accuracy in configuring logger, simply create one. It have to be compatible with standard library's +logger+.
+<tt>@bot_name</tt>        ::  Name of the bot. Default is name of bot's class.
+<tt>@bot_version</tt>     ::  Optional version of the bot. Default is <tt>1.0.0</tt>.
+
+=== Instance methods
+
++Rumpy+ needs only three methods:
+<tt>backend_func() -> [[receiver, message]*]</tt> :: This *optional* method is running all the time in the loop. Returns array of pairs <tt>[receiver, message]</tt>.
+<tt>parser_func(msg) -> pars_result</tt>          :: This method parses any incoming message and returs results of parsing.
+<tt>do_func(usermodel, pars_results) -> msg</tt>  :: This method uses results from +parser_func+, doing some stuff with model of user, from whom the message was received. Returns the answer to this user.
+
+_Hint_: empty answer will not be sent.
+
+== Run bot
+
+You can run your bot without detaching:
+
+  Rumpy.run YourBotClassName.new
+
+Or with detaching:
+
+  bot = YourBotClassName.new
+  #To start your bot:
+  Rumpy.start bot
+  #To stop it:
+  Rumpy.stop bot
+
+= Examples
+
+Look at
+* {CuteBot}[https://github.com/MPogoda/CuteBot]
+* {yatodo}[https://github.com/MPogoda/yatodo]
+* {Noty}[https://github.com/Ximik/Noty]
+
+= Contacts
+
+Feel free to contact us about any questions related to +Rumpy+.
+
+= License
 
 Rumpy is released under the MIT license.

data/lib/rumpy.rb

@@ -7,14 +7,13 @@ require 'logger'
 
 module Rumpy
 
-  # Create new instance of `botclass`, start it in new process,
+  # Start bot in new process,
   # detach this process and save the pid of process in pid_file
-  def self.start(botclass)
-    bot           = botclass.new
+  def self.start(bot)
     pf            = pid_file bot
     return false if File.exist? pf
 
-    bot.log_file  = "#{botclass.to_s.downcase}.log"
+    bot.log_file  = "#{bot.class.to_s.downcase}.log"
 
     pid = fork do
       bot.start
@@ -24,12 +23,12 @@ module Rumpy
       file.puts pid
     end
     true
-  end # def self.start(botclass)
+  end # def self.start(bot)
 
   # Determine the name of pid_file, read pid from this file
   # and try to kill process with this pid
-  def self.stop(botclass)
-    pf = pid_file botclass.new
+  def self.stop(bot)
+    pf = pid_file bot
     return false unless File.exist? pf
     begin
       File.open(pf) do |file|
@@ -39,11 +38,11 @@ module Rumpy
       File.unlink pf
     end
     true
-  end # def self.stop(botclass)
+  end # def self.stop(bot)
 
-  # Create new instance of `botclass` and start it without detaching
-  def self.run(botclass)
-    botclass.new.start
+  # Start bot without detaching
+  def self.run(bot)
+    bot.start
   end
 
   # Determine the name of file where thid pid will stored to
@@ -69,17 +68,20 @@ module Rumpy
       logger_init
 
       init
+
       connect
-      prepare_users
 
+      set_iq_callback
       set_subscription_callback
       set_message_callback
-      set_iq_callback
 
       start_backend_thread
+      start_output_queue_thread
+
+      prepare_users
 
       @logger.info 'Bot is going ONLINE'
-      send_msg Jabber::Presence.new(nil, @status, @priority)
+      @output_queue.enq Jabber::Presence.new(nil, @status, @priority)
 
       add_signal_trap
 
@@ -92,18 +94,21 @@ module Rumpy
     private
 
     def logger_init
-      @log_file             ||= STDERR
-      @log_level            ||= Logger::INFO
-      @logger                 = Logger.new @log_file, @log_shift_age, @log_shift_size
-      @logger.level           = @log_level
-      @logger.progname        = @log_progname
-      @logger.formatter       = @log_formatter
-      @logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+      if @logger.nil? then
+        @log_file             ||= STDERR
+        @log_level            ||= Logger::INFO
+        @logger                 = Logger.new @log_file, @log_shift_age, @log_shift_size
+        @logger.level           = @log_level
+        @logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+      end
 
       @logger.info 'starting bot'
     end
 
     def init
+      @config_path ||= 'config'
+      @main_model  ||= :user
+
       @logger.debug 'initializing some variables'
 
       xmppconfig  = YAML::load_file @config_path + '/xmpp.yml'
@@ -119,13 +124,13 @@ module Rumpy
       @client     = Jabber::Client.new @jid
       Jabber::Version::SimpleResponder.new(@client, @bot_name || self.class.to_s, @bot_version || '1.0.0', RUBY_PLATFORM)
 
-      if @models_path then
+      if @models_files then
         dbconfig  = YAML::load_file @config_path + '/database.yml'
         @logger.info 'loaded database.yml'
         @logger.debug "database.yml: #{dbconfig.inspect}"
         ActiveRecord::Base.establish_connection dbconfig
         @logger.info 'database connection established'
-        Dir[@models_path].each do |file|
+        @models_files.each do |file|
           self.class.require file
           @logger.info "added models file '#{file}'"
         end
@@ -133,13 +138,12 @@ module Rumpy
 
       @main_model = Object.const_get @main_model.to_s.capitalize
       @logger.info "main model set to #{@main_model}"
-      def @main_model.find_by_jid(jid)
-        super jid.strip.to_s
-      end
 
       @queues = Hash.new do |h, k|
         h[k]  = Queue.new
       end
+
+      @output_queue = Queue.new
     end # def init
 
     def connect
@@ -153,35 +157,33 @@ module Rumpy
       @logger.info 'xmpp connection established'
     end
 
-    def prepare_users
-      @logger.debug 'clear wrong users'
-
-      @roster.items.each do |jid, item|
-        user = @main_model.find_by_jid jid
-        if user.nil? or item.subscription != :both then
-          @logger.info "deleting from roster user with jid #{jid}"
-          item.remove
-        end
-      end
-      @main_model.find_each do |user|
-        items = @roster.find user.jid
-        if items.empty? then
-          @logger.info "deleting from database user with jid #{user.jid}"
-          user.destroy
-        else
-          start_user_thread user
+    def set_iq_callback
+      @client.add_iq_callback do |iq|
+        @logger.debug "got iq #{iq}"
+        if iq.type == :get then # hack for pidgin (STOP USING IT)
+          response = iq.answer true
+          if iq.elements['time'] == "<time xmlns='urn:xmpp:time'/>" then
+            @logger.debug 'this is time request, okay'
+            response.set_type :result
+            tm = Time.now
+            response.elements['time'].add REXML::Element.new('tzo')
+            response.elements['time/tzo'].text = tm.xmlschema[-6..-1]
+            response.elements['time'].add REXML::Element.new('utc')
+            response.elements['time/utc'].text = tm.utc.xmlschema
+          else
+            response.set_type :error
+          end # if iq.elements['time']
+          @output_queue.enq response
         end
       end
-
-      @main_model.connection_pool.release_connection
-    end # def prepare_users
+    end # def set_iq_callback
 
     def set_subscription_callback
       @roster.add_subscription_request_callback do |item, presence|
         jid = presence.from
         @roster.accept_subscription jid
-        send_msg presence.answer.set_type :subscribe
-        send_msg Jabber::Message.new(jid, @lang['hello']).set_type :chat
+        @output_queue.enq presence.answer.set_type :subscribe
+        @output_queue.enq Jabber::Message.new(jid, @lang['hello']).set_type :chat
 
         @logger.info "#{jid} just subscribed"
       end
@@ -199,10 +201,10 @@ module Rumpy
             start_user_thread user
 
             @logger.info "added new user: #{user.jid}"
-            send_msg Jabber::Message.new(item.jid, @lang['authorized']).set_type :chat
+            @output_queue.enq Jabber::Message.new(item.jid, @lang['authorized']).set_type :chat
           end
         rescue ActiveRecord::StatementInvalid
-          statement_invalid
+          statement_invalid_error
           retry
         rescue ActiveRecord::ConnectionTimeoutError
           connection_timeout_error
@@ -220,35 +222,14 @@ module Rumpy
             @logger.debug "got normal message #{msg}"
 
             @queues[msg.from.strip.to_s].enq msg
-          else # if @roster[msg.from] and @roster[msg.from].subscription == :both
+          else
             @logger.debug "user not in roster: #{msg.from}"
 
-            send_msg msg.answer.set_body @lang['stranger']
-          end # if @roster[msg.from] and @roster[msg.from].subscription == :both
-        end # if msg.type != :error and msg.body and msg.from
-      end # @client.add_message_callback
-    end # def set_message_callback
-
-    def set_iq_callback
-      @client.add_iq_callback do |iq|
-        @logger.debug "got iq #{iq}"
-        if iq.type == :get then # hack for pidgin (STOP USING IT)
-          response = iq.answer true
-          if iq.elements['time'] == "<time xmlns='urn:xmpp:time'/>" then
-            @logger.debug 'this is time request, okay'
-            response.set_type :result
-            tm = Time.now
-            response.elements['time'].add REXML::Element.new('tzo')
-            response.elements['time/tzo'].text = tm.xmlschema[-6..-1]
-            response.elements['time'].add REXML::Element.new('utc')
-            response.elements['time/utc'].text = tm.utc.xmlschema
-          else
-            response.set_type :error
-          end # if iq.elements['time']
-          send_msg response
+            @output_queue.enq msg.answer.set_body @lang['stranger']
+          end
         end
       end
-    end # def set_iq_callback
+    end # def set_message_callback
 
     def start_backend_thread
       Thread.new do
@@ -256,11 +237,11 @@ module Rumpy
           loop do
             backend_func().each do |result|
               message = Jabber::Message.new(*result).set_type :chat
-              send_msg message if message.body and message.to
+              @output_queue.enq message if message.body and message.to
             end
           end
         rescue ActiveRecord::StatementInvalid
-          statement_invalid
+          statement_invalid_error
           retry
         rescue ActiveRecord::ConnectionTimeoutError
           connection_timeout_error
@@ -271,17 +252,34 @@ module Rumpy
       end if self.respond_to? :backend_func
     end # def start_backend_thread
 
+    def start_output_queue_thread
+      Thread.new do
+        @logger.info "Output queue initialized"
+        until (msg = @output_queue.deq) == :halt do
+          if msg.nil? then
+            @logger.debug "got nil message. wtf?"
+          else
+            @logger.debug "sending message #{msg}"
+            @client.send msg
+          end
+        end
+        @logger.info "Output queue destroyed"
+      end
+    end # def start_output_queue_thread
+
     def add_signal_trap
       Signal.trap :TERM do |signo| # soft stop
         @logger.info 'Bot is unavailable'
-        send_msg Jabber::Presence.new.set_type :unavailable
+        @output_queue.enq Jabber::Presence.new.set_type :unavailable
 
         @queues.each do |user, queue|
           queue.enq :halt
         end
-        until @queues.empty?
-          sleep 1
-        end
+        sleep 1 until @queues.empty?
+
+        @output_queue.enq :halt
+        sleep 1 until @output_queue.empty?
+
         @client.close
 
         @logger.info 'terminating'
@@ -290,28 +288,41 @@ module Rumpy
       end
     end
 
+    def prepare_users
+      @logger.debug 'clear wrong users'
+
+      @roster.items.each do |jid, item|
+        user = @main_model.find_by_jid jid.strip.to_s
+        if user.nil? or item.subscription != :both then
+          @logger.info "deleting from roster user with jid #{jid}"
+          item.remove
+        end
+      end
+      @main_model.find_each do |user|
+        items = @roster.find user.jid
+        if items.empty? then
+          @logger.info "deleting from database user with jid #{user.jid}"
+          user.destroy
+        else
+          start_user_thread user
+        end
+      end
+
+      @main_model.connection_pool.release_connection
+    end # def prepare_users
+
     def start_user_thread(user)
       Thread.new(user) do |user|
+        @logger.debug "thread for user #{user.jid} started"
 
-        loop do
-          msg = @queues[user.jid].deq
-
+        until (msg = @queues[user.jid].deq).kind_of? Symbol do
           begin
-            if msg.kind_of? Symbol then # :unsubscribe or :halt
-              if msg == :unsubscribe
-                @logger.info "removing user #{user.jid}"
-                user.destroy
-              end
-              @queues.delete user.jid
-              break
-            end
-
             pars_results = parser_func msg.body
             @logger.debug "parsed message: #{pars_results.inspect}"
-            message = do_func user, pars_results
-            send_msg msg.answer.set_body message unless message.empty?
+            answer = do_func user, pars_results
+            @output_queue.enq msg.answer.set_body answer unless answer.nil? or answer.empty?
           rescue ActiveRecord::StatementInvalid
-            statement_invalid
+            statement_invalid_error
             retry
           rescue ActiveRecord::ConnectionTimeoutError
             connection_timeout_error
@@ -321,18 +332,19 @@ module Rumpy
           end # begin
 
           @main_model.connection_pool.release_connection
-        end # loop do
-        Thread.current.join
-      end # Thread.new do
-    end # def start_user_thread(queue)
+        end # until (msg = @queues[user.jid].deq).kind_of? Symbol do
 
-    def send_msg(msg)
-      return if msg.nil?
-      @logger.debug "sending message: #{msg}"
-      @client.send msg
-    end
+        if msg == :unsubscribe
+          @logger.info "removing user #{user.jid}"
+          user.destroy
+        end
+
+        @queues.delete user.jid
+
+      end # Thread.new do
+    end # def start_user_thread(user)
 
-    def statement_invalid
+    def statement_invalid_error
       @logger.warn 'Statement Invalid catched'
       @logger.info 'Reconnecting to database'
       @main_model.connection.reconnect!

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rumpy
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 9
-  - 17
-  version: 0.9.17
+  - 19
+  version: 0.9.19
 platform: ruby
 authors: 
 - Tsokurov A.G.
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-18 00:00:00 +03:00
+date: 2011-08-20 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency