Sipper 1.1.3

data/sipper/util/timer/sip_timer_helper.rb

@@ -0,0 +1,26 @@
+require 'util/timer/timer_manager'
+require 'util/timer/timer_task'
+
+module SIP
+  class SipTimerHelper
+  
+    def initialize(manager)
+      @tm = manager
+    end
+    
+    # Have methods for all protocol timers here, along with other type of timers
+    # like user level timers
+    
+    def schedule_for(target, tid, block=nil, type=:session, duration=500)
+      task = TimerTask.new(target, block, tid, type, duration)
+      @tm.schedule task
+      return task
+    end
+    
+    def granularity
+      @tm.granularity
+    end
+    
+        
+  end
+end

data/sipper/util/timer/timer_manager.rb

@@ -0,0 +1,80 @@
+require 'rubygems'
+gem 'facets', '= 1.8.54'
+#require 'facets/more/pqueue'
+require 'ruby_ext/pqueue'
+require 'monitor'
+
+require 'sip_logger'
+require 'util/sipper_util'
+
+module SIP
+  class TimerManager
+    include SipLogger
+    include SipperUtil
+  
+    attr_reader :granularity
+    
+    MAX_TIME = Time.local(2038, "jan", 1).to_f*1000  # a long time
+    
+    def initialize(msg_q=nil, granularity=50)
+      @msg_q = msg_q 
+      #@pqueue = PQueue.new() {|x,y| x<y}
+      @pqueue = PQueue.new(lambda {|x,y| x<y})
+      @lock = Monitor.new
+      @cond = @lock.new_cond
+      @granularity = granularity
+      @running = false
+      @next_schedule = MAX_TIME  
+    end
+    
+    
+    def schedule(task)
+      log_and_raise "Timer Manager not running", RuntimeError unless @running
+      if task.canceled?
+        logw("TimerTask #{task} is canceled, will not be scheduled")
+        return  
+      end
+      @lock.synchronize do
+        @pqueue.push task
+        @cond.signal if @next_schedule > task.abs_msec + @granularity 
+      end
+      task
+    end
+    
+    # possibly keep a separate list and then just gloss over when due.
+    def remove_task(task)
+    end
+    
+    def start
+      logi "Starting the TimerManager"
+      @running = true
+      Thread.new do
+        @lock.synchronize do
+          while @running
+            # look for top if not current then wait on cond
+            if (t = @pqueue.top) 
+              diff = t.abs_msec - Time.ctm
+              if diff >= @granularity 
+                @next_schedule = t.abs_msec
+                @cond.wait(diff/1000.0)
+              else
+                @msg_q << @pqueue.pop
+              end
+            else
+              @next_schedule = MAX_TIME
+              @cond.wait  
+            end
+          end #while
+        end #lock
+      end #thread
+    end #def
+    
+    
+    def stop
+      logi "Stopping the TimerManager"
+      @running = false
+    end
+    
+    
+  end
+end

data/sipper/util/timer/timer_task.rb

@@ -0,0 +1,56 @@
+require 'ruby_ext/time'
+require 'sip_logger'
+
+# The target can be anything which defines a on_timer method. For our purposes it can be 
+# a session for most part and possibly transaction. 
+# todo update this doc. 
+# type can be :session, :app, :transaction. also note that for both :app and :session
+# the target is session. 
+
+module SIP
+  class TimerTask
+    include Comparable
+    attr_reader :abs_msec, :tid, :task, :target, :type, :duration
+    
+    def initialize(target, task_proc=nil, tid="sip_task", type=:session, duration=100)
+      raise ArgumentError, "Time cannot be in past"  if duration < 0
+      @duration = duration
+      @target = target
+      @type = type
+      if task_proc
+        @task = task_proc
+      elsif block_given?
+        @task = Proc.new  # converts the block given to initialize to Proc
+      end
+      @tid = tid
+      @abs_msec = Time.ctm + duration
+      @canceled = false
+    end
+    
+    # Compare on time only
+    def <=>(that)
+      abs_msec <=> that.abs_msec
+    end
+    
+    def invoke
+      if @canceled 
+        SipLogger['siplog::sip_timermanager'].info("Not invoking timer #{self} as it is canceled")
+        return 
+      end
+      @target.on_timer_expiration self
+    end
+    
+    def canceled?
+      @canceled
+    end
+    
+    def cancel
+      @canceled = true
+      SipLogger['siplog::sip_timermanager'].info("Canceled the timer #{self}")
+    end
+    
+    def short_to_s
+      self.to_s
+    end
+  end
+end

data/sipper/util/validations.rb

@@ -0,0 +1,44 @@
+module SIP
+  module Validations
+  
+    def validate_presence_of_headers(*hdr_names)
+      hdr_names.each do |hdr|
+        if self.imessage[hdr]
+          self.do_record("true")
+        else
+          self.do_record("header #{hdr} not found in the message")
+        end
+      end
+    end
+    
+    def validate_header_values(hdr_val_hash)
+      hdr_val_hash.each do |k,v|
+        if self.imessage[k]
+          mvh = v.split(",").sort
+          if mvh == self.imessage[k].sort
+            self.do_record("true")
+          else
+            self.do_record("actual header value found is #{self.imessage[k]}")
+          end
+        else
+          self.do_record("header #{k} not found in the message")
+        end
+      end
+    end
+    
+    def validate_presence_of_header_params(hdr_name, *params)
+      if hdr=self.imessage[hdr_name]
+        params.each do |p|
+          if hdr[0].send p.to_sym
+            self.do_record("true")
+          else
+            self.do_record("param #{p} not found on #{hdr_name}") 
+          end 
+        end
+      else
+        self.do_record("header #{hdr_name} not found in the message")
+      end
+    end
+    
+  end
+end

data/sipper/version.rb

@@ -0,0 +1,10 @@
+module SIP
+  module VERSION #:nodoc:
+    unless defined? MAJOR
+      MAJOR = 1
+      MINOR = 1
+      TINY  = 3
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    end
+  end
+end

data/sipper_test/_test_media_uas.rb

@@ -0,0 +1,79 @@
+require 'driven_sip_test_case'
+
+class Testmediacontroller < DrivenSipTestCase 
+
+  def setup
+    @sm = SipperConfigurator[:SipperMedia] 
+    SipperConfigurator[:SipperMedia] = true
+    super
+    SipperConfigurator[:SessionRecord]='msg-info'
+    SipperConfigurator[:WaitSecondsForTestCompletion] = 40
+    str = <<-EOF
+# FLOW : > INVITE, < 200, > ACK
+#
+require 'base_controller'
+
+class TestmediacontrollerController < SIP::SipTestDriverController 
+
+  # change the directive below to true to enable transaction usage.
+  # If you do that then make sure that your controller is also 
+  # transaction aware. i.e does not try send ACK to non-2xx responses,
+  # does not send 100 Trying response etc.
+
+  transaction_usage :use_transactions=>true
+
+  def initialize
+    logd('Controller created')
+  end
+
+
+  def on_register(session)
+    session.respond_with(200) 
+    registration_store.put(:bob, session.irequest.contact.uri.to_s)
+    session.invalidate(true)
+  end
+
+
+  def on_invite(s)
+    s.set_media_attributes(:codec=>['G711U', 'DTMF'],
+      :type=>'SENDRECV',
+      :play=>{:file=>'hello_sipper.au', :repeat=>false},
+      :record_file=>'in_sipper.au',
+      :remote_m_line=>['any'])
+    s.respond_with(200)
+  end
+  
+  def on_subscribe(session)
+    session.respond_with(200)
+  end
+
+  def on_media_audio_started(session)
+    puts "NK **** Media started**"
+  end
+    
+    def on_media_audio_stopped(session) 
+      puts "NK **** Media stopped**"
+    end
+    
+    def on_media_dtmf_received(session)
+      puts "NK*********DTMF key received****"+session.imedia_event.dtmf
+    end
+
+  def on_ack(session)
+    #sleep 15
+    #session.invalidate
+    #session.flow_completed_for('Testmediacontroller')
+  end
+
+end
+    EOF
+    define_controller_from(str)
+    set_controller('TestmediacontrollerController')
+  end
+
+  def test_case_1
+    self.expected_flow = ['> INVITE','< 200','> ACK']
+    start_controller
+    verify_call_flow(:out)
+  end
+end

data/sipper_test/base_test_case.rb

@@ -0,0 +1,31 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","sipper")
+
+require 'sipper'
+
+$:.unshift File.join(SipperConfigurator[:SipperBasePath],"sipper","lib")
+$:.unshift File.join(SipperConfigurator[:SipperBasePath],"sipper","lib", "smc")
+
+require 'sipper_assertions'
+
+require 'yaml'
+require 'session_recorder'
+
+require 'test/unit'
+
+#Signal.trap("INT") { puts; exit }
+
+class BaseTestCase < Test::Unit::TestCase
+ 
+  def setup
+    SipperConfigurator[:SessionRecordPath] = File.join(SipperConfigurator[:LogPath], ".Test#{self.class.name}")
+    FileUtils.mkdir_p SipperConfigurator[:SessionRecordPath]
+    #puts "Now testing #{self.class.name}"
+  end
+  
+  def teardown
+    FileUtils.rm_r SipperConfigurator[:SessionRecordPath]  unless (Dir.glob(File.join(SipperConfigurator[:SessionRecordPath], "*"))).length>0 if File.exist?(SipperConfigurator[:SessionRecordPath]) if SipperConfigurator[:SessionRecordPath]
+  end
+  
+  undef_method :default_test   
+
+end

data/sipper_test/c_134.txt

@@ -0,0 +1,7 @@
+v=0
+o=user1 53655765 2353687637 IN IP4 127.0.0.1
+s=-
+c=IN IP4 172.17.31.207
+t=0 0
+m=audio 10000 RTP/AVP 0
+a=rtpmap:0 PCMU/8000

data/sipper_test/driven_sip_test_case.rb

@@ -0,0 +1,96 @@
+require 'sip_test_case'
+require 'test_completion_signaling_helper'
+require 'sipper_configurator'
+require 'util/expectation_parser'
+
+class DrivenSipTestCase < SipTestCase
+  
+  @@now_running = "DrivenSipTestCase"
+  
+  def start_controller(in_mem_rec=false)
+    SipperConfigurator[:SessionTimer] = SIP::Locator[:Sth].granularity # we want a quick invalidation for driven test cases
+    # see test_completion_signaling_helper for descriptive comment on this
+    # sequence.
+    _prep_monitor
+    super
+    wait_for_signaling
+  end
+  
+  def start_named_controller_non_blocking(name, in_mem_rec=false)
+    set_controller(name)
+    SipperConfigurator[:SessionTimer] = SIP::Locator[:Sth].granularity # we want a quick invalidation for driven test cases
+    # see test_completion_signaling_helper for descriptive comment on this
+    # sequence.
+    _prep_monitor
+    start_the_set_controller(in_mem_rec)
+  end
+  
+  def _prep_monitor
+    @sd = SIP::TestCompletionSignalingHelper.prepare_monitor_for(self.class.name) unless @sd  
+    @ok_to_wait = true
+  end
+  
+  def wait_for_signaling
+    if @ok_to_wait
+      SIP::TestCompletionSignalingHelper.wait_for_completion_on(@sd)
+      @ok_to_wait = false
+    end  
+  end
+  
+  # Runs assertions against the expected flow.
+  #  assert_equal("> INFO", record_out.get_recording[0])
+  def verify_call_flow(direction, idx=0)
+    if current_controller && current_controller.class < SIP::SipTestDriverController
+      if direction.to_s == "in"
+        recording = get_in_recording(idx).get_info_only_recording
+      elsif direction.to_s == "out"
+        recording = get_out_recording(idx).get_info_only_recording
+      end  
+      expectation = @flowarr
+      ep = SipperUtil::ExpectationParser.new
+      ep.parse(expectation)
+      recording.each do |msg|
+        begin
+          match_result = ep.match(msg)
+          assert(match_result[0])
+        rescue Test::Unit::AssertionFailedError => e
+          raise Test::Unit::AssertionFailedError.new("Expected= #{match_result[1]}  Actual= #{msg}")  
+        end
+      end
+    else
+      flunk "The controller #{current_controller} is not a proper controller for flow verification"
+    end
+  end
+  
+    # Flow(s) are the array of messages with their direction in the form 
+    # of arrows. 
+    # "INVITE >" indicates an outgoing INVITE request and "180 <" indicates an
+    # incoming 180 response. 
+    # The expected messages further have a mini grammar to indicate the various
+    # options in the expected flow. 
+    # * a trailing ? (question) of the arrow indicates an optional message, 100 <? means an optional 100, i.e 0 or 1
+    # * a trailing + (plus) of the arrow indicates at least 1 of the message 1 or more
+    # * a trailing * (star) of the arrow is for 0 or more of the messages. 
+    # Note if the flow is [...."180 <", "180 <", ...] then it means that 2 distinct 180s are expected
+    # while a "180 <+" means that exactly "same" 180 response is to be received twice.
+    # The responses can also take wildcards like "18x" matches any of the 180-189 response code,
+    # 1xx is any provisional response including 100. 
+    # Two special modifiers "gt" and "lt" can also be used with the responses with a period in between.
+    # "1xx.gt.100 <" indicates an expectation of a 1xx class response but greater than 100.
+    # 
+    # Expected flow is an array with messages like 
+    # ["> INFO", "< 200", "< INFO", "> 200", "> INFO", "< 200"]
+    # In order to signal the end of test we need to find the smallest non-repeating pattern in the 
+    # expected flow (from the end) and then compare the building actual flow against it. 
+    # Whenever flow is complete we signal the test class. 
+  def expected_flow=(flowarr)
+    @flowarr = flowarr 
+  end
+  
+  def set_controller(name)
+    super
+  end
+  private :_prep_monitor  
+end
+
+

data/sipper_test/gold.txt

@@ -0,0 +1,10 @@
+INVITE sip:nasir@agnity.com SIP/2.0
+Contact: <sip:127.0.0.1:5060;transport=UDP>
+P-Asserted-Identity: <sip:nina@home.com>
+Max-Forwards: 70
+Call-ID: 1-_PID_@127.0.0.1
+Via: SIP/2.0/UDP 127.0.0.1:5061;branch=z9hG4bK-1-0-1
+From: Sipper <sip:sipper@127.0.0.1:5060>;tag=2
+To: Sut <sip:sut@127.0.0.1:5061>
+Cseq: 1 INVITE
+Content-Length: 0