Sipper 1.1.3

data/sipper_test/test_controllers/multiple/uac_info_controller.rb

@@ -0,0 +1,21 @@
+require 'blank_test'
+
+module InfoTest
+  class UacInfoController < SIP::BaseController
+  
+     def start
+       r = Request.create_initial("info", "sip:nasir@agnity.com", :p_session_record=>"msg-info")
+       u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+       u.send(r)
+       logd("Sent a new request from #{name}")
+       b = BlankTest.new
+     end
+     
+     def on_success_res(session)
+       logd("Received response in #{name}")
+       session.invalidate(true) 
+       session.flow_completed_for("TestMultiple")
+     end
+     
+  end
+end

data/sipper_test/test_controllers/multiple/uac_msg_controller.rb

@@ -0,0 +1,20 @@
+require 'base_controller'
+
+module SipMessage
+  class UacMsgController < SIP::BaseController
+  
+     def start
+       r = Request.create_initial("message", "sip:nasir@sipper.com", :p_session_record=>"msg-info")
+       u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+       u.send(r)
+       logd("Sent a new request from #{name}")
+     end
+     
+     def on_success_res(session)
+       logd("Received response in #{name}")
+       session.invalidate(true) 
+       session.flow_completed_for("TestMultiple")
+     end
+     
+  end
+end

data/sipper_test/test_controllers/multiple/uas_info_controller.rb

@@ -0,0 +1,15 @@
+require 'base_controller'
+
+module InfoTest
+  class UasInfoController < SIP::BaseController
+    
+     def on_info(session)
+       logd("Received #{session.irequest.method} in #{name}")
+       session.local_tag = 5  #todo differentiate automatically on the same container somehow
+       r = session.create_response(200, "OK")
+       session.send(r)
+       session.invalidate(true)
+     end
+     
+  end
+end

data/sipper_test/test_controllers/multiple/uas_msg_controller.rb

@@ -0,0 +1,14 @@
+require 'base_controller'
+
+module SipMessage
+  class UasMsgController < SIP::BaseController
+    
+     def on_message(session)
+       logd("Received MESSAGE in #{name}")
+       session.local_tag = 5  #todo differentiate automatically on the same container somehow
+       r = session.create_response(200, "OK")
+       session.send(r)
+       session.invalidate(true)
+     end
+  end
+end

data/sipper_test/test_controllers/nict_tcbh/lib/transaction_handlers/app_nict_handler.rb

@@ -0,0 +1,13 @@
+require 'transaction/state_machine_wrapper'
+
+class AppNictHandler
+
+  def before_request(txn)
+    txn.message.test_header = "Sipper"
+  end
+  
+  def before_final(txn)
+    txn.message.test_response_header = "Sipper"
+  end
+    
+end

data/sipper_test/test_controllers/nict_tcbh/uac_nict_tcbh_controller.rb

@@ -0,0 +1,26 @@
+require 'transaction_handlers/app_nict_handler'
+
+module SipNict
+  class UacNictTcbhController < SIP::SipTestDriverController
+      
+    transaction_usage :use_transactions=>false, :use_nict=>true
+    transaction_handlers :Nict=>AppNictHandler
+    #start_on_load :true
+    
+    def start
+      u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+      u.request_with("info", "sip:nasir@sipper.com", :p_session_record=>"msg-debug")
+      logd("Sent a new INFO from #{name}")
+    end
+ 
+    def on_success_res(session)
+      logd("Received response in #{name}")
+      if session.iresponse.test_response_header
+        logd("Test-Response-Header found in the response")
+        session.request_with("message")
+      end
+      session.invalidate
+    end
+        
+  end
+end

data/sipper_test/test_controllers/nict_tcbh/uas_nict_tcbh_controller.rb

@@ -0,0 +1,20 @@
+require 'sip_test_driver_controller'
+
+module SipNict
+  class  UasNictTcbhController < SIP::SipTestDriverController
+    def on_info(session)
+      logd("Received INFO in #{name}")
+      session.local_tag = 5  #todo differentiate automatically on the same container somehow
+      session.respond_with(200)
+    end
+    
+    def on_message(session)
+      session.invalidate
+      session.flow_completed_for("TestControllerUsingNictWithTcbh")
+    end
+        
+    def order
+      0
+    end
+  end
+end

data/sipper_test/test_controllers/state_machine_based/lib/CreditControl.sm

@@ -0,0 +1,43 @@
+%class SipCreditControl
+
+%start MessageMap::Initial
+
+%map MessageMap
+
+%%
+
+Initial
+{
+  invite      Connecting {}
+}
+
+
+Connecting
+{
+
+  provisional nil        {}
+
+  error(s: Session)  Terminated { cleanup(s); }
+
+  success     Connected  {}
+
+}
+
+
+Connected
+{
+  message(s: Session)  
+  [ctxt.check_credit(s)] 
+    nil   { send_success(s); } 
+
+  message(s: Session)   Terminated  { send_bye(s); cleanup(s); }
+
+  bye(s: Session)       Terminated { send_bye(s); cleanup(s); }
+}
+
+
+Terminated
+{
+}
+
+%%

data/sipper_test/test_controllers/state_machine_based/lib/CreditControl_sm.rb

@@ -0,0 +1,194 @@
+# DO NOT EDIT.
+# generated by smc (http://smc.sourceforge.net/)
+# from file : CreditControl.sm
+
+require 'statemap'
+
+class SipCreditControlState < Statemap::State
+
+    def Entry(fsm) end
+
+    def Exit(fsm) end
+
+    def bye(fsm, s)
+        Default(fsm)
+    end
+
+    def error(fsm, s)
+        Default(fsm)
+    end
+
+    def invite(fsm)
+        Default(fsm)
+    end
+
+    def message(fsm, s)
+        Default(fsm)
+    end
+
+    def provisional(fsm)
+        Default(fsm)
+    end
+
+    def success(fsm)
+        Default(fsm)
+    end
+
+    def Default(fsm)
+        msg = "\nState: " + fsm.getState.getName +
+            "\nTransition: " + fsm.getTransition + "\n"
+        raise Statemap::TransitionUndefinedException, msg
+    end
+
+end
+
+class MessageMap_Default < SipCreditControlState
+
+end
+
+class MessageMap_Initial < MessageMap_Default
+
+    def invite(fsm)
+        fsm.getState.Exit(fsm)
+        fsm.setState(MessageMap::Connecting)
+        fsm.getState.Entry(fsm)
+    end
+
+end
+
+class MessageMap_Connecting < MessageMap_Default
+
+    def error(fsm, s)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.cleanup(s)
+        ensure
+            fsm.setState(MessageMap::Terminated)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+    def provisional(fsm)
+    end
+
+    def success(fsm)
+        fsm.getState.Exit(fsm)
+        fsm.setState(MessageMap::Connected)
+        fsm.getState.Entry(fsm)
+    end
+
+end
+
+class MessageMap_Connected < MessageMap_Default
+
+    def bye(fsm, s)
+        ctxt = fsm.getOwner
+        fsm.getState.Exit(fsm)
+        fsm.clearState
+        begin
+            ctxt.send_bye(s)
+            ctxt.cleanup(s)
+        ensure
+            fsm.setState(MessageMap::Terminated)
+            fsm.getState.Entry(fsm)
+        end
+    end
+
+    def message(fsm, s)
+        ctxt = fsm.getOwner
+        if ctxt.check_credit(s) then
+            endState = fsm.getState
+            fsm.clearState
+            begin
+                ctxt.send_success(s)
+            ensure
+                fsm.setState(endState)
+            end
+        else
+            fsm.getState.Exit(fsm)
+            fsm.clearState
+            begin
+                ctxt.send_bye(s)
+                ctxt.cleanup(s)
+            ensure
+                fsm.setState(MessageMap::Terminated)
+                fsm.getState.Entry(fsm)
+            end
+        end
+    end
+
+end
+
+class MessageMap_Terminated < MessageMap_Default
+
+end
+
+module MessageMap
+
+    Initial = MessageMap_Initial::new('MessageMap.Initial', 0).freeze
+    Connecting = MessageMap_Connecting::new('MessageMap.Connecting', 1).freeze
+    Connected = MessageMap_Connected::new('MessageMap.Connected', 2).freeze
+    Terminated = MessageMap_Terminated::new('MessageMap.Terminated', 3).freeze
+    Default = MessageMap_Default::new('MessageMap.Default', -1).freeze
+
+end
+
+class SipCreditControl_sm < Statemap::FSMContext
+
+    def initialize(owner)
+        super()
+        @_owner = owner
+        setState(MessageMap::Initial)
+        MessageMap::Initial.Entry(self)
+    end
+
+    def bye(*arglist)
+        @_transition = 'bye'
+        getState.bye(self, *arglist)
+        @_transition = nil
+    end
+
+    def error(*arglist)
+        @_transition = 'error'
+        getState.error(self, *arglist)
+        @_transition = nil
+    end
+
+    def invite()
+        @_transition = 'invite'
+        getState.invite(self)
+        @_transition = nil
+    end
+
+    def message(*arglist)
+        @_transition = 'message'
+        getState.message(self, *arglist)
+        @_transition = nil
+    end
+
+    def provisional()
+        @_transition = 'provisional'
+        getState.provisional(self)
+        @_transition = nil
+    end
+
+    def success()
+        @_transition = 'success'
+        getState.success(self)
+        @_transition = nil
+    end
+
+    def getState()
+        if @_state.nil? then
+            raise Statemap::StateUndefinedException
+        end
+        return @_state
+    end
+
+    def getOwner()
+        return @_owner
+    end
+
+end

data/sipper_test/test_controllers/state_machine_based/order.yaml

@@ -0,0 +1 @@
+- Smc::UasMessageController

data/sipper_test/test_controllers/state_machine_based/uac_message_controller.rb

@@ -0,0 +1,34 @@
+# The UAC does not use the state machine but the UAS does, this example
+# demonstrates the difference in coding style between the two 
+# approaches
+
+module Smc
+  class UacMessageController < SIP::SipTestDriverController
+  
+    def start
+      u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+      u.request_with("invite", "sip:nasir@sipper.com", :p_session_record=>"msg-info")
+      logd("Sent a new request from uac_controller")
+      u[:state] = "invite"
+    end
+    
+    def on_success_res(session)
+      if session[:state] == "invite"
+        logd("Creating ACK on getting 200 OK")
+        session.create_and_send_ack
+      end
+      session.request_with("message")
+      session[:state] = "message"
+    end
+    
+    def on_bye(session)
+      if session[:state] == "message"
+        session.respond_with 200
+        session.invalidate
+      else
+        logw("Got BYE in wrong state")
+      end
+    end
+    
+  end
+end

data/sipper_test/test_controllers/state_machine_based/uas_message_controller.rb

@@ -0,0 +1,44 @@
+require 'CreditControl_sm'
+
+module Smc
+  class UasMessageController < SIP::SipTestDriverController
+  
+    def on_invite(session)
+      session[:sm] = SipCreditControl_sm.new(self) unless session[:sm]
+      session[:sm].invite
+      session.local_tag = 5  #to differentiate the key for UAC/UAS
+      session.respond_with(200)
+      logd("Sent response from #{name}")
+      session[:sm].success
+    end
+    
+    def on_message(s)
+      s[:sm].message(s)
+    end
+    
+    def on_success_res(s)
+      s.invalidate
+      s.flow_completed_for("TestSmcController") 
+    end
+
+    #--------SM callbacks--------     
+    def check_credit(s)
+      (s.remote_cseq)%3!=0
+    end
+     
+    def send_success(s)
+      s.respond_with(200)
+    end
+
+    def send_bye(s)
+      s.request_with "bye"
+    end
+    
+    def cleanup(s)
+      #nothing to cleanup here as we want to signal on 2xx callback, invalidating here
+      #would remove the session which would not allow the response to reach us. 
+    end
+    #--------SM callbacks--------      
+ 
+  end
+end