gnms 2.1.0.rc1

data/lib/external/fog.rb

@@ -0,0 +1,41 @@
+class Fog < String
+   VERSION = '1.0.1'
+
+   # Returns an encrypted +string+ based on the +degree+ that you pass. The
+   # default degree is 13. The +degree+ is more or less a salt value.
+   #
+   def initialize(string, degree=13)
+      @degree = degree.to_i
+      str = encrypt(string, degree)
+      super(str)
+   end
+
+   # Decrypts the string using the +degree+ passed to the constructor.
+   #
+   def decrypt
+      unpack('C*').map{ |e| e -= @degree }.pack('C*')
+   end
+
+   # The to_s method is identical to inspect, in order to prevent the
+   # literal quotation marks from potentially messing up things.
+   #
+   def to_s
+      inspect
+   end
+
+   # Decrypts an arbitrary string using +degree+. You must know the degree
+   # with which the string was originally encrypted in order for this method
+   # to work properly.
+   #
+   def self.decrypt(string, degree=13)
+      string.unpack('C*').map{ |e| e -= degree }.pack('C*')
+   end
+
+   private
+
+   # A private method used to encrypt a string based on +degree+.
+   #
+   def encrypt(str=self, degree=@degree)
+      str.unpack('C*').map{ |e| e += degree }.pack('C*')
+   end
+end

data/lib/external/jjmx.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env jruby
+require 'rubygems'
+require 'jmx4r'
+#./jjmx.rb 192.168.2.10 9003 user pass "java.lang:type=Memory" "heap_memory_usage non_heap_memory_usage"
+
+if ARGV.length < 6
+	print "error: missing parameters\n"
+	exit
+end
+
+host = ARGV[0]
+port = ARGV[1]
+user = ARGV[2]
+pass = ARGV[3]
+object = ARGV[4]
+attrs = ARGV[5]
+
+begin
+	if user != ""
+		JMX::MBean.establish_connection :host => host, :port => port, :username => user, :password => pass
+	else
+		JMX::MBean.establish_connection :host => host, :port => port
+	end
+rescue Exception => msg
+		print "error: ",msg, "\n"
+		exit
+end
+
+mbean = JMX::MBean.find_by_name object
+
+attrs.split.each {|attr|
+	print attr,": "
+	begin
+		val=mbean.send(attr)
+		if val.class == Java::JavaxManagementOpenmbean::CompositeDataSupport
+			print val["used"]
+		else
+			print val
+		end
+	rescue
+		print "error"
+	end
+	
+	print "\n"
+}

data/lib/external/sms.rb

@@ -0,0 +1,282 @@
+# encoding: utf-8
+
+begin
+	require "serialport"
+rescue LoadError
+	$log.error("Serialport is not installed, you should install the gem to have SMS notification")
+end
+require "socket"
+
+
+class SMSController
+  
+  def initialize(bluetoothDevice,phoneNum,smsText)
+    @@bluetoothDevice = bluetoothDevice
+    @@phoneNum = phoneNum
+    @@smsText = smsText
+  end
+  
+  @@t_bin =  
+    {
+    "0000" => "0", 
+    '0001' => '1', 
+    '0010' => '2',
+    '0011' => '3', 
+    '0100' => '4', 
+    '0101' => '5', 
+    '0110' => '6', 
+    '0111' => '7', 
+    '1000' => '8', 
+    '1001' => '9', 
+    '1010' => 'A', 
+    '1011' => 'B', 
+    '1100' => 'C',  
+    '1101' => 'D', 
+    '1110' => 'E', 
+    '1111' => 'F' 
+    }
+    
+  @@bit7 = 
+    {
+      "0000000" => "@",
+      "0000001" => "£",
+      "0000010" => "$",
+      "0000011" => "¥",
+      "0000100" => "è",
+      "0000101" => "é",
+      "0000110" => "ù",
+      "0000111" => "ì",
+      "0001000" => "ò",
+      "0001001" => "Ç",
+      "0001010" => "\r",
+      "0001011" => "Ø",
+      "0001100" => "ø",
+      "0001101" => "\n\r",
+      "0001110" => "Å",
+      "0001111" => "å",
+      "0010000" => "∆",
+      "0010001" => "_",
+      "0010010" => "fi",
+      "0010011" => "GAMMA",
+      "0010100" => "LAMBDA",
+      "0010101" => "Ω",
+      "0010110" => "π",
+      "0010111" => "PSI",
+      "0011000" => "∑",
+      "0011001" => "THETA",
+      "0011010" => "XI",
+      "0011011" => "\n",
+      "0011100" => "Æ",
+      "0011101" => "æ",
+      "0011110" => "ß",
+      "0011111" => "É",
+      "0100000" => " ",
+      "0100001" => "!",
+      "0100010" => "\"",
+      "0100011" => "#",
+      "0100100" => "¢",
+      "0100101" => "%",
+      "0100110" => "&",
+      "0100111" => "\'",
+      "0101000" => "(",
+      "0101001" => ")",
+      "0101010" => "*",
+      "0101011" => "+",
+      "0101100" => ",",
+      "0101101" => "-",
+      "0101110" => ".",
+      "0101111" => "/",
+      "0110000" => "0",
+      "0110001" => "1",
+      "0110010" => "2",
+      "0110011" => "3",
+      "0110100" => "4",
+      "0110101" => "5",
+      "0110110" => "6",
+      "0110111" => "7",
+      "0111000" => "8",
+      "0111001" => "9",
+      "0111010" => ":",
+      "0111011" => ",",
+      "0111100" => "<",
+      "0111101" => "=",
+      "0111110" => ">",
+      "0111111" => "?",
+      "1000000" => "¡",
+      "1000001" => "A",
+      "1000010" => "B",
+      "1000011" => "C",
+      "1000100" => "D",
+      "1000101" => "E",
+      "1000110" => "F",
+      "1000111" => "G",
+      "1001000" => "H",
+      "1001001" => "I",
+      "1001010" => "J",
+      "1001011" => "K",
+      "1001100" => "L",
+      "1001101" => "M",
+      "1001110" => "N",
+      "1001111" => "O",
+      "1010000" => "P",
+      "1010001" => "Q",
+      "1010010" => "R",
+      "1010011" => "S",
+      "1010100" => "T",
+      "1010101" => "U",
+      "1010110" => "V",
+      "1010111" => "W",
+      "1011000" => "X",
+      "1011001" => "Y",
+      "1011010" => "Z",
+      "1011011" => "Ä",
+      "1011100" => "Ö",
+      "1011101" => "N",
+      "1011110" => "Ü",
+      "1011111" => "§",
+      "1100000" => "?",
+      "1100001" => "a",
+      "1100010" => "b",
+      "1100011" => "c",
+      "1100100" => "d",
+      "1100101" => "e",
+      "1100110" => "f",
+      "1100111" => "g",
+      "1101000" => "h",
+      "1101001" => "i",
+      "1101010" => "j",
+      "1101011" => "k",
+      "1101100" => "l",
+      "1101101" => "m",
+      "1101110" => "n",
+      "1101111" => "o",
+      "1110000" => "p",
+      "1110001" => "q",
+      "1110010" => "r",
+      "1110011" => "s",
+      "1110100" => "t",
+      "1110101" => "u",
+      "1110110" => "v",
+      "1110111" => "w",
+      "1111000" => "x",
+      "1111001" => "y",
+      "1111010" => "Z",
+      "1111011" => "ä",
+      "1111100" => "ö",
+      "1111101" => "ñ",
+      "1111110" => "ü",
+      "1111111" => "à",
+      }
+      
+   def sendSMS()
+    	createSMS(@@phoneNum,@@smsText)
+   end
+   
+
+   def nibble_swap(str)
+       strLen = str.length
+       swap_str = ""
+       if strLen%2 != 0 then        
+           str = str + "f"
+       end
+       i = 0
+       while i < strLen
+           swap_str = swap_str + str.slice(i..(i+1)).reverse
+           i += 2
+       end
+       return swap_str
+   end  
+   
+  def ascii2bin7bit(str)
+      strLen = str.length
+      binStr = ""
+      i = 0
+      while i < strLen
+          char = str.slice(i..i)
+          @@bit7.each do |k,v|
+              if v == char then
+                  binStr = binStr + k
+              end
+          end
+          i += 1
+      end
+      return binStr
+  end
+  
+  def code7bin2octet(septets)
+
+      spLen = septets.length - 6
+      octets = ""
+      octets_n = ""
+      oct = {}
+      n = 0
+      i = 0
+      while i < spLen
+          if (n <= 6) then
+              sep = septets.slice((i)..(i+6))
+              sep_n = septets.slice((i+7)..(i+13))
+              if !(sep_n.length == 0) then
+                  oct[n] = sep_n.slice((6-n)..6) + sep.slice(0..(6-n))
+                  octets_n = octets_n + oct[n]
+              else
+                  oct[n] = sep.slice(0..(6-n))
+                  while oct[n].length < 8
+                      oct[n] = "0" + oct[n]
+                  end
+                  octets_n = octets_n + oct[n]
+              end
+              n += 1
+          else
+              n = 0
+          end
+          i += 7
+      end
+      hex = []
+      j = 0   
+      while j < octets_n.length
+          bin = octets_n.slice(j..j+3)
+          hex.insert(-1,@@t_bin["#{bin}"])
+          j += 4
+      end
+      return hex.to_s
+  end
+  
+  def createSMS(phoneNum,smsText)
+    
+      @sms_praefix = "001100"
+
+      @phone_num = phoneNum
+      @sms_msg = smsText
+      @pn_len = @phone_num.length
+      @pn_len = sprintf('%02X',@pn_len)
+      @trp = "91"
+      @phone_num = nibble_swap(@phone_num)
+      @sms_infix = "0000FF"
+      @msg_len = @sms_msg.length
+      @msg_len = sprintf('%02X',@msg_len)
+      @sms_msg = ascii2bin7bit(@sms_msg)
+      @sms_msg = code7bin2octet(@sms_msg)
+      @sms = @sms_praefix + @pn_len + @trp + @phone_num + @sms_infix + @msg_len + @sms_msg
+      @sms_len = @sms.length/2 -1
+
+      sp = SerialPort.new(@@bluetoothDevice, 9600,8,1,SerialPort::NONE)
+      open(@@bluetoothDevice)
+
+      sp.write( "at+cmgs=#{@sms_len}" + "\n\r")
+
+      sleep 2
+
+      sp.write( "#{@sms}" + "\032")
+
+      sleep 2
+
+      sp.close
+  end  
+
+end
+
+#mySMS = SMSController.new("/dev/cu.Your_Paired_Bluetooth_Device","Number_Of_SMS_Receiver,"SMS_Message")
+#mySMS = SMSController.new("/dev/cu.W900i-SerialPort-1","43676844256222","hallo world!")
+
+#mySMS.sendSMS
+

data/lib/external/xmpp4r-simple.rb

@@ -0,0 +1,497 @@
+# Jabber::Simple - An extremely easy-to-use Jabber client library.
+# Copyright 2006 Blaine Cook <blaine@obvious.com>, Obvious Corp.
+#
+# Jabber::Simple is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# Jabber::Simple is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Jabber::Simple; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+# copy the lib as the default version
+# 20090422 and fix from https://github.com/blaine/xmpp4r-simple/blob/master/lib/xmpp4r-simple.rb
+
+require 'rubygems'
+require 'xmpp4r'
+require 'xmpp4r/roster'
+require 'xmpp4r/vcard'
+ 
+module Jabber
+ 
+  class ConnectionError < StandardError #:nodoc:
+  end
+  
+  class Contact #:nodoc:
+ 
+    include DRb::DRbUndumped if defined?(DRb::DRbUndumped)
+ 
+    def initialize(client, jid)
+      @jid = jid.respond_to?(:resource) ? jid : JID.new(jid)
+      @client = client
+    end
+ 
+    def inspect
+      "Jabber::Contact #{jid.to_s}"
+    end
+ 
+    def subscribed?
+      [:to, :both].include?(subscription)
+    end
+ 
+    def subscription
+      roster_item && roster_item.subscription
+    end
+ 
+    def ask_for_authorization!
+      subscription_request = Presence.new.set_type(:subscribe)
+      subscription_request.to = jid
+      client.send!(subscription_request)
+    end
+    
+    def unsubscribe!
+      unsubscription_request = Presence.new.set_type(:unsubscribe)
+      unsubscription_request.to = jid
+      client.send!(unsubscription_request)
+      client.send!(unsubscription_request.set_type(:unsubscribed))
+    end
+ 
+    def jid(bare=true)
+      bare ? @jid.strip : @jid
+    end
+ 
+    private
+ 
+    def roster_item
+      client.roster.items[jid]
+    end
+   
+    def client
+      @client
+    end
+  end
+ 
+  class Simple
+ 
+    include DRb::DRbUndumped if defined?(DRb::DRbUndumped)
+ 
+    # Create a new Jabber::Simple client. You will be automatically connected
+    # to the Jabber server and your status message will be set to the string
+    # passed in as the status_message argument.
+    #
+    # jabber = Jabber::Simple.new("me@example.com", "password", "Chat with me - Please!")
+    def initialize(jid, password, status = nil, status_message = "Available")
+      @jid = jid
+      @password = password
+      @disconnected = false
+      status(status, status_message)
+      start_deferred_delivery_thread
+    end
+ 
+    def inspect #:nodoc:
+      "Jabber::Simple #{@jid}"
+    end
+    
+    # Send a message to jabber user jid.
+    #
+    # Valid message types are:
+    #
+    # * :normal (default): a normal message.
+    # * :chat: a one-to-one chat message.
+    # * :groupchat: a group-chat message.
+    # * :headline: a "headline" message.
+    # * :error: an error message.
+    #
+    # If the recipient is not in your contacts list, the message will be queued
+    # for later delivery, and the Contact will be automatically asked for
+    # authorization (see Jabber::Simple#add).
+    #
+    # message should be a string or a valid Jabber::Message object. In either case,
+    # the message recipient will be set to jid.
+    def deliver(jid, message, type=:chat)
+      contacts(jid) do |friend|
+        unless subscribed_to? friend
+          add(friend.jid)
+          return deliver_deferred(friend.jid, message, type)
+        end
+        if message.kind_of?(Jabber::Message)
+          msg = message
+          msg.to = friend.jid
+        else
+          msg = Message.new(friend.jid)
+          msg.type = type
+          msg.body = message
+        end
+        send!(msg)
+      end
+    end
+ 
+    # Set your presence, with a message.
+    #
+    # Available values for presence are:
+    #
+    # * nil: online.
+    # * :chat: free for chat.
+    # * :away: away from the computer.
+    # * :dnd: do not disturb.
+    # * :xa: extended away.
+    #
+    # It's not possible to set an offline status - to do that, disconnect! :-)
+    def status(presence, message)
+      @presence = presence
+      @status_message = message
+      stat_msg = Presence.new(@presence, @status_message)
+      send!(stat_msg)
+    end
+ 
+    # Ask the users specified by jids for authorization (i.e., ask them to add
+    # you to their contact list). If you are already in the user's contact list,
+    # add() will not attempt to re-request authorization. In order to force
+    # re-authorization, first remove() the user, then re-add them.
+    #
+    # Example usage:
+    #
+    # jabber_simple.add("friend@friendosaurus.com")
+    #
+    # Because the authorization process might take a few seconds, or might
+    # never happen depending on when (and if) the user accepts your
+    # request, results are placed in the Jabber::Simple#new_subscriptions queue.
+    def add(*jids)
+      contacts(*jids) do |friend|
+        next if subscribed_to? friend
+        friend.ask_for_authorization!
+      end
+    end
+ 
+    # Remove the jabber users specified by jids from the contact list.
+    def remove(*jids)
+      contacts(*jids) do |unfriend|
+        unfriend.unsubscribe!
+      end
+    end
+ 
+    # Returns true if this Jabber account is subscribed to status updates for
+    # the jabber user jid, false otherwise.
+    def subscribed_to?(jid)
+      contacts(jid) do |contact|
+        return contact.subscribed?
+      end
+    end
+ 
+    # If contacts is a single contact, returns a Jabber::Contact object
+    # representing that user; if contacts is an array, returns an array of
+    # Jabber::Contact objects.
+    #
+    # When called with a block, contacts will yield each Jabber::Contact object
+    # in turn. This is mainly used internally, but exposed as an utility
+    # function.
+    def contacts(*contacts, &block)
+      @contacts ||= {}
+      contakts = []
+      contacts.each do |contact|
+        jid = contact.to_s
+        unless @contacts[jid]
+          @contacts[jid] = contact.respond_to?(:ask_for_authorization!) ? contact : Contact.new(self, contact)
+        end
+        yield @contacts[jid] if block_given?
+        contakts << @contacts[jid]
+      end
+      contakts.size > 1 ? contakts : contakts.first
+    end
+ 
+    # Returns true if the Jabber client is connected to the Jabber server,
+    # false otherwise.
+    def connected?
+      @client ||= nil
+      connected = @client.respond_to?(:is_connected?) && @client.is_connected?
+      return connected
+    end
+ 
+    # Returns an array of messages received since the last time
+    # received_messages was called. Passing a block will yield each message in
+    # turn, allowing you to break part-way through processing (especially
+    # useful when your message handling code is not thread-safe (e.g.,
+    # ActiveRecord).
+    #
+    # e.g.:
+    #
+    # jabber.received_messages do |message|
+    # puts "Received message from #{message.from}: #{message.body}"
+    # end
+    def received_messages(&block)
+      dequeue(:received_messages, &block)
+    end
+ 
+    # Returns true if there are unprocessed received messages waiting in the
+    # queue, false otherwise.
+    def received_messages?
+      !queue(:received_messages).empty?
+    end
+ 
+    # Returns an array of presence updates received since the last time
+    # presence_updates was called. Passing a block will yield each update in
+    # turn, allowing you to break part-way through processing (especially
+    # useful when your presence handling code is not thread-safe (e.g.,
+    # ActiveRecord).
+    #
+    # e.g.:
+    #
+    # jabber.presence_updates do |friend, new_presence|
+    # puts "Received presence update from #{friend}: #{new_presence}"
+    # end
+    def presence_updates(&block)
+      updates = []
+      @presence_mutex.synchronize do
+        dequeue(:presence_updates) do |friend|
+          presence = @presence_updates[friend]
+          next unless presence
+          new_update = [friend, presence[0], presence[1]]
+          yield new_update if block_given?
+          updates << new_update
+          @presence_updates.delete(friend)
+        end
+      end
+      return updates
+    end
+    
+    # Returns true if there are unprocessed presence updates waiting in the
+    # queue, false otherwise.
+    def presence_updates?
+      !queue(:presence_updates).empty?
+    end
+ 
+    # Returns an array of subscription notifications received since the last
+    # time new_subscriptions was called. Passing a block will yield each update
+    # in turn, allowing you to break part-way through processing (especially
+    # useful when your subscription handling code is not thread-safe (e.g.,
+    # ActiveRecord).
+    #
+    # e.g.:
+    #
+    # jabber.new_subscriptions do |friend, presence|
+    # puts "Received presence update from #{friend.to_s}: #{presence}"
+    # end
+    def new_subscriptions(&block)
+      dequeue(:new_subscriptions, &block)
+    end
+    
+    # Returns true if there are unprocessed presence updates waiting in the
+    # queue, false otherwise.
+    def new_subscriptions?
+      !queue(:new_subscriptions).empty?
+    end
+    
+    # Returns an array of subscription notifications received since the last
+    # time subscription_requests was called. Passing a block will yield each update
+    # in turn, allowing you to break part-way through processing (especially
+    # useful when your subscription handling code is not thread-safe (e.g.,
+    # ActiveRecord).
+    #
+    # e.g.:
+    #
+    # jabber.subscription_requests do |friend, presence|
+    # puts "Received presence update from #{friend.to_s}: #{presence}"
+    # end
+    def subscription_requests(&block)
+      dequeue(:subscription_requests, &block)
+    end
+ 
+    # Returns true if auto-accept subscriptions (friend requests) is enabled
+    # (default), false otherwise.
+    def accept_subscriptions?
+      @accept_subscriptions = true if @accept_subscriptions.nil?
+      @accept_subscriptions
+    end
+ 
+    # Change whether or not subscriptions (friend requests) are automatically accepted.
+    def accept_subscriptions=(accept_status)
+      @accept_subscriptions = accept_status
+    end
+    
+    # Direct access to the underlying Roster helper.
+    def roster
+      return @roster if @roster
+      self.roster = Roster::Helper.new(client)
+    end
+ 
+    # Direct access to the underlying Jabber client.
+    def client
+      connect!() unless connected?
+      @client
+    end
+    
+    # Send a Jabber stanza over-the-wire.
+    def send!(msg)
+      attempts = 0
+      begin
+        attempts += 1
+        client.send(msg)
+      rescue Errno::EPIPE, IOError => e
+        sleep 1
+        disconnect
+        reconnect
+        retry unless attempts > 3
+        raise e
+      rescue Errno::ECONNRESET => e
+        sleep (attempts^2) * 60 + 60
+        disconnect
+        reconnect
+        retry unless attempts > 3
+        raise e
+      end
+    end
+ 
+    # Use this to force the client to reconnect after a force_disconnect.
+    def reconnect
+      @disconnected = false
+      connect!
+    end
+ 
+    # Use this to force the client to disconnect and not automatically
+    # reconnect.
+    def disconnect
+      disconnect!
+    end
+    
+    # Queue messages for delivery once a user has accepted our authorization
+    # request. Works in conjunction with the deferred delivery thread.
+    #
+    # You can use this method if you want to manually add friends and still
+    # have the message queued for later delivery.
+    def deliver_deferred(jid, message, type)
+      msg = {:to => jid, :message => message, :type => type}
+      queue(:pending_messages) << [msg]
+    end
+ 
+    private
+ 
+    def client=(client)
+      self.roster = nil # ensure we clear the roster, since that's now associated with a different client.
+      @client = client
+    end
+ 
+    def roster=(new_roster)
+      @roster = new_roster
+    end
+ 
+    def connect!
+      raise ConnectionError, "Connections are disabled - use Jabber::Simple::force_connect() to reconnect." if @disconnected
+      # Pre-connect
+      @connect_mutex ||= Mutex.new
+ 
+      # don't try to connect if another thread is already connecting.
+      return if @connect_mutex.locked?
+ 
+      @connect_mutex.lock
+      disconnect!(false) if connected?
+ 
+      # Connect
+      jid = JID.new(@jid)
+      my_client = Client.new(@jid)
+      my_client.connect
+      my_client.auth(@password)
+      self.client = my_client
+ 
+      # Post-connect
+      register_default_callbacks
+      status(@presence, @status_message)
+      @connect_mutex.unlock
+    end
+ 
+    def disconnect!(auto_reconnect = true)
+      if client.respond_to?(:is_connected?) && client.is_connected?
+        begin
+          client.close
+        rescue Errno::EPIPE, IOError => e
+          # probably should log this.
+          nil
+        end
+      end
+      client = nil
+      @disconnected = auto_reconnect
+    end
+ 
+    def register_default_callbacks
+      client.add_message_callback do |message|
+        queue(:received_messages) << message unless message.body.nil?
+      end
+ 
+      roster.add_subscription_callback do |roster_item, presence|
+        if presence.type == :subscribed
+          queue(:new_subscriptions) << [roster_item, presence]
+        end
+      end
+ 
+      roster.add_subscription_request_callback do |roster_item, presence|
+        if accept_subscriptions?
+          roster.accept_subscription(presence.from)
+        else
+          queue(:subscription_requests) << [roster_item, presence]
+        end
+      end
+ 
+      @presence_updates = {}
+      @presence_mutex = Mutex.new
+      roster.add_presence_callback do |roster_item, old_presence, new_presence|
+        simple_jid = roster_item.jid.strip.to_s
+        presence = case new_presence.type
+                   when nil then new_presence.show || :online
+                   when :unavailable then :unavailable
+                   else
+                     nil
+                   end
+ 
+        if presence && @presence_updates[simple_jid] != presence
+          queue(:presence_updates) << simple_jid
+          @presence_mutex.synchronize { @presence_updates[simple_jid] = [presence, new_presence.status] }
+        end
+      end
+    end
+ 
+    # This thread facilitates the delivery of messages to users who haven't yet
+    # accepted an invitation from us. When we attempt to deliver a message, if
+    # the user hasn't subscribed, we place the message in a queue for later
+    # delivery. Once a user has accepted our authorization request, we deliver
+    # any messages that have been queued up in the meantime.
+    def start_deferred_delivery_thread #:nodoc:
+      Thread.new {
+        loop {
+          messages = [queue(:pending_messages).pop].flatten
+          messages.each do |message|
+            if subscribed_to?(message[:to])
+              deliver(message[:to], message[:message], message[:type])
+            else
+              queue(:pending_messages) << message
+            end
+          end
+          sleep 10 * 60 # minutes
+        }
+      }
+    end
+ 
+    def queue(queue)
+      @queues ||= Hash.new { |h,k| h[k] = Queue.new }
+      @queues[queue]
+    end
+ 
+    def dequeue(queue, non_blocking = true, max_items = 100, &block)
+      queue_items = []
+      max_items.times do
+        queue_item = queue(queue).pop(non_blocking) rescue nil
+        break if queue_item.nil?
+        queue_items << queue_item
+        yield queue_item if block_given?
+      end
+      queue_items
+    end
+  end
+end
+ 
+true
+