stomp_message 0.1.8 → 0.6.3

data/lib/stomp_message/message.rb

@@ -12,7 +12,7 @@ module StompMessage
   class Options
     def self.parse_options(params)
        opts = OptionParser.new
-       puts "argv are #{params}"
+    #   puts "argv are #{params}"
        temp_hash = {}
        temp_hash[:ack]= 'false'   # no ack by default
        temp_hash[:msisdn] = 'not_defined'
@@ -20,13 +20,22 @@ module StompMessage
         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 }
+      # takes ruby hash code and converts to yaml
+       opts.on("-H","--body_hash VAL", String) {|val|   temp=eval(val)
+                                                 temp_hash[:body ] = temp.to_yaml
+                                                                                        #  puts "host is #{val}"
+                                                                                          }                                          
+        opts.on("-D","--email VAL", String) {|val|  temp_hash[:email ] = val
+                                                     temp_hash[:destination]=val }
 
       opts.on("-p","--port VAL", String) {|val|  temp_hash[:port ] = val      }
+      opts.on("-c","--count VAL", String) {|val|  temp_hash[:count ] = val      }
+      opts.on("-r","--repeat VAL", String) {|val|  temp_hash[:repeat ] = 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}"
+                                                    temp_hash[:action]=val
+                                              #     puts "ack is #{val}"
                                                               }                                                  
 
        opts.on("-u","--user VAL", String) {|val|  temp_hash[:user ] = val }
@@ -41,12 +50,13 @@ module StompMessage
                                                 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("-U","--url VAL", String) {|val|  temp_hash[:url ] = val }
+  #oops couldnot thinkof another acronym for a
+       opts.on("-a","--account VAL", String) {|val|      temp_hash[:account ] = 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("-v","--value VAL", String) {|val|  temp_hash[:value ] = val }
                                                                                                                                                       
        opts.on("-d","--debug", "turn on debug") { |val| temp_hash[:debug ] = true              }                          
                                              
@@ -153,12 +163,12 @@ module StompMessage
     #  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)
+      tt_sms=StompMessage::Message.new(command, body)
       rescue Exception => e
         puts "Exception in load xml:#{xml_string}"
         puts "message #{e.message}"
       end
-      sms
+      tt_sms
     end
      def self.load_xml_new(xml_string)
         begin
@@ -176,8 +186,10 @@ module StompMessage
 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}"
+    # main_program_file = caller[1].sub(/:\d+$/, '')
+      main_program_file = caller[1].split(':')[0]
+    #puts "main program is #{main_program_file}"
+   # puts " caller is #{caller.inspect}"
     comment = File.open(main_program_file) do |file|
       find_comment(file)
     end
@@ -201,4 +213,4 @@ def RDoc.usage_no_exit(*args)
     end
     formatter = options.formatter.new(options, "")
     formatter.display_flow(flow)
-  end
+  end

data/lib/stomp_message/stomp_send_topic.rb

@@ -5,6 +5,10 @@ require 'stomp'
 require 'net/smtp'
 require 'net/http'
 require 'socket'
+if RUBY_PLATFORM =~ /java/
+require 'java'
+end
+
 
 # This 
 module StompMessage
@@ -12,22 +16,56 @@ module StompMessage
 class StompSendTopic
   attr_accessor :conn, :topic, :host, :port, :login, :password, :url
   #need to define topic, host properly
-
+  include StompMessage::JmsTools if RUBY_PLATFORM =~ /java/
  def initialize(options={})
    # set up variables using hash
     @close_ok=false
      init_vars(options)
+         if RUBY_PLATFORM =~ /java/
+             @javaflag= @java_flag=true
+          else
+            @javaflag= @java_flag=false
+          end
+      set_up_jms(options[:topic]) if @javaflag
   #  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}"
+    @debug=false
+    
+    puts "#{self.class}: Initialized host is: #{self.host} port is #{self.port} topic is #{self.topic} login #{self.login} pass: #{self.password}" if @debug
     # 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 jms_msg_result(msg)
+      #tproducer, tsession= self.jms_create_producer_session(@jms_dest,@jms_conn)
+       @my_conn=@jms_conn
+     #  tconsumer=jms_create_consumer(tsession,@jms_dest)
+   #   tconsumer, consumer_session = self.jms_create_consumer_session(@jms_dest,@jms_conn) 
+      #  result =jms_send_ack(tsession,tproducer,msg.to_xml)
+       # tsession.commit
+       # tconsumer.close
+      #  self.jms_close_producer_session(tproducer, tsession)
+           result =jms_message_handling(@jms_dest, @jms_conn)  {     jms_send_ack(@session,@producer,msg.to_xml,50) }
+       # self.close_con
+       msg=nil
+     result
+  end
+  def set_up_jms(topic)
+      jms_start("TopicConnectionFactory")   #THIS NEEDS TO BE A VAR
+      @jms_dest, @jms_conn = jms_create_destination_connection(topic)
+      # @session = jms_create_session( topic)
+     # @producer = jms_create_producer(@session,@dest)
+     #  @consumer = jms_create_consumer(@session,@dest)
+     # at_exit { puts "#{self.class}: auto close exit block"  #if @debug
+     #         send_topic_jms_shutdown }
+   end
+   def send_topic_jms_shutdown
+     jms_shutdown(@jms_dest, @jms_conn, @session, @producer, @consumer)
+   end
+   
   def init_vars(options)
      self.login =   options[:login]==nil ? '' : options[:login]
       self.url =   options[:url]== nil ? nil : options[:url]
@@ -36,14 +74,19 @@ class StompSendTopic
       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}"
+      puts "self url is #{self.url}" if @debug
+  end
+  def java?
+    @javaflag
   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
+     at_exit { puts "#{self.class}: auto close exit block"  if @debug
+           if !self.java?
+               close_topic
+              disconnect_stomp 
+            end } if !@close_ok
       @close_ok=true
   end  
   #manage timeout etc...
@@ -65,7 +108,8 @@ class StompSendTopic
         retry  if !flag and count < 4
      #   raise "timeout" 
     
-       end         
+       end 
+        raise 'connection not established'  if conn==nil        
         conn
   end
   def open_connection
@@ -73,14 +117,19 @@ class StompSendTopic
   end
   # close the topic
    def close_topic
-        self.conn.unsubscribe(self.topic) if self.conn !=nil  
+        self.conn.unsubscribe(self.topic) if self.conn !=nil && !self.java?
       #  self.conn=nil 
     end
     #disconnect the connection
     def disconnect_stomp
-          close_topic
-           puts "#{self.class}  closing connection"
-          self.conn.close() if self.conn !=nil   
+        if !self.java?
+           close_topic
+           puts "#{self.class}  closing connection #{@jms_conn.inspect}" if @debug
+          @jms_conn.close() if @jms_conn !=nil   
+        else
+          @jms_conn.close() if @jms_conn !=nil   
+          put "INVESTIGATE THIS diconnect stomp if java in stomp_send_topic.rb"
+        end
     end
     # post stomp message to url
     def post_stomp(msg,headers)
@@ -88,26 +137,96 @@ class StompSendTopic
            response_header = {"Content-type" => "text/xml"}
            response_header.merge headers
            ht =Net::HTTP.start(self.host,self.port)
-           url = self.url + "/" + self.topic
+           url = self.url # + "/" + self.topic
+            puts "posting to: #{self.host}: #{self.port} #{url} message: #{msg.to_xml}"
            r=ht.post(url,msg.to_xml,response_header)
-           puts "url was: #{url}"
+          
            puts "result: #{r.to_s}"
            r
     end
+    def jms_message_one_way(tjms_dest,tjms_conn)
+        # @my_conn=@jms_conn
+           @producer, @session  = self.jms_create_producer_session(tjms_dest,tjms_conn)
+      #   tconsumer=jms_create_consumer(@session,@jms_dest)
+         #@producer, @session  = self.jms_create_producer_session(tjms_dest,tjms_conn)
+         ttresult = yield
+       #  tconsumer.close
+         jms_close_producer_session(  @producer, @session )
+         ttresult
+      end
+     def jms_message_handling(tjms_dest,tjms_conn)
+          @my_conn=@jms_conn
+            @producer, @session  = self.jms_create_producer_session(tjms_dest,tjms_conn)
+          tconsumer=jms_create_consumer(@session,@jms_dest)
+          #@producer, @session  = self.jms_create_producer_session(tjms_dest,tjms_conn)
+          result = yield
+          tconsumer.close
+          jms_close_producer_session(  @producer, @session )
+          result
+       end
   def send_topic(msg, headers, &r_block)
         #  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)
+           if self.java?
+             jms_message_handling(@jms_dest, @jms_conn) {  self.jms_send_message(@session,@producer,headers,msg.to_xml)  }
+           else
+             self.conn.send(self.topic, msg.to_xml, more_headers, &r_block)
+           end
         #  Thread.pass
    end #send_sms
+   def interim_package(msg,headers,timeout)
+     result=false
+     msg_received_flag =false
+     begin
+     Timeout::timeout(timeout+1) {
+       self.send_topic_acknowledge(msg,headers,timeout-1)  {   |msg| # puts 'in handle action block' 
+                           #  puts "MESSAGE RECEIVED ---- #{msg.to_s} "
+                             msg_received_flag=true
+                             m=StompMessage::Message.load_xml(msg)
+                             result=m.body
+                          #    result= yield m.body if block_given? FIGURE OUT HOW TO MAKE THIS WORK
+                           #  puts "result is #{result}"
+                             result
+                              }
+                   
+                              while true  
+                             #    putc '.'
+                                 break if msg_received_flag
+                                 sleep(1)
+                                 end  }
+                           rescue SystemExit
+                           rescue Timeout::Error
+                           rescue Exception => e
+                            puts "exception #{e.message} class: #{e.class}"
+                            puts  "no receipt"
+                           end
+                result
+   end
+   def create_consumer
+      @consumer, @consumer_session = jms_create_consumer_session(@jms_dest,@jms_conn) 
+   end
+   def send_topic_ack(msg,headers,timeout=75, &r_block)
+      
+      result=false
+      #puts "Send topic ack"
+      
+      if self.java?
+        #create_consumer if @consumer==nil
+        result =jms_message_handling(@jms_dest, @jms_conn)  {     jms_send_ack(@session,@producer,msg.to_xml,timeout) }
+      else
+          result =interim_package(msg,headers,timeout)
+       end
+            result
+         # puts "result is now #{result}"
+   end
    # be careful with the receipt topic calculations... strange errors onactive mq
- def send_topic_acknowledge(msg, headers, timeout=4)
+ def send_topic_acknowledge(msg, headers, timeout=60)
           #m=StompMessage::Message.new('stomp_BILLING', msg)
           open_connection
-          s=rand*20   # scott - used to be 1000 but seem to create connections on activemq
+          s=rand*30   # 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}"
@@ -133,7 +252,7 @@ class StompSendTopic
           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)
+          Thread.new {   sleep(timeout+1)
                           puts "calling unsubscribe on #{receipt_topic}" if !receipt_flag
                           self.conn.unsubscribe receipt_topic if !receipt_flag
                            }       

data/lib/stomp_message/stomp_server.rb

@@ -1,39 +1,123 @@
 # basic format for stomp messages
 require 'rexml/document'
 require 'socket'
+#require 'monitor'
+require 'thread'
 # basic server class for listening to topics
 module StompMessage
+  class JmsMessage
+      attr_accessor :headers, :body, :command
+     def initialize(body, headers)
+       self.body=body
+       self.headers=headers
+    end
+    end
+    class MySpecialListener
+             include javax.jms.MessageListener if RUBY_PLATFORM =~ /java/
+           def initialize(obj)
+             @call_obj=obj
+           end
+           def set_self(obj)
+             @call_obj=obj
+           end
+           def onMessage(msg)
+             #puts "----> consumer in on msg #{msg.inspect}"
+             puts "message received #{@my_topic}"
+             h= {}
+             msg.get_property_names.each { |n| h[n]=msg.getStringProperty(n) }
+            # puts "text: #{msg.getText()} props: #{h.inspect}"
+            # exit!
+             @call_obj.onMessage(msg.getText(),h)
+             msg=nil
+             h=nil
+            # puts "<--- consumer on message"
+           end
+     end
+  
 	class StompServer
-	  attr_accessor :conn,   :topic, :msg_count, :exception_count, :host, :port, :login, :password, :queue, :thread_count, :mythreads
+	  include StompMessage::JmsTools
+	#  include MonitorMixin
+	  attr_accessor :conn,   :topic, :msg_count, :exception_count, :host, :port, :login, :password, :queue, :thread_count, :mythreads, :guard, :jms_source, :variables, :ss_start_time
      #need to define topic, host properly
       @debug=false
     
     def initialize(options={})
+         self.mythreads = []
+         self.ss_start_time=Time.now
+         puts "VERSION StompServer starting:: #{self.class} #{self.version_number}"
+         if RUBY_PLATFORM =~ /java/
+            @javaflag= @java_flag=true
+         else
+           @javaflag= @java_flag=false
+         end
         @my_hostname = Socket.gethostname
+        self.guard    = Mutex.new  
+        self.variables = []
+        #  use like  self.guard.synchronize {   code for synchronize here  }
           self.login =   options[:login]==nil ? '' : options[:login]
-          num =   options[:thread_count]==nil ? '2' : options[:thread_count]
+            self.jms_source =   options[:jms_source]==nil ? nil : options[:jms_source]
+          num =   options[:thread_count]==nil ? '1' : 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
-        self.mythreads = []
-        connect_connection
+      
+        
+        if !self.java?
+           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
+           connect_topic
+           setup_auto_close
+        else 
+          do_jms_setup
+        end
        @debug=false
-       puts "finished StompServer initializing"
-       setup_auto_close
+       puts "#{self.class}: message broker host is: #{host} port is #{port} topic is: #{self.topic} threads #{self.thread_count} my host: #{@my_hostname} jms source #{self.jms_source} java flag #{@javaflag}"
+       puts "VERSION StompServer finalized:: #{self.class} #{self.version_number}"
+       
         trap("INT")   {  puts "#{Time.now}: #{self.class} in interrupt trap\n"
                           #close_topic
                           #disconnect_stomp
                           #setup_auto_close   already done in INIT
-                          exit(0)}
+                          jms_close_connections
+                          exit! }
+    
+       
+     end
+     def java?
+        @javaflag
+      end
+     def version_number
+        module_name=self.class.to_s.split('::')[0] 
+        version_num = eval("#{module_name}::VERSION::STRING")  #note needs version/string
+     end
+     def create_dest_conn
+       #  puts "IN CREATE DEST CONN"
+         @ss_jms_dest, @ss_jms_conn = jms_create_destination_connection(self.topic)  if @ss_jms_conn==nil
+       #  @ss_jms_conn.start if  @ss_jms_conn!=nil
+       #  puts " STARTED CONNECTION"
+      #   puts "JMS create dest_conn :dest #{@ss_jms_dest.inspect} conn: #{@ss_jms_conn.inspect}"
+     end
+     def create_jms_mdb_connections
+        puts "----> entering jms mdb connections"
+        jms_start("TopicConnectionFactory",self.jms_source) #if @JmsTools_conn_factory==nil
+        create_dest_conn
+        puts "<---- leaving jms mdb connections" # if @debug
+     end
+     def do_jms_setup
+         puts "----> entering jms setup" #if @debug
+         setup_thread_specific_items("#{self.jms_source} thread")
+         create_jms_mdb_connections
+     #    jms_auto_close
+         check_thread
+          puts "<---- leaving jms setup" # if @debug
      end
       def reconnect
           puts "about to reconnect"
@@ -53,23 +137,70 @@ module StompMessage
                 # self.mythreads.each {|t| t.raise "auto exit" }
                }
      end
+     def server_shutdown
+       puts "----in server shutdown"
+     end
+       def jms_close_connections
+          puts "----in jms close connections #{self.topic}--HERE BE DRAGONS"
+         # puts "----#{@ss_jms_dest.inspect} #{@ss_jms_conn.inspect} #{@ss_session.inspect} #{@ss_producer.inspect}" 
+           @ss_session.close if @ss_session!=nil
+           @ss_producer.close  if @ss_producer!=nil
+           @ss_jms_conn.close  if @ss_jms_conn!=nil
+             @ss_consumer.close  if @ss_consumer!=nil
+      #     @ss_session=@ss_producer=@ss_jms_conn=nil
+           server_shutdown
+           object_duration = Time.now - self.ss_start_time
+           puts "---- Duration: #{object_duration} #{self.class} #{self.version_number} on topic #{self.topic}"
+            #   puts "----closed session and producer #{@ss_jms_dest.inspect} #{@ss_jms_conn.inspect} #{@ss_session.inspect} #{@ss_producer.inspect}"
+            object_duration=nil
+            puts "----after jms shutdown #{self.topic}--- exiting"
+            #exit!
+       end
+       def check_session  #NOT USED
+        
+         @ss_producer,  @ss_session = jms_create_producer_session(@ss_jms_dest, @ss_jms_conn) if @ss_producer==nil || @ss_session==nil
+       end
+       def jms_auto_close
+          at_exit { puts "#{self.class}: in at exit block"
+          # PERHAPS SET GLOBALBS for dest/conn
+                   jms_close_connections
+                   # 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 jms_message_handling(tjms_dest, tjms_conn)
+    #puts "JMS MESSAGE HNDLE #{tjms_dest.inspect} #{tjms_conn.inspect}"
+        @ss_producer, @ss_session  = self.jms_create_producer_session(tjms_dest, tjms_conn)
+   #     puts "JMS MESSAGE HNDLE sprod #{@ss_producer.inspect} sess #{@ss_session.inspect}"
+        result = yield
+        jms_close_producer_session(  @ss_producer, @ss_session )
+        result
+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
+          # if headers['reply-to']!=nil ||  headers['JMSReplyTo']!=nil
+                 reply_topic=headers['reply-to']
+                # create_dest_conn
+                 response_header = {'persistent'=>'false'}
+                 response_header.merge headers
+                 response_header['id']= headers['id']
+                 response_header['JMSReplyTo']= headers['JMSReplyTo']
+             #    puts "SEND REPLY setting response to #{response_header['JMSReplyTo']} for id #{response_header['id']}  "
+              puts "SEND REPLY #{response_header.inspect}" if @debug
+                 puts "<----- reply to follow:"
+                 if  self.java?
+                     jms_message_handling(@ss_jms_dest, @ss_jms_conn) {                 jms_send_message(@ss_session,@ss_producer,headers,msg.to_xml)  }
+                 
+                 else
+                   self.conn.send(reply_topic, msg.to_xml, response_header ) 
+                  end
+                
+         #   end
+     
      end
      # name is message command
      def connect_topic
@@ -96,23 +227,37 @@ module StompMessage
           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}"
+        body="ALIVE Class: #{self.class.to_s} id: #{self.object_id} listening to: #{self.topic} on host #{@my_hostname} id  thread #{Thread.current.inspect}  msg_count #{self.msg_count} exception_count #{self.exception_count} time: #{Time.now}\n"
+          body << "Object details  #{self.inspect}"  if @debug
          reply_msg = StompMessage::Message.new('stomp_REPLY', body)
-         send_reply(stomp_msg.headers,reply_msg) if stomp_msg.headers['reply-to']!=nil
+          [true, reply_msg]
+     
+      end
+      def check_thread
+         if @debug  
+            puts "----check thread id: #{get_id} Thread value: #{Thread.current.inspect}  "
+            self.variables[get_id].each { |key, val| 
+                puts "---- key #{key} is: #{val.inspect}"}
+         end
       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?}"
+      
+        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} id #{self.inspect} thread #{Thread.current.inspect} 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
+         [true, reply_msg]
+        
       end
      def stomp_DEBUG(msg,stomp_msg)
+       
         @debug=!@debug
         puts "debug flag is now #{@debug}"
+         [false, ""]
      end
      def method_missing(name, *args)
        puts "Method missing called: #{name}"
        puts "Likely invalid message recieved"
+          [false, ""]
      end
      # monitor queue
      def monitor_queue_status
@@ -139,7 +284,7 @@ module StompMessage
        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}"
+       result << "Thread: #{Thread.current[:name]} :exception messag #{e.message} e: #{e.inspect}"
          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)
@@ -147,20 +292,73 @@ module StompMessage
             puts "Can not send email, please check smtp host setting"
          end
      end
+     def check_origin(thash)
+       flag= false
+        src_id = thash['JMSOrigin']
+        flag= src_id.to_s!=self.jms_source if src_id!=nil
+        #puts "ORIGIN FLAG #{flag}"
+        flag
+     end
+       def onMessage(msg_body,msg_hash)
+           puts "message body is : #{msg_body} hash #{msg_hash}"      if @debug
+           puts "my id is #{jms_my_id} message id is #{msg_hash['JMSOrigin']}"   if @debug
+            start_time=Time.now
+           if check_origin(msg_hash)
+           begin
+              self.msg_count+=1
+              check_thread    if @debug
+   	          m=StompMessage::Message.load_xml(msg_body)
+   	          puts "----> #{Time.now} received msg is #{m.command}" # if @debug
+      	       msg=StompMessage::JmsMessage.new(msg_body,msg_hash)
+      	       puts "jms message: #{msg.inspect}" if @debug
+      	     
+      	       r=send(m.command, m, msg)
+      	        duration=Time.now-start_time
+      	        puts "--- Message processing before reply: #{self.topic}: #{m.command} : #{duration}"
+      	       send_reply(msg.headers,r[1])    if r[0]==true
+  	           duration=Time.now-start_time
+  	         
+  	           puts "--- Message processed #{self.topic}: #{m.command} : #{duration}"
+  	             m=nil
+   	        rescue Exception => e
+   	           self.exception_count+=1
+               handle_exception(e)
+ 	          end
+ 	         else
+ 	           puts "----> received message from myself...ignoring #{msg_hash['JMSOrigin']}"
+ 	         end   #JMS Origin if
+ 	         msg_body=msg_hash=nil
+ 	         puts "<-----finished onMesage"
+   	      # puts "Message is: #{m.to_xml}"  if @debug
+   	        # effectively case statement  (Should SCREEN HERE)
+   	      # puts "sms text is: #{sms.text} dest is: #{sms.destination} result is: #{res}"
+        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)
+	       r=send(m.command, m, msg)
+ 	       send_reply(msg.headers,r[1]) if r[0]=true
 	      # 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 get_id
+         id = Thread.current[:id] 
+         id = 1 if @java_flag
+         id
+     end
      def setup_thread_specific_items(mythread_number)
-     
+        puts "----> entering setup threads #{mythread_number}" # if @debug
        Thread.current[:name]= "Thread: #{mythread_number}"
-        puts " #{Thread.current[:name]} in setup thread specific data"
+       Thread.current[:id]=mythread_number
+       self.variables[get_id]={}
+       
+       #self.variables[get_id][:test_field]='test problem'
+       check_thread
+       puts "<---- leaving setup threads" if @debug
+       
      end
      def run
           1.upto(self.thread_count)   { |c|  # create the threads here