Open Mash Cross Reference
mash/tcl/degas/degasclient/aglp.tcl

   import AnnounceListenManager
   
   
   Class AGLP -superclass {AnnounceListenManager}
   
   AGLP public init { type group mtu } {
           $self instvar unique_port_ max_port_ min_port_
           $self instvar type_ 
           $self next $group $mtu
          set type_ $type
          $self set addr_ [localaddr]
          set min_port_ [$self get_option minPort]
          set max_port_ [$self get_option maxPort]
          set unique_port_ $min_port_
          load_delay
  }
  
  AGLP public send { msg } {
          $self announce "$msg\n"
  }
  
  proc print_delay {queue_time} {
          set now [gettimeofday]
          puts "A QUEUE [expr $now - $queue_time]"
  }
  
  AGLP public recv_announcement { addr post msg length } {
          $self recv $addr $post "$msg" $length"
  #       set delay [get_delay $addr]
  #       if {$delay != 0} {
  #               after [get_delay $addr] "$self recv $addr $post \"$msg\" $length"
  #       } else {
  #               $self recv $addr $post "$msg" $length"
  #       }
  }
  
  AGLP public debug { str } {
          if {[$self get_option debug] == 1} {
                  puts "$str"
          }
  }
  
  #------------------------------------------------------------------
  # AnnounceLinstenManager/DegasServer::generate_unique_port
  #
  # purpose : generate a unique port for the server. 
  # input   : none
  # output  : none
  #------------------------------------------------------------------
  
  AGLP private generate_unique_port {} {
      
      # Generate unique port number
      $self instvar unique_port_
      $self instvar port_in_use_
      $self instvar max_port_
      $self instvar min_port_
      incr unique_port_ 4
      set unique_port_ [expr ($unique_port_ % $max_port_) + $min_port_]
      while {[info exists port_in_use_($unique_port_)]} {
          incr unique_port_ 4
          set unique_port_ [expr ($unique_port_ % $max_port_) + $min_port_]
      }
      set port_in_use_($unique_port_) 1
      return $unique_port_
  }
  
  #------------------------------------------------------------------
  # AnnounceLinstenManager/DegasServer::generate_new_session_spec
  #
  # purpose : generate a unique multicast address and port for the
  #           outgoing session.  The multicast address will have 
  #           prefix 224.3
  # input   : none
  # output  : none
  #------------------------------------------------------------------
  
  AGLP private generate_new_session_spec {} {
      
      set port [$self generate_unique_port]
     
      # Generate unique multicast address.  Just generate a random number
      # between 2 and 251, and see if they are used.
      $self instvar addr_in_use_
          MashRNG seed [pid]
      set addr1 [expr ([MashRNG integer 250] + 2)]
      set addr2 [expr ([MashRNG integer 250] + 2)]
      while {[info exists addr_in_use_($addr1,$addr2)]} {
          set addr1 [expr ([MashRNG integer 250] + 2)]
          set addr2 [expr ([MashRNG integer 250] + 2)]
      }
      set addr_in_use_($addr1,$addr2) 1
  
      return 224.3.$addr1.$addr2/$port/[$self get_option ttl]
  }
  
  AGLP public recv_offer_service {addr args} { 
  }
  
 AGLP public recv_serve {addr args} { 
 }
 
 AGLP public recv_served_by {addr args} { 
 }
 
 AGLP public recv_replace {addr args} { 
 }
 
 AGLP public recv_handoff {addr args} { 
 }
 
 AGLP public recv_handoff_ok {addr args} { 
 }
 
 AGLP public recv_help_offer {addr args} { 
 }
 
 AGLP public recv_accept_help {addr args} { 
 }
 
 AGLP public time {} { 
         return [expr [clock seconds] - 978535100]
 }
 
 proc load_delay {} {
         # delay_table is a list of <host_reg_exp delay> pair
         # Note : cannot use array here since [array name] cannot 
         # gurantee order of list.
 
         set f [open "~/.delays" r]
         global delay_table
         set data [read $f]
         set hostname [lindex  [split [info hostname] .] 0]
         foreach {host delay_table} $data {
                 if {$host == $hostname} {
                         return
                 }
         }
 }
 
 
 proc get_delay {addr} {
         global delay_table
         set hostname [lindex [split [lookup_host_name $addr] .] 0]
         foreach {key value} $delay_table {
                 if {[string match $key $addr] || [string match $key $hostname]} {
 #                       puts "DELAY $addr $value"
                         return $value
                 }
         }
         return 0
 }