stomp_message 0.1.2 → 0.1.8

data/Manifest.txt

@@ -9,6 +9,7 @@ lib/stomp_message.rb
 lib/stomp_message/version.rb
 lib/stomp_message/stomp_server.rb
 lib/stomp_message/stomp_statistics_server.rb
+lib/stomp_message/stomp_z_active_record_server.rb
 lib/stomp_message/stomp_send_topic.rb
 lib/stomp_message/stomp_participant.rb
 lib/stomp_message/message.rb

data/README.txt

@@ -1,5 +1,11 @@
 A basic package for sending and receiving stomp messages
 
+Active Record Server Class
+
+This extends the server class to access active record.  It is based on the rail app structure where the config file has database.yml and the app/models/*.rb contains all the files that are needed for active record.  Note that there is some strange code to pick up class name of last file loaded for checking the AR connection.  THis needs to be fixed.
+
+But in general with the AR Server class you can recieve messages and write them to active record databases.
+
 
 A server class will listen to topics  (StompMessage::StompServer)
 

data/bin/stomp_message_send.rb

@@ -1,3 +1,22 @@
+# == Synopsis
+#   Send a message to a stomp server and wait for result if requested
+# == Usage
+#  stomp_message_send.rb -T topic -M command -b body -h host -p port " 
+#   Debug: to turn on debug: stomp_message_send.rb -T '/topic/sms' -M stomp_DEBUG -b nil
+#   Statistics:  stomp_message_send.rb -T '/topic/sms' -M stomp_REPORT -b nil -A true
+#    Reconnect: stomp_message_send.rb -T '/topic/sms' -M stomp_RECONNECT -b nil -A true  ---- NOT USED OFTEN
+# Ping:  for ping test: stomp_message_send.rb -T '/topic/sms' -M stomp_PING -b nil -A true
+# Ping: for email ping test: stomp_message_send.rb -T '/topic/sms' -M stomp_PING -b nil -A true -D comma_separated_email_addresses"
+# Note -a flag for response  --- eg true or false
+# == Useful commands
+# stomp_message_send.rb -T '/topic/sms' -M stomp_PING -b nil -A true
+# stomp_message_send.rb -T '/topic/sms' -M stomp_DEBUG -b nil
+# stomp_message_send.rb -T '/topic/sms' -M stomp_REPORT -b nil -A true -D email@com
+# == Author
+#   Scott Sproule  --- Ficonab.com (scott.sproule@ficonab.com)
+# == Copyright
+#    Copyright (c) 2007 Ficonab Pte. Ltd.
+#     See license for license details
 require 'yaml'
 require 'rubygems'
 gem 'stomp'
@@ -5,64 +24,12 @@ require 'stomp'
 require 'optparse'
 gem 'stomp_message'
 require 'stomp_message'
-def usage
-    puts "Usage: stomp_message_send.rb -t topic -m command -b body -h host -p port " 
-    puts "to turn on debug: stomp_message_send.rb -t '/topic/sms' -m stomp_DEBUG -b nil"
-    puts "for statistics report: stomp_message_send.rb -t '/topic/sms' -m stomp_REPORT -b nil -a true"
-     puts "for statistics report: stomp_message_send.rb -t '/topic/sms' -m stomp_REPORT -b nil -a true"
-     puts "for ping test: stomp_message_send.rb -t '/topic/sms' -m stomp_PING -b nil -a true"
-      puts "for email ping test: stomp_message_send.rb -t '/topic/sms' -m stomp_PING -b nil -a true -d comma_separated_email_addresses"
-     puts "-a flag for response"
-    
-   exit
-end
-def parse_options(params)
-   opts = OptionParser.new
-   puts "argv are #{params}"
-   #params_split = params.split(' ')
-   #puts "paramsp is #{paramsp}"
-   topic_flag=command_flag=body_flag=true
-   temp_hash = {}
-   temp_hash[:ack]= 'false'   # no ack by default
-   temp_hash[:msisdn] = 'not_defined'
-   email_flag=false
-    opts.on("-h","--host VAL", String) {|val|  temp_hash[:host ] = val
-                                          #  puts "host is #{val}"
-                                            }
-    opts.on("-d","--email VAL", String) {|val|  temp_hash[:email ] = val
-                                    puts "email address is #{val}"
-                                #  puts "host is #{val}"
-                              }
-                                                                                                                            
-  opts.on("-p","--port VAL", String) {|val|  temp_hash[:port ] = val
-                                       #  puts "port is #{val}"
-                                                  }
-      opts.on("-a","--ack VAL", String) {|val|  temp_hash[:ack ] = val
-                                               puts "ack is #{val}"
-                                                          }                                                  
+require 'rdoc/usage'
+
+
 
-   opts.on("-u","--user VAL", String) {|val|  temp_hash[:user ] = val
-                                        #   puts "user is #{val}"
-                                           user_flag=false }
-   opts.on("-t","--topic VAL", String) {|val|  temp_hash[:topic ] = val
-                                       #   puts "topic is #{val}"
-                                          topic_flag=false }
-  opts.on("-m","--msg_command VAL", String) {|val|  temp_hash[:command ] = val
-                                          #    puts "command is #{val}"
-                                              command_flag=false }
-   opts.on("-b","--body VAL", String) {|val|  temp_hash[:body ] = val
-                                       #   puts "body is #{val}"
-                                          body_flag=false }
-   #opts.on("-d","--database VAL", String) {|val|  temp_hash[:db ] = val }
-   #opts.on("-p","--password VAL", String) {|val|  temp_hash[:password ] = val }
-   #opts.on("-u","--user VAL", String) {|val|  temp_hash[:user ] = val }
-   #puts " in test commander option parse #{port} #{url}"
-   opts.parse(params)
-   # puts " in HTTP #{hostname} port #{port} url: #{url}"
-   usage if topic_flag or body_flag or command_flag 
-   return temp_hash
- end
- arg_hash=parse_options(ARGV)
+ arg_hash=StompMessage::Options.parse_options(ARGV)
+ RDoc::usage if  arg_hash[:topic]==nil || arg_hash[:command]==nil || arg_hash[:help]==true
 require 'pp'
   options = arg_hash
    # set up variables using hash

data/lib/stomp_message/message.rb

@@ -1,10 +1,64 @@
 # basic format for stomp messages
 require 'rexml/document'
 #require 'xml_helper.rb'
-require 'rubygems'
-gem 'stomp_message'
-require 'stomp_message'
+#require 'rubygems'
+#gem 'stomp_message'
+#require 'stomp_message'
+require 'optparse'
+require 'rdoc/usage'
+
+
 module StompMessage
+  class Options
+    def self.parse_options(params)
+       opts = OptionParser.new
+       puts "argv are #{params}"
+       temp_hash = {}
+       temp_hash[:ack]= 'false'   # no ack by default
+       temp_hash[:msisdn] = 'not_defined'
+       email_flag=false
+        opts.on("-h","--host VAL", String) {|val|  temp_hash[:host ] = val
+                                              #  puts "host is #{val}"
+                                                }
+        opts.on("-D","--email VAL", String) {|val|  temp_hash[:email ] = val }
+
+      opts.on("-p","--port VAL", String) {|val|  temp_hash[:port ] = val      }
+          opts.on("-S","--subject VAL", String) {|val|  temp_hash[:subject ] = val }
+        opts.on("-s","--source VAL", String) {|val|  temp_hash[:source ] = val  }
+          opts.on("-A","--ack VAL", String) {|val|  temp_hash[:ack ] = val
+                                                   puts "ack is #{val}"
+                                                              }                                                  
+
+       opts.on("-u","--user VAL", String) {|val|  temp_hash[:user ] = val }
+                                            #   puts "user is #{val}"
+         opts.on("-T","--topic VAL", String) {|val|  temp_hash[:topic ] = val }                                      
+       opts.on("-t","--text VAL", String) {|val|  temp_hash[:text ] = val }
+                                        
+      opts.on("-M","--msg_command VAL", String) {|val|  temp_hash[:command ] = val }
+                                             
+       opts.on("-b","--body VAL", String) {|val|  temp_hash[:body ] = val }
+        opts.on("-k","--keyword VAL", String) {|val|  temp_hash[:keyword ] = val
+                                                puts "keyword is #{val}"
+                                                keyword_flag=false }
+        opts.on("-m","--msisdn VAL", String) {|val|  temp_hash[:msisdn ] = val }
+ opts.on("-U","--url VAL", String) {|val|  temp_hash[:url ] = val }
+
+       opts.on("-a","--action VAL", String) {|val|  temp_hash[:action ] = val }
+
+      opts.on("-B","--broadcast VAL", String) {|val|  temp_hash[:broadcast ] = val        }
+         opts.on("-x","--help", "get help") { |val|  temp_hash[:help]=true  }  
+                                                                                                                                                      
+       opts.on("-d","--debug", "turn on debug") { |val| temp_hash[:debug ] = true              }                          
+                                             
+                                       
+       opts.parse(params)
+                     # puts " in HTTP #{hostname} port #{port} url: #{url}"
+      
+      return temp_hash
+
+     end # parse options
+  end
+  # help build xml commands from messages
   module XmlHelper
 	  # create elements from instance variables... (instance variablesneed to be set)
 	  #array variables need to end in s (eg mssidns) and are handled recurvisely
@@ -37,7 +91,18 @@ module StompMessage
         element_xml= REXML::Element.new element_name
         element_xml.text=element_value
         element_xml
-    end
+    end     
+     def load_iv(iv_input,doc)
+        iv=iv_input.delete('@')
+       val = REXML::XPath.first(doc, "//#{iv}").text
+       puts "in load iv #{iv} and val: #{val}"
+        eval "self.#{iv}=#{val}"
+     end
+     def load_instance_variables(xml_string)
+              xml_doc=REXML::Document.new(xml_string)
+              self.instance_variables.each {|iv| load_iv(iv,xml_doc)        }
+             
+     end
     # add all elements to top variable
     def add_elements(top)
        elements = []
@@ -50,6 +115,8 @@ module StompMessage
     end
   
 	end
+	# basic stomp message class
+	# sent between clients and servers... subclasss and add instance variables.
 	class Message
 	  include StompMessage::XmlHelper
 	  attr_accessor :__stomp_msg_command, :__stomp_msg_body
@@ -93,5 +160,45 @@ module StompMessage
       end
       sms
     end
+     def self.load_xml_new(xml_string)
+        begin
+       # doc=REXML::Document.new(xml_string)
+        test= self.new('temp', 'temp')
+        test.load_instance_variables(xml_string)
+        #sms=StompMessage::Message.new(test.command, test.body)
+        rescue Exception => e
+          puts "Exception in load xml:#{xml_string}"
+          puts "message #{e.message}"
+        end
+       test
+      end
 	end
-end
+end
+# if a ruby gem file then you need to grab second in caller array
+def RDoc.usage_no_exit(*args)
+    main_program_file = caller[1].sub(/:\d+$/, '')
+    puts "main program is #{main_program_file} caller is #{caller.inspect}"
+    comment = File.open(main_program_file) do |file|
+      find_comment(file)
+    end
+
+    comment = comment.gsub(/^\s*#/, '')
+
+    markup = SM::SimpleMarkup.new
+    flow_convertor = SM::ToFlow.new
+    
+    flow = markup.convert(comment, flow_convertor)
+
+    format = "plain"
+
+    unless args.empty?
+      flow = extract_sections(flow, args)
+    end
+
+    options = RI::Options.instance
+    if args = ENV["RI"]
+      options.parse(args.split)
+    end
+    formatter = options.formatter.new(options, "")
+    formatter.display_flow(flow)
+  end

data/lib/stomp_message/stomp_participant.rb

@@ -1,6 +1,4 @@
 require 'rubygems'
-gem 'stomp_message'
-require 'stomp_message'
 require 'timeout'
 gem 'openwferu'
 require 'openwfe/participants/participants'

data/lib/stomp_message/stomp_send_topic.rb

@@ -49,19 +49,20 @@ class StompSendTopic
   #manage timeout etc...
   def self.open_connection(old_conn,login,pass,host,port)
       conn=old_conn
-      flag=false
+      count=0
+      flag= false
      begin
       conn.close if conn!=nil
-      
-      Timeout::timeout(5) {
+      count+=1
+      Timeout::timeout(15) {
            conn=nil
            conn = Stomp::Client.new(login, pass, host, port, false)
            flag=true
        }
    
        rescue Timeout::Error
-        puts "Timeout error: exception retrying flag is: #{flag}"
-        retry  if !flag
+        puts "Timeout error: exception retrying flag is: #{flag} retry number #{count}"
+        retry  if !flag and count < 4
      #   raise "timeout" 
     
        end         
@@ -87,7 +88,8 @@ class StompSendTopic
            response_header = {"Content-type" => "text/xml"}
            response_header.merge headers
            ht =Net::HTTP.start(self.host,self.port)
-           r=ht.post(self.url,msg.to_xml,response_header)
+           url = self.url + "/" + self.topic
+           r=ht.post(url,msg.to_xml,response_header)
            puts "url was: #{url}"
            puts "result: #{r.to_s}"
            r
@@ -96,6 +98,7 @@ class StompSendTopic
         #  m=StompMessage::Message.new('stomp_BILLING', msg)
            open_connection
            more_headers= {'persistent'=>'false' }
+           # i think bug in this merge..needs to return result
            more_headers.merge headers
           self.conn.send(self.topic, msg.to_xml, more_headers, &r_block)
         #  Thread.pass

data/lib/stomp_message/stomp_server.rb

@@ -21,6 +21,7 @@ module StompMessage
         self.msg_count = self.exception_count=0
         self.queue= Queue.new
         self.conn=nil
+        self.mythreads = []
         connect_connection
        #  self.conn = Stomp::Client.new self.login, self.password, self.host, self.port, false 
       # self.conn = Stomp::Connection.open self.login, self.password, self.host , self.port, false 
@@ -34,6 +35,14 @@ module StompMessage
                           #setup_auto_close   already done in INIT
                           exit(0)}
      end
+      def reconnect
+          puts "about to reconnect"
+          self.conn.close if self.conn!=nil
+          connect_connection
+         #  self.conn = Stomp::Client.new self.login, self.password, self.host, self.port, false 
+        # self.conn = Stomp::Connection.open self.login, self.password, self.host , self.port, false 
+         connect_topic
+      end
      def connect_connection
        self.conn = StompMessage::StompSendTopic.open_connection(self.conn, self.login, self.password, self.host, self.port) 
      end
@@ -91,6 +100,12 @@ module StompMessage
          reply_msg = StompMessage::Message.new('stomp_REPLY', body)
          send_reply(stomp_msg.headers,reply_msg) if stomp_msg.headers['reply-to']!=nil
       end
+      def stomp_RECONNECT(msg,stomp_msg)
+        reconnect
+        body="ALIVE Class: #{self.class.to_s} listing to: #{self.topic} on host #{@my_hostname} msg_count #{self.msg_count} exception_count #{self.exception_count} connection status #{self.conn.open?}"
+         reply_msg = StompMessage::Message.new('stomp_REPLY', body)
+         send_reply(stomp_msg.headers,reply_msg) if stomp_msg.headers['reply-to']!=nil
+      end
      def stomp_DEBUG(msg,stomp_msg)
         @debug=!@debug
         puts "debug flag is now #{@debug}"
@@ -103,18 +118,35 @@ module StompMessage
      def monitor_queue_status
        puts "starting up queue status"
        self.mythreads << Thread.new { while true
-                      sleep(30)
+                    begin
+                      sleep(1000)
                       puts "QUEUE size is: #{self.queue.size}"
                      # puts "-------conn var is on #{self.conn.inspect}"
                        if !self.conn.open? 
                          puts "restarting connection"
-                         self.conn=nil
-                         connect_connection
-                         connect_topic
+                         self.reconnect
                        end
+                     rescue Exception => e
+                       handle_exception(e)
+                     end
                     end  # while
                      }
      end
+     def handle_exception(e)
+       puts " Thread: #{Thread.current[:name]} :exception found #{e.backtrace}" 
+       puts "Thread: #{Thread.current[:name]} :exception messag #{e.message}"
+       result = "-----------EXCEPTION FOUND----------\n"
+       result << "ALIVE Class: #{self.class.to_s} listing to: #{self.topic} on host #{@my_hostname} msg_count #{self.msg_count} exception_count #{self.exception_count}\n"
+       result << "-----exception data--------\n"
+       result << " Thread: #{Thread.current[:name]} :exception found #{e.backtrace}\n" 
+       result << "Thread: #{Thread.current[:name]} :exception messag #{e.message}"
+         begin
+           StompMessage::StompSendTopic.send_email_stomp("scott.sproule@cure.com.ph",
+                   "STOMP EXCEPTION", "scott.sproule@cure.com.ph","Thread: #{Thread.current[:name]} :exception messag #{e.message}", result)
+         rescue Exception => e
+            puts "Can not send email, please check smtp host setting"
+         end
+     end
      def handle_message(msg)
         puts "STOMP message frame is : #{msg} "      if @debug
 	       m=StompMessage::Message.load_xml(msg.body)
@@ -123,11 +155,18 @@ module StompMessage
 	       send(m.command, m, msg)  # effectively case statement  (Should SCREEN HERE)
 	      # puts "sms text is: #{sms.text} dest is: #{sms.destination} result is: #{res}"
      end
+     #define thread specific variables here
+     # eg Thread.currect[:smsc]=blah blah
+     def setup_thread_specific_items(mythread_number)
+     
+       Thread.current[:name]= "Thread: #{mythread_number}"
+        puts " #{Thread.current[:name]} in setup thread specific data"
+     end
      def run
-          self.mythreads = []
           1.upto(self.thread_count)   { |c|  # create the threads here
-            puts "creating thread: #{c}"
+            #puts "creating thread: #{c}"
             self.mythreads << Thread.new(c)   { |ctmp| 
+               setup_thread_specific_items(ctmp)
                while true
                 
                   begin	
@@ -136,19 +175,7 @@ module StompMessage
                    
                    rescue Exception => e
                      self.exception_count+=1
-                   puts " Thread: #{ctmp} :exception found #{e.backtrace}" 
-                   puts "Thread: #{ctmp} :exception messag #{e.message}"
-                   result = "-----------EXCEPTION FOUND----------\n"
-                   result << "ALIVE Class: #{self.class.to_s} listing to: #{self.topic} on host #{@my_hostname} msg_count #{self.msg_count} exception_count #{self.exception_count}\n"
-                   result << "-----exception data--------\n"
-                   result << " Thread: #{ctmp} :exception found #{e.backtrace}\n" 
-                   result << "Thread: #{ctmp} :exception messag #{e.message}"
-                     begin
-                       StompMessage::StompSendTopic.send_email_stomp("scott.sproule@cure.com.ph",
-                               "STOMP EXCEPTION", "scott.sproule@cure.com.ph","Thread: #{ctmp} :exception messag #{e.message}", result)
-                     rescue Exception => e
-                        puts "Can not send email, please check smtp host setting"
-                     end
+                     handle_exception(e)
                   end
              #   Thread.pass
                end

data/lib/stomp_message/stomp_z_active_record_server.rb

@@ -0,0 +1,81 @@
+require 'yaml'
+require 'erb'
+
+#require 'stomp_server'
+module StompMessage
+  # statistics listening class.  Updates the statistics at every message/event
+  # had to name it Z due to order problems. not sure why.
+  class StompZActiveRecordServer   < StompMessage::StompServer
+   attr_accessor :model_list
+def initialize(options={})
+   super(options)
+   puts "root_path: #{options[:root_path]} rails_environment #{options[:env]}"
+   setup_active_record(options[:root_path], options[:env])
+   puts "#{self.class}: finished Active Record initializing"
+  # self.model_list = []
+ end
+#check the active record connection and reestablish... wierd stuff happening at cure.
+#note this is specific tomysql... need to fix later
+	def check_active_record_connection(my_class)
+	 begin
+	   conn=my_class.new.connection
+     puts " checking AR connection status: #{conn.active?}"
+     puts " AR down... reconnecting"  if !conn.active?
+   #  puts "after first check"
+     conn.reconnect! if !conn.active?
+   # puts "after reconnect"
+  rescue Mysql::Error
+     puts "reconnecting due to Mysql:Error"
+     conn.reconnect
+  rescue Exception => e
+    puts "ActiveRecord found exception that should not be here #{e.message}"
+  end
+end
+def monitor_ar_status(connection)
+  puts "starting up active record monitor status"
+  self.mythreads << Thread.new { while true
+                 begin
+                   sleep(1000)
+                   check_active_record_connection(connection)
+                 rescue Exception => e
+                          handle_exception(e)
+                 end
+               end  # while
+                }              
+end
+# the model path needs to include the models for active record...  can be inferred from
+# table names if needed but easiest and simplest is to give path to to the rails application
+def setup_active_record(root_path,env)
+  require 'rubygems'
+  gem 'activerecord'
+  require 'active_record'
+   path= root_path + "config/database.yml"
+   puts "path is #{path}"
+   data=File.open(path).readlines.join
+   result=ERB.new(data).result
+   parsed=YAML.load(result)
+   puts "env is #{env} values are: #{parsed[env]}"
+   ActiveRecord::Base.establish_connection(parsed[env])
+   ActiveRecord::Base.logger = Logger.new(STDOUT)
+   # grab all the models
+ #   model_path = root_path + "app/models/*.rb"
+   load_models(root_path)
+   #puts "after DIR"
+ end
+ #load the AR models... override if necessary
+ # model list is an array of models to load
+ def load_models(root_path)
+      model_path = root_path  + "app/models/"
+   # puts "model path is #{model_path}"
+   last_model=""
+   self.model_list.each { |model_file|
+       lib = model_path + model_file
+       last_model = require lib 
+      puts "loading required model: is #{lib}"
+      # last_model=lib  #last one needs to be active_record  (need to fix)
+       }
+       puts "last model is #{last_model}"
+      monitor_ar_status(eval("#{last_model[0]}"))
+ end
+end   # class
+end  #module

data/lib/stomp_message/version.rb

@@ -2,7 +2,7 @@ module StompMessage #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 2
+    TINY  = 8
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/test_stomp_message.rb

@@ -7,6 +7,8 @@ require File.dirname(__FILE__) + '/test_helper.rb'
  require 'rubygems'
  gem 'openwferu'
  require 'openwfe/workitem'
+ gem 'stomp_message'
+ require 'stomp_message'
 class TestStompMessage < Test::Unit::TestCase
 
   def setup
@@ -25,6 +27,16 @@ class TestStompMessage < Test::Unit::TestCase
         m2=StompMessage::Message.new("command",false)
         assert m1.to_xml==m2.to_xml, "xml generation wrong"
   end
+  def test_xml_helper_load_iv
+     m1=StompMessage::Message.new("command",true)
+      m2=StompMessage::Message.new("command",true)
+      assert m1.to_xml==m2.to_xml, "xml generation wrong"
+        m3=StompMessage::Message.load_xml_new(m2.to_xml)
+        puts "M3 is #{m3.to_xml}"
+        assert m3.class=StompMessage::Message, 'm3 is wrong'
+     assert m3.to_xml==m2.to_xml, "xml generation wrong"
+      assert m3.to_xml==m1.to_xml, "xml generation wrong"
+   end
   def test_object_nil
      begin
      m1=StompMessage::Message.new(nil)

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: stomp_message
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
-date: 2007-10-17 00:00:00 +08:00
+  version: 0.1.8
+date: 2007-11-05 00:00:00 +08:00
 summary: handling stomp messages and servers
 require_paths: 
 - lib
@@ -40,6 +40,7 @@ files:
 - lib/stomp_message/version.rb
 - lib/stomp_message/stomp_server.rb
 - lib/stomp_message/stomp_statistics_server.rb
+- lib/stomp_message/stomp_z_active_record_server.rb
 - lib/stomp_message/stomp_send_topic.rb
 - lib/stomp_message/stomp_participant.rb
 - lib/stomp_message/message.rb