stomp_message 0.0.3 → 0.1.2

data/History.txt

@@ -1,2 +1,8 @@
+0.0.8
+fix for not closing topics
+
+
 Initial release of stomp message..
-bulk casing for stomp messages
+xml casing for stomp messages
+
+arbirtrary sending of stomp messages to any topic

data/Manifest.txt

@@ -7,6 +7,10 @@ config/hoe.rb
 config/requirements.rb
 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_send_topic.rb
+lib/stomp_message/stomp_participant.rb
 lib/stomp_message/message.rb
 log/debug.log
 bin/stomp_message_send.rb

data/README.txt

@@ -1 +1,26 @@
-README
+A basic package for sending and receiving stomp messages
+
+
+A server class will listen to topics  (StompMessage::StompServer)
+
+
+A class to easily send (and receive messages from the server).  Since the messsage protocol is semi one way to receive a message you reply to a distinct topic and a call back is executed.
+
+The code below creates server class and sends message/gets response. 
+
+IMPORTANT apachemq or some other messaging platform must be running :)
+
+ args={:topic => '/topic/test'}
+ ss=StompMessage::StompStatisticsServer.new(args)
+ ss_thread = Thread.new {
+        ss.run }
+ 
+ msg=StompMessage::Message.new('stomp_REPORT', "body")
+
+ puts "creating send topic"
+ send_topic=StompMessage::StompSendTopic.new(args)
+  send_topic.send_topic_acknowledge(msg,{ :msisdn => "639999"})   { |m| 
+                puts "#{m.to_s}"
+                msg=StompMessage::Message.load_xml(m)
+                assert msg.command== 'stomp_REPLY',  "command wrong"
+                }

data/bin/stomp_message_send.rb

@@ -8,6 +8,12 @@ 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)
@@ -17,23 +23,35 @@ def parse_options(params)
    #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}"
+                                          #  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}"
+                                       #  puts "port is #{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}"
+                                        #   puts "user is #{val}"
                                            user_flag=false }
    opts.on("-t","--topic VAL", String) {|val|  temp_hash[:topic ] = val
-                                          puts "topic is #{val}"
+                                       #   puts "topic is #{val}"
                                           topic_flag=false }
   opts.on("-m","--msg_command VAL", String) {|val|  temp_hash[:command ] = val
-                                              puts "command is #{val}"
+                                          #    puts "command is #{val}"
                                               command_flag=false }
    opts.on("-b","--body VAL", String) {|val|  temp_hash[:body ] = val
-                                          puts "body is #{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 }
@@ -48,16 +66,50 @@ def parse_options(params)
 require 'pp'
   options = arg_hash
    # set up variables using hash
-    host =   options[:host]==nil ? 'localhost' : options[:host]
-    port =   options[:port]==nil ? '61613' : options[:port]
-    puts "host is: #{host} port is #{port}"
-    conn = Stomp::Connection.open '', '', host, port, false 
-  #  self.conn.subscribe @@TOPIC, { :ack =>"auto" }
-    puts "finished initializing"
-    m=StompMessage::Message.new(options[:command], options[:body])
-      #   puts "message body is #{msgbody}"
-    conn.send options[:topic], m.to_xml, {'persistent'=>'false'}
-  
+    msg_sender=StompMessage::StompSendTopic.new(options) 
+    msg_sender.setup_auto_close  
+    m=StompMessage::Message.new(options[:command],options[:body])
     puts "message is: #{m.to_xml}"
-    puts  'successfully sent messsage!!!'
+   # billing_sender.send_topic(m.body,  arg_hash[:msisdn]) 
+   # m=StompMessage::Message.new('stomp_BILLING', msg)
+     header = {}
+     header[:msisdn]=arg_hash[:msisdn]
+      msg_received_flag=false
+      msg_data=nil
+      case options[:ack].downcase
+      when   'true'
+          msg_sender.send_topic_acknowledge(m,header,50)  {   |msg| # puts 'in handle action block' 
+                                puts 'MESSAGE RECEIVED ----'
+                                msg_received_flag=true
+                                msg_data=msg
+                          puts "handle action block msg is #{msg.to_s}"  }
+                            begin
+                           Timeout::timeout(100) {
+                                 while true  
+                                    putc '.'
+                                    exit(0) if msg_received_flag
+                                    sleep(1)
+                                    end  }
+                              rescue SystemExit
+
+                              rescue Exception => e
+                               puts "exception #{e.message} class: #{e.class}"
+                               puts  "no receipt"
+                            #   raise "timeout" 
+                              #ensure
+                               # msg_sender.setup_auto_close
+                              end
+                          
+   
+      else
+          msg_sender.send_topic(m,header)
+       
+      end
+          
+     msg_sender.send_email_stomp("scott.sproule@cure.com.ph","STOMP MSG", options[:email],
+                    m.command, msg_data) if msg_received_flag and options[:email]!=nil
+   
+  
+    
+    puts  '-------------finished processing!!!'
   

data/config/hoe.rb

@@ -1,10 +1,10 @@
 require 'stomp_message/version'
 
-AUTHOR = 'FIXME full name'  # can also be an array of Authors
-EMAIL = "FIXME email"
-DESCRIPTION = "description of gem"
+AUTHOR = 'scott sproule'  # can also be an array of Authors
+EMAIL = "scott dot sproule at ficonab dot com"
+DESCRIPTION = "handling stomp messages and servers"
 GEM_NAME = 'stomp_message' # what ppl will type to install your gem
-RUBYFORGE_PROJECT = 'stomp_message' # The unix name for your project
+RUBYFORGE_PROJECT = 'stompmessage' # The unix name for your project
 HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
 DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
 

data/lib/stomp_message/message.rb

@@ -1,29 +1,97 @@
 # basic format for stomp messages
 require 'rexml/document'
+#require 'xml_helper.rb'
+require 'rubygems'
+gem 'stomp_message'
+require 'stomp_message'
 module StompMessage
+  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
+	  def xml_instance_variable(iv_input)
+	    iv=iv_input.delete('@')
+	    class_var=eval("self.#{iv}.class")
+	  #  puts "class is #{class_var} "
+	    iv_xml=[]
+	    case 
+      when class_var==Array
+        #puts "in array with #{iv}"
+        len=iv.size
+        check_for_s=iv[len-1]
+        # puts "iv #{iv}: len is #{len} last digit is #{check_for_s}"     
+        raise "not terminate in s or too short" if len <=1 or check_for_s!=115
+        the_array = eval("self.#{iv}")
+        iv_short = iv[0..len-2]
+        #puts "iv short is #{iv_short}"     
+        the_array.each {|e| 
+               iv_xml << create_element(iv_short,e) }
+        
+      else
+        val= eval "self.#{iv}"
+	      iv_xml[0]= create_element(iv.to_s,val)
+      end
+	    return iv_xml
+    end
+    def create_element(element_name, element_value)
+        # puts "in create element #{element_name}: #{element_value}"
+        element_xml= REXML::Element.new element_name
+        element_xml.text=element_value
+        element_xml
+    end
+    # add all elements to top variable
+    def add_elements(top)
+       elements = []
+        self.instance_variables.each {|iv| xml_instance_variable(iv).each {|x| elements << x} 
+                   
+      
+                  }
+        elements.each {|e| top.add_element e}
+        top
+    end
+  
+	end
 	class Message
-	  attr_accessor :command, :body
-	  def initialize(cmd, body=nil)
-	    self.command=cmd
-	    self.body=body
+	  include StompMessage::XmlHelper
+	  attr_accessor :__stomp_msg_command, :__stomp_msg_body
+	  def initialize(cmd, bdy=nil)
+	      raise 'command nil' if cmd==nil
+	      self.__stomp_msg_command =   cmd==nil ? '' : cmd.to_s
+	      self.__stomp_msg_body =   bdy==nil ? '' : bdy.to_s
+	     
 	  end
-	  def to_xml
-      msg_xml = REXML::Element.new "message"
-      command_xml = REXML::Element.new "command"
-      command_xml.text=self.command
-      body_xml =REXML::Element.new "body"
-      body_xml.text=self.body
-      msg_xml.add_element command_xml
-      msg_xml.add_element body_xml
-      msg_xml.to_s
+	  def body
+	    self.__stomp_msg_body
+    end
+     def command
+  	    self.__stomp_msg_command
+      end
+	     
+    def to_xml
+      doc=REXML::Document.new()
+      msg_xml = REXML::Element.new "stomp_msg_message"   
+      doc.add_element(msg_xml)   
+       msg3 = self.add_elements(REXML::Element.new("__instance_variables"))
+       doc.root.add_element(msg3)
+      output =""
+      doc.write output
+      output
      # doc= REXML::Document.new sms_xml.to_s
      # doc.to_s
     end
+	
     def self.load_xml(xml_string)
+      begin
       doc=REXML::Document.new(xml_string)
-      command=REXML::XPath.first(doc, "//command").text
-      body=REXML::XPath.first(doc, "//body").text
-      sms=StompMessage::Message.new(command,body)
+      command=REXML::XPath.first(doc, "//__stomp_msg_command").text
+    #  puts "load_xml command is #{command}"
+      body=REXML::XPath.first(doc, "//__stomp_msg_body").text
+    #     puts "load_xml body is #{body}"
+      sms=StompMessage::Message.new(command, body)
+      rescue Exception => e
+        puts "Exception in load xml:#{xml_string}"
+        puts "message #{e.message}"
+      end
+      sms
     end
 	end
 end

data/lib/stomp_message/stomp_participant.rb

@@ -0,0 +1,102 @@
+require 'rubygems'
+gem 'stomp_message'
+require 'stomp_message'
+require 'timeout'
+gem 'openwferu'
+require 'openwfe/participants/participants'
+
+
+module OpenWFE
+
+    #
+    # Participant to send/receive work items to stomp message servers applications
+    # send message and asynch wait for response
+    #
+    # Timeoout may need to be changed
+    # 
+    # On the return side, you can override the method handle_call_result 
+    # for better mappings between messages calls and the workitems.
+    #
+    class StompParticipant 
+        include LocalParticipant
+        attr_accessor  :timeout_val, :options, :msg_sender
+        def initialize(topic, host='localhost', port=61613, timeout=4, &block)
+
+            
+            self.options={}
+            self.options[:host]=host
+            self.options[:port]=port
+            self.options[:topic]=topic
+            self.timeout_val = timeout
+            self.msg_sender=StompMessage::StompSendTopic.new(self.options)   
+            self.msg_sender.setup_auto_close
+        end
+
+        #
+        # The method called by the engine when the flow reaches an instance
+        # of this Participant class.
+        #
+        def consume (workitem)
+           
+            m=prepare_call_params(workitem)
+            puts "message is: #{m.to_xml}"
+           # billing_sender.send_topic(m.body,  arg_hash[:msisdn]) 
+           # m=StompMessage::Message.new('stomp_BILLING', msg)
+             header={}
+            # header[:msisdn]=workitem.attributes[:msisdn]
+                begin
+                  Timeout::timeout(self.timeout_val) {
+                    self.msg_sender.send_topic_acknowledge(m,header)  { 
+                                   |msg|  workitem=handle_call_result(msg, workitem)
+                                     }
+                  }
+                  rescue Timeout::Error
+                   puts "STOMP participant:: consume(wi) exception"
+                   workitem.attributes["__result__"]=false
+                   workitem.attributes["stomp_TIMEOUT"]=true
+                #   raise "timeout" 
+                  ensure
+                     reply_to_engine(workitem)
+                  end
+                   
+
+           
+        end
+
+        #
+        # The base implementation :prepares the message
+        # param there is a workitem field with the same name.
+        #
+        # Feel free to override this method.
+        #
+        def prepare_call_params (workitem)
+            m=StompMessage::Message.new(workitem.attributes[:command].to_s,
+                                         workitem.attributes[:body].to_s)
+            m
+           # puts "message is: #{m.to_xml}"
+        end
+
+        #
+        # This implementation simply stuffs the result into the workitem
+        # as an attribute named "__result__".
+        #
+        # Feel free to override this method.
+        #
+        def handle_call_result (result, workitem)
+
+            puts 'in handle action block' 
+             puts 'MESSAGE RECEIVED ----'
+              m= StompMessage::Message.load_xml(result)
+              workitem.attributes["__result__"]=m.to_xml
+              workitem.attributes["command"]=m.command.to_s
+               workitem.attributes["body"]=m.body.to_s
+               puts "wi #{workitem.attributes.to_s}"
+              workitem
+              
+        end
+
+       
+
+    end
+
+end

data/lib/stomp_message/stomp_send_topic.rb

@@ -0,0 +1,173 @@
+require 'yaml'
+require 'rubygems'
+gem 'stomp'
+require 'stomp'
+require 'net/smtp'
+require 'net/http'
+require 'socket'
+
+# This 
+module StompMessage
+  # this class manages sending and receiving messages.  It uses passed code block to execute received code
+class StompSendTopic
+  attr_accessor :conn, :topic, :host, :port, :login, :password, :url
+  #need to define topic, host properly
+
+ def initialize(options={})
+   # set up variables using hash
+    @close_ok=false
+     init_vars(options)
+  #  puts "host is: #{host} port is #{port}"
+  # using url as flag wrong
+  #  self.conn = Stomp::Client.new(self.login, self.password, self.host, self.port, false) if self.url ==nil
+  
+    puts "#{self.class}: Initialized host is: #{self.host} port is #{self.port} topic is #{self.topic} login #{self.login} pass: #{self.password}"
+    # scott old   self.conn.subscribe( self.topic, { :ack =>"auto" })  { |m| 
+ #    self.conn.subscribe( self.topic, { :ack =>"client" })  { |m| 
+  #                                 # puts "#{self.class} msg: #{m.to_s}"
+  #                                   }
+   # setup_auto_close
+  end
+  def init_vars(options)
+     self.login =   options[:login]==nil ? '' : options[:login]
+      self.url =   options[:url]== nil ? nil : options[:url]
+        self.password =   options[:password]==nil ? '' : options[:password]
+          self.host =   options[:host]==nil ? 'localhost' : options[:host]
+      self.port =   options[:port]==nil ? '61613' : options[:port]
+      self.topic = options[:topic]==nil ? '/topic/undefined' : options[:topic]  
+      self.conn=nil
+      puts "self url is #{self.url}"
+  end
+  # only call this once
+  def setup_auto_close
+    
+     at_exit { puts "#{self.class}: auto close exit block"
+           close_topic
+           disconnect_stomp } if !@close_ok
+      @close_ok=true
+  end  
+  #manage timeout etc...
+  def self.open_connection(old_conn,login,pass,host,port)
+      conn=old_conn
+      flag=false
+     begin
+      conn.close if conn!=nil
+      
+      Timeout::timeout(5) {
+           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
+     #   raise "timeout" 
+    
+       end         
+        conn
+  end
+  def open_connection
+    self.conn = StompMessage::StompSendTopic.open_connection(@conn, self.login, self.password, self.host, self.port) if self.conn==nil
+  end
+  # close the topic
+   def close_topic
+        self.conn.unsubscribe(self.topic) if self.conn !=nil  
+      #  self.conn=nil 
+    end
+    #disconnect the connection
+    def disconnect_stomp
+          close_topic
+           puts "#{self.class}  closing connection"
+          self.conn.close() if self.conn !=nil   
+    end
+    # post stomp message to url
+    def post_stomp(msg,headers)
+           
+           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)
+           puts "url was: #{url}"
+           puts "result: #{r.to_s}"
+           r
+    end
+  def send_topic(msg, headers, &r_block)
+        #  m=StompMessage::Message.new('stomp_BILLING', msg)
+           open_connection
+           more_headers= {'persistent'=>'false' }
+           more_headers.merge headers
+          self.conn.send(self.topic, msg.to_xml, more_headers, &r_block)
+        #  Thread.pass
+   end #send_sms
+   # be careful with the receipt topic calculations... strange errors onactive mq
+ def send_topic_acknowledge(msg, headers, timeout=4)
+          #m=StompMessage::Message.new('stomp_BILLING', msg)
+          open_connection
+          s=rand*20   # scott - used to be 1000 but seem to create connections on activemq
+          # open new topic to listen to reply...
+           # was this but jms seems to blow up  receipt_topic="/topic/receipt/client#{s.to_i}"
+          receipt_topic="/topic/rcpt_client#{s.to_i}"
+          receipt_flag = false
+         # internal_conn =  Stomp::Connection.open '', '', self.host, self.port, false 
+          self.conn.subscribe( receipt_topic, { :ack =>"client" })   {|msg|
+                        begin
+                        Timeout::timeout(timeout) {
+                            self.conn.acknowledge(msg,msg.headers)
+                    	      msg2= msg.body
+                    	       yield msg2
+                         }
+                         rescue Exception => e
+                          puts "exception #{e.message}"
+                       #   raise "timeout" 
+                         ensure
+                           receipt_flag=true
+                           self.conn.unsubscribe receipt_topic 
+                         end   
+                           }
+                          
+          
+          more_headers= {'persistent'=>'false',  'reply-to' => "#{receipt_topic}" }
+          more_headers.merge headers
+          self.conn.send(self.topic, msg.to_xml, more_headers )  
+          Thread.new {   sleep(timeout)
+                          puts "calling unsubscribe on #{receipt_topic}" if !receipt_flag
+                          self.conn.unsubscribe receipt_topic if !receipt_flag
+                           }       
+      end #send_sms
+      def send_email_stomp(from, from_alias, to, subject, message)
+        StompMessage::StompSendTopic.send_email_stomp(from,from_alias,to,subject,message)
+      end
+      def self.send_email_stomp(from, from_alias, to, subject, message)
+          #to_csv_array=to.each.join(",")
+        	msg = <<EOF__RUBY_END_OF_MESSAGE
+From: #{from_alias} <#{from}>
+To: #{to}
+Subject: #{subject} #{Time.now}
+Comand ----------
+#{subject}
+RESPONSE -----------
+#{message}
+EOF__RUBY_END_OF_MESSAGE
+         recipients=to.split(',')
+         recipients.each {|r|  StompMessage::StompSendTopic.send_email(from,r,msg)}
+        
+    end
+    def  self.send_email(from,to,msg)
+          case   Socket.gethostname
+          when "svbalance.cure.com.ph"
+                smtp_host='mail2.cure.com.ph'
+          when "Scotts-Computer.local"
+            smtp_host='mail2.cure.com.ph'
+          else
+            smtp_host='localhost'
+          end
+          
+        	Net::SMTP.start(smtp_host) { |smtp|
+        		smtp.send_message(msg, from, to)
+      	   }
+    end
+        
+ end # stomp send topic
+
+end #module

data/lib/stomp_message/stomp_server.rb

@@ -0,0 +1,176 @@
+# basic format for stomp messages
+require 'rexml/document'
+require 'socket'
+# basic server class for listening to topics
+module StompMessage
+	class StompServer
+	  attr_accessor :conn,   :topic, :msg_count, :exception_count, :host, :port, :login, :password, :queue, :thread_count, :mythreads
+     #need to define topic, host properly
+      @debug=false
+    
+    def initialize(options={})
+        @my_hostname = Socket.gethostname
+          self.login =   options[:login]==nil ? '' : options[:login]
+          num =   options[:thread_count]==nil ? '2' : options[:thread_count]
+          self.thread_count=num.to_i
+            self.password =   options[:password]==nil ? '' : options[:password]
+        self.host =   options[:host]==nil ? 'localhost' : options[:host]
+        self.port =   options[:port]==nil ? '61613' : options[:port]
+        self.topic =   options[:topic]==nil ? '/topic/please_define' : options[:topic]
+        puts "#{self.class}: message broker host is: #{host} port is #{port} topic is: #{self.topic} threads #{self.thread_count} my host: #{@my_hostname}"
+        self.msg_count = self.exception_count=0
+        self.queue= Queue.new
+        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
+       @debug=false
+       puts "finished StompServer initializing"
+       setup_auto_close
+        trap("INT")   {  puts "#{Time.now}: #{self.class} in interrupt trap\n"
+                          #close_topic
+                          #disconnect_stomp
+                          #setup_auto_close   already done in INIT
+                          exit(0)}
+     end
+     def connect_connection
+       self.conn = StompMessage::StompSendTopic.open_connection(self.conn, self.login, self.password, self.host, self.port) 
+     end
+     def setup_auto_close
+       at_exit { puts "#{self.class}: in at exit block"
+                 close_topic
+                 disconnect_stomp 
+                # self.mythreads.each {|t| t.raise "auto exit" }
+               }
+     end
+       def disconnect_stomp
+             puts "#{self.class} #{@my_hostname} closing connection"
+             self.conn.close() if self.conn !=nil   
+       end
+     def send_reply(headers,msg)
+       reply_topic=headers['reply-to']
+     #  puts "headers:  #{headers['msisdn']} reply topic #{headers['reply-to']}"
+          # internal_conn =  Stomp::Connection.open '', '', self.host, self.port, false 
+          # scott old auto
+        # scott not needed   self.conn.subscribe(reply_topic, { :ack =>"client" }) {|m|   puts "yes boring should not be called: #{m.to_s}"
+                  #                                    }
+        #   m=StompMessage::Message.new('stomp_REPLY', msg_body)
+           response_header = {'persistent'=>'false'}
+           response_header.merge headers
+           self.conn.send(reply_topic, msg.to_xml, response_header ) 
+        #   self.conn.unsubscribe reply_topic  #testing shoul call this but not certain about it
+       #    internal_conn.disconnect
+     end
+     # name is message command
+     def connect_topic
+       # scott old ack auot
+       # see http://activemq.apache.org/stomp.html for activemq.dispathAsync settig
+         self.conn.subscribe( self.topic, { :ack =>"client" , 'activemq.dispatchAsync' => 'false'}) { |msg|  
+            
+            self.msg_count+=1
+    	       begin	
+    	        self.conn.acknowledge(msg,msg.headers)   
+    	        self.queue << msg  
+    	         
+             rescue Exception => e
+               self.exception_count+=1
+             puts " Thread: :exception found #{e.backtrace}" 
+             puts "Thread: :exception messag #{e.message}"
+            end
+          
+           }
+     end
+     # close the topic, override if necessary
+     def close_topic
+         puts "#{self.class} #{@my_hostname} unsubscribing #{self.topic}"
+          self.conn.unsubscribe self.topic  if self.conn!=nil
+      end
+      def stomp_PING(msg,stomp_msg)
+        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}"
+         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}"
+     end
+     def method_missing(name, *args)
+       puts "Method missing called: #{name}"
+       puts "Likely invalid message recieved"
+     end
+     # monitor queue
+     def monitor_queue_status
+       puts "starting up queue status"
+       self.mythreads << Thread.new { while true
+                      sleep(30)
+                      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
+                       end
+                    end  # while
+                     }
+     end
+     def handle_message(msg)
+        puts "STOMP message frame is : #{msg} "      if @debug
+	       m=StompMessage::Message.load_xml(msg.body)
+	      # puts "Message is: #{m.to_xml}"  if @debug
+	       puts "Message type is #{m.command}" if @debug
+	       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
+     def run
+          self.mythreads = []
+          1.upto(self.thread_count)   { |c|  # create the threads here
+            puts "creating thread: #{c}"
+            self.mythreads << Thread.new(c)   { |ctmp| 
+               while true
+                
+                  begin	
+          	        msg=self.queue.pop
+                    handle_message(msg)   
+                   
+                   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
+                  end
+             #   Thread.pass
+               end
+              }
+            }
+           monitor_queue_status
+           self.mythreads.each { |t| t.join }
+          
+          
+   	     #  msg = self.conn.receive
+   	#       puts "after receive"
+   	     #  self.msg_count+=1
+   	     #  begin	
+   	    #     handle_message(msg)      
+         #   rescue Exception => e
+        #      self.exception_count+=1
+         #   puts "exception found #{e.backtrace}" 
+        #    puts "exception messag #{e.message}"
+         #  end
+         # end  # while
+
+       # t.join  # wait for t to die..
+     end #run
+  end
+end

data/lib/stomp_message/stomp_statistics_server.rb

@@ -0,0 +1,83 @@
+# basic format for stomp messages
+require 'rexml/document'
+# basic statistics class for listening to topics
+module StompMessage
+  # statistics listening class.  Updates the statistics at every message/event
+	class StompStatisticsServer < StompMessage::StompServer
+	  attr_accessor  :tags, :statistics
+	  def setup_var
+	    self.tags = %w(hour day week  month)
+	    self.statistics = Hash.new
+	    self.tags.each { |tagv| statistics[tagv] = Hash.new(0)    }
+	    @old_exception_count=0
+    end
+	  def initialize(options={})
+      super(options)
+      setup_var
+    end
+    # update the statistics by tag value  (eg hour)
+    def increment_stats(tag, element)
+       self.statistics[tag][element]+=1
+    end
+    # reset element to zero (eg reset hour to zero)
+    def reset_element(tag, element)
+       self.statistics[tag][element]=0
+    end
+    # increment all the tags with a new element value  .  Hash is zero if not found
+    def tag_increment(element)
+      self.tags.each {|tagv|  puts "incrementing #{tagv}  element: #{element}" if @debug
+                            increment_stats(tagv,element)}
+      
+    end
+    
+     def handle_message(msg)
+        puts "in handle message stomp stat server" if @debug
+         m=StompMessage::Message.load_xml(msg.body)
+        tag_increment(m.command)
+        super(msg)
+        tag_increment('msg_count')
+        tag_increment('exception_count') if @old_exception_count!= self.exception_count
+         @old_exception_count= self.exception_count
+         
+	  end
+	   def stomp_PING(msg, stomp_msg)
+          puts "stomp PING: #{msg.body}" if @debug
+          #do not reply as statistic servers do no respond to pings.  they respond to stomp_REPORT    
+    end
+    #def create_statistics(msg)  # k[it]=0 if !k.key?(it)
+     # self.tags.each { |tagv| self.statistics[tagv].each {|k| 
+    #                             internal_tags = %w(msg_count, exception_count ) 
+    #                             internal_tags.each { |it| 
+    #                                                       data= eval("self.#{it}")
+    #                                                        k[it]= data-k[it]
+    #                                                       puts "it is #{it}: data is #{data} k[it] is #{k[it]}"
+     #                                                                               }
+    #                                                    }
+    #                          }
+    # 
+    #end
+    def stomp_REPORT(msg, stomp_msg)
+      
+       result= " Stomp Report #{Time.now}\n"
+       result << " Messages processed: #{self.msg_count} \n"
+       flag =   self.exception_count!=nil ? '' : 'IMPORTANT'
+       result << "#{flag} Exceptions processed: #{self.exception_count}\n "
+       self.tags.each { |tagv|  # run through each tag  (hour, day etc)  
+           result << "#{tagv} Latests Statistics\n"
+           self.statistics[tagv].each {|k,v| result <<  " ----- #{k}: #{v}\n"}
+          }
+       puts result if @debug
+       reply_msg = StompMessage::Message.new('stomp_REPLY', "#{result}")
+       send_reply(stomp_msg.headers,reply_msg) if stomp_msg.headers['reply-to']!=nil
+       result
+    end
+    def stomp_RESET(msg, stomp_msg)
+        puts "stomp reset: #{msg.body}" if @debug
+        reset_tag = msg.body.to_s if self.tags.include?(msg.body.to_s)
+        puts " --- RESET TAG: #{reset_tag}"
+        self.statistics[reset_tag].each { |k,v| self.statistics[reset_tag][k]=0
+                                       puts "RESET: tag #{k} value is zero"
+                                        } if self.tags.include?(msg.body.to_s)
+    end
+  end
+end

data/lib/stomp_message/version.rb

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

data/test/test_stomp_message.rb

@@ -1,5 +1,12 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
-
+ class OpenWFE::StompParticipant
+   def reply_to_engine(workitem)
+     puts "hello from test reply to engine"
+   end
+ end
+ require 'rubygems'
+ gem 'openwferu'
+ require 'openwfe/workitem'
 class TestStompMessage < Test::Unit::TestCase
 
   def setup
@@ -10,6 +17,66 @@ class TestStompMessage < Test::Unit::TestCase
      m2=StompMessage::Message.new("command")
      assert m1.to_xml==m2.to_xml, "xml generation wrong"
   end
+  def test_object_create2
+    m1=StompMessage::Message.new("command",true)
+     m2=StompMessage::Message.new("command",true)
+     assert m1.to_xml==m2.to_xml, "xml generation wrong"
+       m1=StompMessage::Message.new("command",false)
+        m2=StompMessage::Message.new("command",false)
+        assert m1.to_xml==m2.to_xml, "xml generation wrong"
+  end
+  def test_object_nil
+     begin
+     m1=StompMessage::Message.new(nil)
+   rescue Exception => e
+      assert true, 'raised exception'
+     end
+   end
+    class M3 < StompMessage::Message
+      attr_accessor :msisdns, :bad , :s
+      def initialize(cmd)
+        super(cmd)
+        self.msisdns=[]
+         self.s= []
+        self.bad = []
+        self.msisdns << "test"
+         self.msisdns << "test2"
+        self.bad << "test"
+         self.s << "test"
+      end
+    end  # class M3
+      class M4 < StompMessage::Message
+        attr_accessor :msisdns
+        def initialize(cmd)
+          super(cmd, "body")
+          self.msisdns=[]
+          self.msisdns << "test"
+           self.msisdns << "test2"
+        end
+      end  # class M3
+   def test_xml1_helper
+       puts "XML Helper test"
+       m2=M3.new("command")
+       begin
+         res=m2.to_xml
+        # puts "m2 xml is #{res}"
+       rescue Exception => e
+         puts "found exception #{e.message}"
+         assert e.message=="not terminate in s or too short", "bad message"
+       end
+     end
+      def test_xml2_helper
+          puts "XML2 Helper test"
+          m2=M4.new("command")
+          begin
+            res=m2.to_xml
+            puts "m2 xml is #{res}"
+          rescue Exception => e
+            puts "found exception #{e.message}"
+            assert false, "bad message #{e.message}"
+          end
+          
+        end
   def test_object_duplication
      m1=StompMessage::Message.new("command")
      m2=StompMessage::Message.new("command")
@@ -17,8 +84,131 @@ class TestStompMessage < Test::Unit::TestCase
      assert m1.to_xml==m2.to_xml, "xml generation wrong"
      assert m3.to_xml==m2.to_xml, "xml generation wrong"
       m2=StompMessage::Message.new("command","body")
-       assert m3.to_xml!=m2.to_xml, "xml generation wrong"
+       assert m3.to_xml!=m2.to_xml, "xml generation wrong"  
       m4=StompMessage::Message.load_xml(m2.to_xml)
-        assert m4.body==m2.body, "xml generation wrong"
+      puts "CHECK THIS m2 is: #{m2.to_xml} m4 is #{m4.to_xml}"
+      assert m4.body==m2.body, "xml generation wrong"
+  end
+  def test_statistics_server
+    #note activemq or stomp message bus needs to be running
+     args={:topic => '/topic/test'}
+     ss=StompMessage::StompStatisticsServer.new(args)
+     ss_thread = Thread.new {
+            ss.run }
+     assert ss.topic=='/topic/test', "topic not set properly"
+     sleep(1)
+     msg=StompMessage::Message.new('stomp_REPORT', "body")
+     assert msg.command=='stomp_REPORT', "message command not correct"
+     puts "creating send topic"
+     send_topic=StompMessage::StompSendTopic.new(args)
+     puts "send topic NO ack"
+     send_topic.send_topic(msg,{ :msisdn => "639999"})
+      puts "send topic WITH ack"
+      msg_reply=''
+    send_topic.send_topic_acknowledge(msg,{ :msisdn => "639999"})   { |m|  assert true
+                    puts "#{m.to_s}"
+                    msg_reply=StompMessage::Message.load_xml(m)
+                
+                  }
+        sleep(3)
+          assert msg_reply.command== 'stomp_REPLY',  "command wrong"    
+      ss_thread.kill          
+  end
+  def test_base_server
+    #note activemq or stomp message bus needs to be running
+     args={:topic => '/topic/test'}
+     ss=StompMessage::StompServer.new(args)
+     ss_thread = Thread.new {
+            ss.run }
+     sleep(3)
+     assert ss.topic=='/topic/test', "topic not set properly"
+     msg=StompMessage::Message.new('stomp_PING', "body")
+     assert msg.command=='stomp_PING', "message command not correct"
+     puts "creating ping messager topic"
+     send_topic=StompMessage::StompSendTopic.new(args) 
+      puts "send ping WITH ack"
+      msg_reply=''
+       send_topic.send_topic_acknowledge(msg,{ :msisdn => "639999"})   { |m|  assert true
+                    puts "#{m.to_s}"
+                    msg_reply=StompMessage::Message.load_xml(m)
+                    assert msg_reply.body.split[0]== 'ALIVE',  "ping not ok #{msg_reply.body}" 
+                  }
+        sleep(3)
+          assert msg_reply.command== 'stomp_REPLY',  "command wrong" 
+          send_topic.close_topic   
+      ss_thread.kill          
+  end
+  def test_statistics_reset
+    #note activemq or stomp message bus needs to be running
+     args={:topic => '/topic/test'}
+     ss=StompMessage::StompStatisticsServer.new(args)
+     ss_thread = Thread.new {
+            ss.run }
+     assert ss.topic=='/topic/test', "topic not set properly"
+     msg=StompMessage::Message.new('stomp_REPORT', "body")
+     assert msg.command=='stomp_REPORT', "message command not correct"
+     puts "creating send topic"
+     send_topic=StompMessage::StompSendTopic.new(args)
+     puts "send topic NO ack"
+     send_topic.send_topic(msg,{ :msisdn => "639999"})
+      puts "send topic WITH ack"
+      msg_reply = ""
+      send_topic.setup_auto_close
+    send_topic.send_topic_acknowledge(msg,{ :msisdn => "639999"})   { |m|  assert true
+                    puts "#{m.to_s}"
+                    msg_reply=StompMessage::Message.load_xml(m)
+
+                    }
+                    sleep(3)
+     assert msg_reply.command== 'stomp_REPLY',  "command wrong"
+   send_topic.send_topic_acknowledge(msg,{ :msisdn => "639999"})   { |m|  assert true
+                         puts "#{m.to_s}"
+                          msg_reply=StompMessage::Message.load_xml(m)
+
+                                    }
+                  sleep(3)
+              assert msg_reply.command== 'stomp_REPLY',  "command wrong"
+              response = msg_reply.body.to_s
+              assert response.include?("stomp_REPORT: 3"),  "Stomp_Report 3 not included"
+              assert !response.to_s.include?("stomp_REPORT: 0"),  "Stomp_Report: 0  included"
+                          # reset hour statistics
+                 msg2=StompMessage::Message.new('stomp_RESET', "hour")
+                 assert msg2.command=='stomp_RESET', "message command not correct"
+                 puts "creating send msg2 topic"
+                       send_topic.send_topic(msg2,{ :msisdn => "639999"})                             
+            send_topic.send_topic_acknowledge(msg,{ :msisdn => "639999"})   { |m|  assert true
+                                                           puts "#{m.to_s}"
+                                    msg_reply=StompMessage::Message.load_xml(m)
+                                 
+                                                                      }   
+                                sleep(3)
+                       assert msg_reply.command== 'stomp_REPLY',  "command wrong"
+                                    response = msg_reply.body.to_s
+                assert response.include?("stomp_REPORT: 1"),  "Stomp_Report 0 not included"
+              assert response.include?("stomp_RESET: 1"),  "Stomp_RESET 1 not included"
+                assert !response.to_s.include?("stomp_REPORT: 2"),  "Stomp_Report: 2  included" 
+          ss_thread.kill                           
+  end
+  
+  def test_stomp_parti
+    #note activemq or stomp message bus needs to be running
+    args={}
+     args[:topic] = '/topic/test'
+     ss=StompMessage::StompServer.new(args)
+     ss_thread = Thread.new {
+            ss.run }
+     assert ss.topic=='/topic/test', "topic not set properly"
+     participant=OpenWFE::StompParticipant.new('/topic/test') { puts "hello from block"}
+     wi = OpenWFE::WorkItem.new()
+     wi[:command] = 'stomp_PING'
+      wi[:body] = 'body'
+       wi[:msisdn] = '63999999'
+         m2=StompMessage::Message.new(wi[:command].to_s,wi[:body].to_s)
+         puts "m2: #{m2.to_xml}"
+         assert m2.to_xml==StompMessage::Message.load_xml(m2.to_xml).to_xml, "problems in wi xml"
+     wi['sms'] = "hello there"
+     participant.consume(wi)
+     ss_thread.kill
+     
   end
 end

metadata

@@ -3,15 +3,15 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: stomp_message
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
-date: 2007-09-19 00:00:00 +08:00
-summary: description of gem
+  version: 0.1.2
+date: 2007-10-17 00:00:00 +08:00
+summary: handling stomp messages and servers
 require_paths: 
 - lib
-email: FIXME email
-homepage: http://stomp_message.rubyforge.org
-rubyforge_project: stomp_message
-description: description of gem
+email: scott dot sproule at ficonab dot com
+homepage: http://stompmessage.rubyforge.org
+rubyforge_project: stompmessage
+description: handling stomp messages and servers
 autorequire: 
 default_executable: 
 bindir: bin
@@ -27,7 +27,7 @@ signing_key:
 cert_chain: 
 post_install_message: 
 authors: 
-- FIXME full name
+- scott sproule
 files: 
 - History.txt
 - License.txt
@@ -38,6 +38,10 @@ files:
 - config/requirements.rb
 - 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_send_topic.rb
+- lib/stomp_message/stomp_participant.rb
 - lib/stomp_message/message.rb
 - log/debug.log
 - bin/stomp_message_send.rb