Open Mash Cross Reference
mash/tcl/degas/degasclient/alm-degas-client.tcl

   import AnnounceListenManager
   
   Class AnnounceListenManager/DegasClient -superclass {AnnounceListenManager}
   
   
   #------------------------------------------------------------------

   # AnnouceListenManager/DegasClient::init

   #

   # purpose : Constructor for a AnnouceListenManager/DegasClient obj

  # input   : spec - Specifies where the ALM should announce and listen.

  #                  Format is <ipaddr>/<port> or <port>.

  #           mtu  - Maximum size of a message.  A buffer of this size

  #                  will be allocated for storing message.

  # output  : none

  #------------------------------------------------------------------

  
  AnnounceListenManager/DegasClient public init {agent controller spec mtu} {
      
      $self next $spec $mtu
  
      # member : prog_filename_ 

      # specifies the filename of the program to submit to 

      # the server to run.

  
      $self instvar prog_filename_
      set prog_filename_ ""
  
      # member : announcement_ 

      # stores the message to announce to the server.

  
      $self instvar announcement_
      set announcement_ ""
  
      # member : after_id_

      # this is the id of the current pending "after" event.

      # It can be used to cancel a scheduled announcement.

      
      $self instvar after_id_
      set after_id_ 0
  
      $self instvar agent_
      set agent_ $agent
  
      $self instvar controller_
      set controller_ $controller
  
          $self timer "DCP client action request" [new Timer/Periodic 5]
          $self start "DCP client action request"
  }
  
  
  #------------------------------------------------------------------

  # AnnouceListenManager/DegasClient::recv_announcement

  #

  # purpose : This is called whenever an announcement is received.

  # input   : addr - the ip address where this message is from.

  #           port - the port where this message is from

  #           m    - the announcement message itself

  #           l    - length of the message.

  # output  : none

  #------------------------------------------------------------------

  
  AnnounceListenManager/DegasClient private recv_announcement {addr port m l} {
      $self log "recv announcement from $addr $port {$m}"
      # Check magic word.

      set magic_word [lindex $m 0]
      if {$magic_word != "DCP"} {
          # This message is not for me.

          return
      }
  
      # Check message type (from server ? or client ?)

      set type [lindex $m 1]
      set m [lrange $m 2 end]
      if {$type == "server"} {
          $self handle_server_message $addr $port $m
      } elseif {$type == "client"} {
          $self handle_client_message $addr $port $m
      }
  }
  
  
  #------------------------------------------------------------------

  # AnnounceListenManager/DegasClient::handle_client_message

  #

  # purpose : Handle message received from other client.  Do nothing

  #           for now.  Not sure if we care what other clients is 

  #           saying.

  # input   : addr,port - the client that announce this message.

  #           m - the message itself.

  # output  : none

  #------------------------------------------------------------------

  
  AnnounceListenManager/DegasClient private handle_client_message {addr port m} {
      return
  }
  
  
  #------------------------------------------------------------------

 # AnnounceListenManager/DegasClient::handle_server_message

 #

 # purpose : Handle message received from server.  

 # input   : addr,port - the client that announce this message.

 #           m - the message itself.

 # output  : none

 #------------------------------------------------------------------

 
 AnnounceListenManager/DegasClient private handle_server_message {addr port m} {
 
     set key [lindex $m 0]
     switch $key {
         "service" {
             $self instvar snet_
             set service_addr [lindex $m 1]
             set service_port [lindex $m 2]
             set my_addr [localaddr]
             set my_port [$snet_ localsport]
             if {$service_addr == $my_addr && $service_port == $my_port} {
                 $self instvar agent_
                 $self instvar controller_
                 set in_session_spec [lindex $m 3]
                 $agent_ reset [new AddressBlock $in_session_spec]
 #                               set log [open client.log a]

 #                               puts $log "receiving from $in_session_spec"

 #                               close $log

                 $controller_ open $addr [lindex $m 4]
             }
             $self stop
         }
     }
 }
 
 
 #------------------------------------------------------------------

 # AnnounceListenManager/DegasClient::create_annoucement

 #

 # purpose : Create a new message.  This message can then be send

 #           by calling "announce".

 # input   : 

 # return  : A new message of the following format :

 #           {

 #               DCP

 #               client

 #               input_session_spec   <addr>/<port>/<ttl>

 #               control_channel_port <port>

 #               sources              <list of sources>

 #               max_num_of_sources   <int> or "*"

 #               init_callback        <program>

 #               recv_frame_callback  <program>

 #               new_source_callback  <program>

 #               del_source_callback  <program>

 #               destroy_callback     <program>

 #           }

 #           This message is read from file whose filename is specified 

 #           with -df option or entered from GUI.

 #------------------------------------------------------------------

 
 AnnounceListenManager/DegasClient public create_announcement {} {
     $self instvar prog_filename_
     $self instvar announcement_
 
     if {$announcement_ == ""} {
             if {$prog_filename_ == ""} {
                     puts stderr "no program filename specified. quiting."
                     exit
             }
             set f [open $prog_filename_ r]
             set announcement_ [$self parse_degas_program $f]
     close $f
     }
     return $announcement_
 }
 
 
 #------------------------------------------------------------------

 # AnnouceListenManager/DegasClient::run

 #

 # purpose : Start the AnnounceListenManager.  This simply calls

 #           create_announcement and annouce repeatedly, with

 #           period seconds between them.

 # input   : period - Interval between two announcements.

 # return  : none

 #------------------------------------------------------------------

 
 AnnounceListenManager/DegasClient public run {period} {
     $self instvar after_id_
     $self instvar announcement_
 
     puts stderr "announcing"
         $self announce "$announcement_"
     set cmd "
         $self announce \{$announcement_\}
         $self run $period
         "
         set after_id_ [after $period $cmd]
 }
 
 
 #------------------------------------------------------------------

 # AnnouceListenManager/DegasClient::stop

 #

 # purpose : Stop the AnnounceListenManager.  This simply calls

 #           cancelled the current scheduled announcement.

 # input   : none

 # return  : none

 #------------------------------------------------------------------

 
 AnnounceListenManager/DegasClient public stop {} {
     $self instvar after_id_
 
     if {[info exists after_id_]} {
         after cancel $after_id_ 
     } else {
         puts stderr "ALM is not running."
     }
 }
 
 
 #------------------------------------------------------------------

 # AnnounceListenManager/DegasClient::log

 #

 # purpose : create a log message of the server.  This can be either

 #           to the screen or to a file.

 # input   : msg - a message to log

 # output  : none

 #------------------------------------------------------------------

 
 AnnounceListenManager/DegasClient private log {msg} {
 #    set log [open LOGFILE a+]

 #    puts $log "$msg"

 #    close $log

 }
 
 
 #------------------------------------------------------------------

 # AnnounceListenManager/DegasClient::parse_degas_program

 #

 # purpose : parse the degas program given the file.  this function

 #           basically remove the comments and add the header for 

 #           announcement.

 # input   : file - the file that contains the program

 # output  : a list of strings that represents the content of the 

 #           program.  

 #------------------------------------------------------------------

 
 AnnounceListenManager/DegasClient private parse_degas_program {f} {
     set result "DCP\nclient\naction new\n"
     while {![eof $f]} {
         set line [gets $f]
         if {![regexp {^[\ \t]*#.*} $line]} {
             append result "$line\n"
         } else {
         }
     }
     return $result
 }