Sipper 1.1.3

data/sipper/sipper_http/sipper_http_request_dispatcher.rb

@@ -0,0 +1,71 @@
+require 'net/http'
+require 'thread'
+require 'uri'
+require 'sipper_http/sipper_http_response'
+require 'sip_logger'
+
+class HttpUrlContext
+  attr_accessor :url, :session, :params, :req_method  
+  def initialize(url, req_method, session, params)
+    @url = url
+    @session = session
+    @params = params
+    @req_method = req_method
+  end
+end
+
+
+class SipperHttpRequestDispatcher
+  include SipLogger
+  # sipper_message_queue is the main event queue in sipper 
+  # this is where all the sip/timer/media and now http responses
+  # are queued.
+  def initialize(sipper_msg_queue, num_threads = 5)
+    @num_threads = num_threads
+    @request_queue = Queue.new 
+    @run = false
+    @smq = sipper_msg_queue
+  end
+  
+  def start
+    @run = true
+    1.upto(@num_threads) do |i|
+      Thread.new do
+        Thread.current[:name] = "HttpClientThread-"+i.to_s
+        while @run
+          url_context = @request_queue.pop
+          url = URI.parse(url_context.url)
+          res = nil
+          if url_context.req_method == 'get'
+            req = Net::HTTP::Get.new(url.path)
+            res = Net::HTTP.start(url.host, url.port) {|http|
+              http.request(req)
+            }
+          elsif url_context.req_method == 'post'
+            req = Net::HTTP::Post.new(url.path)
+            req.set_form_data( url_context.params, '&')
+            res = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }                   
+          end
+          sipper_res = SipperHttp::SipperHttpResponse.new(res, url_context.session)
+          @smq << sipper_res
+        end  
+      end
+    end  
+  end
+  
+  def stop
+    @run = false
+  end
+  
+  # params are a hash of POST parameters
+  def request_post(url, session, params)
+    logd('POST request called on dispatcher, now enquing request')
+    @request_queue << HttpUrlContext.new(url, 'post', session, params)  
+  end
+  
+  def request_get(url, session)
+    logd('GET request called on dispatcher, now enquing request')
+    @request_queue << HttpUrlContext.new(url, 'get', session, nil)
+  end
+  
+end

data/sipper/sipper_http/sipper_http_response.rb

@@ -0,0 +1,25 @@
+require 'delegate'
+
+# Wraps the HTTPResponse, with Sipper context data.
+
+module SipperHttp
+  class SipperHttpResponse < SimpleDelegator
+    
+    attr_reader :session, :wrapped_http_res
+    
+    def initialize(http_res, session)
+      super(http_res)  
+      @session = session
+      @wrapped_http_res = http_res
+    end
+    
+    def dispatch    
+      @session.on_http_response(self)  
+    end
+    
+    def short_to_s
+      self.inspect  
+    end
+    
+  end
+end

data/sipper/stray_message_manager.rb

@@ -0,0 +1,40 @@
+
+module SIP
+ 
+  class StrayMessageHandler
+    
+    SMH_DROP          = 8000
+    SMH_HANDLED       = 8001
+    SMH_RETRY         = 8002
+    SMH_TREAT_INITIAL = 8003
+    
+    # Filter on anonymous Module because if the stray handler is defined inline then 
+    # we load the string twice, once in an anonymous module and once in top 
+    # level object. We do not want to register the stray handler twice. 
+    def self.inherited(child)
+      @stray_message_handler = child.new unless child.to_s =~ /^#<Module/
+    end
+    
+    # default handler
+    def handle(msg)
+      [SIP::StrayMessageHandler::SMH_DROP, nil]
+    end
+   
+    class << self; attr_accessor :stray_message_handler end
+  end
+  
+  
+  class StrayMessageManager
+  
+    def self.stray_message_handler
+        return StrayMessageHandler.stray_message_handler
+    end
+    
+    def self.clear_handler
+      StrayMessageHandler.stray_message_handler = nil
+    end
+    
+  end
+  
+end
+

data/sipper/test_completion_signaling_helper.rb

@@ -0,0 +1,77 @@
+require 'monitor'
+require 'ostruct'
+require 'util/locator'
+
+module SIP
+
+  class TcshProxy
+    def signal_waiting_test(test_name)
+      SipLogger['siplog::sip_testcompletionsignalinghelper'].debug("Fetching the signal data for remote server")
+      TestCompletionSignalingHelper.signal_waiting_test(test_name, true)
+    end
+  end
+  
+  class TestCompletionSignalingHelper
+    include SipLogger
+    
+    @@ro = nil
+    
+    # The breakdown into two following methods: one to be called before starting any SIP 
+    # signaling and other to be called after having started  the controllers, is to set the monitor 
+    # infra in place, such that in the unlikely event of SIP signaling completing before the driver
+    # even waits for the signal. 
+    
+    def self.prepare_monitor_for(test_class_name)
+      test_running = []
+      test_running.extend(MonitorMixin)
+      compl_cond = test_running.new_cond
+      signal_data = OpenStruct.new
+      signal_data.lock = test_running
+      signal_data.cond = compl_cond
+      (SIP::Locator[:Tlocks] ||= {})[test_class_name.to_s] = signal_data
+    end
+    
+    # todo make use of count_waiters and signal added to the test_running[]
+    def self.wait_for_completion_on(signal_data)
+      signal_data.lock.synchronize do
+        if signal_data.lock.nitems > 0
+          SipLogger['siplog::sip_testcompletionsignalinghelper'].debug "Found queued signal, clearing"
+          signal_data.lock.clear
+        else
+          SipLogger['siplog::sip_testcompletionsignalinghelper'].debug "Now waiting for the signal"
+          k = 0
+          while k < SipperConfigurator[:WaitSecondsForTestCompletion]
+            signal_data.cond.wait(3)
+            break if signal_data.lock.nitems > 0
+          end
+        end
+      end
+    end
+    
+    
+    def self.signal_waiting_test(test_name, proxy_call=false)
+      signal_data = SIP::Locator[:Tlocks][test_name] if SIP::Locator[:Tlocks]
+      unless signal_data
+        unless proxy_call 
+          SipLogger['siplog::sip_testcompletionsignalinghelper'].debug "Signaling the remote object"
+          @@ro = DRbObject.new(nil, "druby://#{SipperConfigurator[:TestManagerName]}:#{SipperConfigurator[:TestManagerPort]}")  unless @@ro
+          signal_data = @@ro.signal_waiting_test(test_name)
+          return true
+        else
+          SipLogger['siplog::sip_testcompletionsignalinghelper'].debug "No SD anywhere"
+          return false
+        end
+      end
+      signal_data.lock.synchronize do 
+        signal_data.lock << "signal"
+        if signal_data.cond.count_waiters > 0
+          SipLogger['siplog::sip_testcompletionsignalinghelper'].debug("Signaling the waiting test driver")
+          signal_data.cond.signal
+        else
+          SipLogger['siplog::sip_testcompletionsignalinghelper'].debug "Queueing the signal"
+        end
+      end
+    end
+     
+  end
+end

data/sipper/transaction/Ict.sm

@@ -0,0 +1,59 @@
+// Invite Client Transaction. Section 17.1.1
+
+%class Ict
+
+%start IctMap::Initial
+
+%map IctMap
+
+%%
+
+Initial
+{
+  invite            Calling    { __send_invite(); __start_A(); __start_B(); }
+  transport_err     Terminated { __transport_err(); }  // even though not mentioned in RFC
+}
+
+
+Calling
+Exit   { __cancel_A(); __cancel_B(); }
+{
+  timer_A(t: ltime)  nil        { __send_invite(); __reset_A(t); }
+  provisional        Proceeding { __consume_msg(true); }
+  non_success_final  Completed  { __create_ack(); __send_ack(); __cancel_Y(); __consume_msg(true); } 
+  success_final      Terminated { __cancel_Y(); __consume_msg(true); }  
+  timer_B            Terminated { __timeout(); }  
+  transport_err      Terminated { __transport_err(); }
+  cancel_sent        nil        { __start_Y(); }
+  timer_Y            Terminated { __timeout(); }
+}
+
+
+Proceeding
+Exit  { __cancel_Y(); }
+{
+  provisional        nil        { __consume_msg(true); }
+  non_success_final  Completed  { __create_ack(); __send_ack(); __consume_msg(true); } 
+  success_final      Terminated { __consume_msg(true); } 
+  transport_err      Terminated { __transport_err(); }  // even though not mentioned in RFC
+  cancel_sent        nil        { __start_Y(); }
+  timer_Y            Terminated { __timeout(); }
+}
+
+Completed 
+Entry { __start_D();  }
+{
+  non_success_final  nil        { __send_ack(); __consume_msg(false); }
+  timer_D            Terminated { }
+  transport_err      Terminated { __transport_err(); }
+  cancel_sent        nil        { }  // no effect
+}
+
+
+Terminated
+Entry { __cleanup(); }
+{
+  cancel_sent        nil        { }  // no effect
+}
+
+%%

data/sipper/transaction/Ict_sm.rb

@@ -0,0 +1,430 @@
+# DO NOT EDIT.
+# generated by smc (http://smc.sourceforge.net/)
+# from file : Ict.sm
+
+require 'statemap'
+
+class IctState < Statemap::State
+
+    def Entry(fsm) end
+
+    def Exit(fsm) end
+
+    def cancel_sent(fsm)
+        Default(fsm)
+    end
+
+    def invite(fsm)
+        Default(fsm)
+    end
+
+    def non_success_final(fsm)
+        Default(fsm)
+    end
+
+    def provisional(fsm)
+        Default(fsm)
+    end
+
+    def success_final(fsm)
+        Default(fsm)
+    end
+
+    def timer_A(fsm, t)
+        Default(fsm)
+    end
+
+    def timer_B(fsm)
+        Default(fsm)
+    end
+
+    def timer_D(fsm)
+        Default(fsm)
+    end
+
+    def timer_Y(fsm)
+        Default(fsm)
+    end
+
+    def transport_err(fsm)
+        Default(fsm)
+    end
+
+    def Default(fsm)
+        msg = "\nState: " + fsm.getState.getName +
+            "\nTransition: " + fsm.getTransition + "\n"
+        raise Statemap::TransitionUndefinedException, msg
+    end
+
+end
+
+class IctMap_Default < IctState
+
+end
+
+class IctMap_Initial < IctMap_Default
+
+    def invite(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__send_invite()
+            ctxt.__start_A()
+            ctxt.__start_B()
+        ensure
+            fsm.setState(IctMap::Calling)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+    def transport_err(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__transport_err()
+        ensure
+            fsm.setState(IctMap::Terminated)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+end
+
+class IctMap_Calling < IctMap_Default
+
+    def Exit(fsm)
+        ctxt = fsm.getOwner
+        ctxt.__cancel_A()
+        ctxt.__cancel_B()
+    end
+
+    def cancel_sent(fsm)
+        ctxt = fsm.getOwner
+        endState = fsm.getState
+        fsm.clearState
+        begin
+            ctxt.__start_Y()
+        ensure
+            fsm.setState(endState)
+        end
+    end
+
+    def non_success_final(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__create_ack()
+            ctxt.__send_ack()
+            ctxt.__cancel_Y()
+            ctxt.__consume_msg(true)
+        ensure
+            fsm.setState(IctMap::Completed)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+    def provisional(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__consume_msg(true)
+        ensure
+            fsm.setState(IctMap::Proceeding)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+    def success_final(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__cancel_Y()
+            ctxt.__consume_msg(true)
+        ensure
+            fsm.setState(IctMap::Terminated)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+    def timer_A(fsm, t)
+        ctxt = fsm.getOwner
+        endState = fsm.getState
+        fsm.clearState
+        begin
+            ctxt.__send_invite()
+            ctxt.__reset_A(t)
+        ensure
+            fsm.setState(endState)
+        end
+    end
+
+    def timer_B(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__timeout()
+        ensure
+            fsm.setState(IctMap::Terminated)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+    def timer_Y(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__timeout()
+        ensure
+            fsm.setState(IctMap::Terminated)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+    def transport_err(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__transport_err()
+        ensure
+            fsm.setState(IctMap::Terminated)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+end
+
+class IctMap_Proceeding < IctMap_Default
+
+    def Exit(fsm)
+        ctxt = fsm.getOwner
+        ctxt.__cancel_Y()
+    end
+
+    def cancel_sent(fsm)
+        ctxt = fsm.getOwner
+        endState = fsm.getState
+        fsm.clearState
+        begin
+            ctxt.__start_Y()
+        ensure
+            fsm.setState(endState)
+        end
+    end
+
+    def non_success_final(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__create_ack()
+            ctxt.__send_ack()
+            ctxt.__consume_msg(true)
+        ensure
+            fsm.setState(IctMap::Completed)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+    def provisional(fsm)
+        ctxt = fsm.getOwner
+        endState = fsm.getState
+        fsm.clearState
+        begin
+            ctxt.__consume_msg(true)
+        ensure
+            fsm.setState(endState)
+        end
+    end
+
+    def success_final(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__consume_msg(true)
+        ensure
+            fsm.setState(IctMap::Terminated)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+    def timer_Y(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__timeout()
+        ensure
+            fsm.setState(IctMap::Terminated)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+    def transport_err(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__transport_err()
+        ensure
+            fsm.setState(IctMap::Terminated)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+end
+
+class IctMap_Completed < IctMap_Default
+
+    def Entry(fsm)
+        ctxt = fsm.getOwner
+        ctxt.__start_D()
+    end
+
+    def cancel_sent(fsm)
+    end
+
+    def non_success_final(fsm)
+        ctxt = fsm.getOwner
+        endState = fsm.getState
+        fsm.clearState
+        begin
+            ctxt.__send_ack()
+            ctxt.__consume_msg(false)
+        ensure
+            fsm.setState(endState)
+        end
+    end
+
+    def timer_D(fsm)
+        fsm.getState.Exit(fsm)
+        fsm.setState(IctMap::Terminated)
+        fsm.getState.Entry(fsm)
+    end
+
+    def transport_err(fsm)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.__transport_err()
+        ensure
+            fsm.setState(IctMap::Terminated)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+end
+
+class IctMap_Terminated < IctMap_Default
+
+    def Entry(fsm)
+        ctxt = fsm.getOwner
+        ctxt.__cleanup()
+    end
+
+    def cancel_sent(fsm)
+    end
+
+end
+
+module IctMap
+
+    Initial = IctMap_Initial::new('IctMap.Initial', 0).freeze
+    Calling = IctMap_Calling::new('IctMap.Calling', 1).freeze
+    Proceeding = IctMap_Proceeding::new('IctMap.Proceeding', 2).freeze
+    Completed = IctMap_Completed::new('IctMap.Completed', 3).freeze
+    Terminated = IctMap_Terminated::new('IctMap.Terminated', 4).freeze
+    Default = IctMap_Default::new('IctMap.Default', -1).freeze
+
+end
+
+class Ict_sm < Statemap::FSMContext
+
+    def initialize(owner)
+        super()
+        @_owner = owner
+        setState(IctMap::Initial)
+        IctMap::Initial.Entry(self)
+    end
+
+    def cancel_sent()
+        @_transition = 'cancel_sent'
+        getState.cancel_sent(self)
+        @_transition = nil
+    end
+
+    def invite()
+        @_transition = 'invite'
+        getState.invite(self)
+        @_transition = nil
+    end
+
+    def non_success_final()
+        @_transition = 'non_success_final'
+        getState.non_success_final(self)
+        @_transition = nil
+    end
+
+    def provisional()
+        @_transition = 'provisional'
+        getState.provisional(self)
+        @_transition = nil
+    end
+
+    def success_final()
+        @_transition = 'success_final'
+        getState.success_final(self)
+        @_transition = nil
+    end
+
+    def timer_A(*arglist)
+        @_transition = 'timer_A'
+        getState.timer_A(self, *arglist)
+        @_transition = nil
+    end
+
+    def timer_B()
+        @_transition = 'timer_B'
+        getState.timer_B(self)
+        @_transition = nil
+    end
+
+    def timer_D()
+        @_transition = 'timer_D'
+        getState.timer_D(self)
+        @_transition = nil
+    end
+
+    def timer_Y()
+        @_transition = 'timer_Y'
+        getState.timer_Y(self)
+        @_transition = nil
+    end
+
+    def transport_err()
+        @_transition = 'transport_err'
+        getState.transport_err(self)
+        @_transition = nil
+    end
+
+    def getState()
+        if @_state.nil? then
+            raise Statemap::StateUndefinedException
+        end
+        return @_state
+    end
+
+    def getOwner()
+        return @_owner
+    end
+
+end