MultClient/Server-Based Monitor
Overview

   Multiclient-Server based Monitor is a tool 
   for high-performance networking: 
   
   "A Hierarchical Fair Service Curve Algorithm for 
   Link-Sharing, Real-Time and Priority Service". 

   With a GUI, it enables user to remotly 
   perfrom the router network resource 
   management, bandwidth reservation, performance 
   analysis. It is directly based on the 
   kernel of the operating system.

   It is modified from the original monitor
   by seperating the original monitor into 
   two parts: 

   1. Client, which runs at remote
      machine(s) under X Windows, used by users 
      to manage network resource and 
      display the performance. 

   2. Server, which runs at the router 
      to access the kernel, retrieves
      the class information from the kernel
      and replies request from client(s). 

   The basic idea is (please refer to the figure):

   The function ioctl() in original monitor
   is replaced with the function wrap_ioctl(), 
   which will send request id and partially 
   filled required data structure to server. 
   Then, wait for reply from server.

   Once server receives a request from
   client, it does ioctl() call according to the
   request id sent by client and make up
   the required data structure during the
   execution of the function ioctl() (as the
   original code does).  Then, server
   transfers the required data structure to
   client.

   Compared with the original monitor, there
   are following advantages:

   1. It can be used to monitor those 
      routers which do not support xterm. 

   2. Running a server at the router can support
      mutiple clients to monitor the performance
      of the router. 

   3. Users can do this job locally without
      doing telnet etc. 


Program

   The source codes for monitor includes

   -------------------------------------------------------------
                          1. Client
   -------------------------------------------------------------
   cli.c            : TckTk and C interface
   monitor.tcl      : main window
   nodeInfo.ui.tcl  : node configuration window
   nodeName.ui.tcl  : node set name window
   nodeAdd.ui.tcl   : node Add window
   monitor_user.c   : data collection from the kernel
   Makefile         : the makefile for the GUI client program
   Makefile.et      : the sample makefile for et distribution
   monitor_user.h   : the structure and function definition file
   qi_monitor.h     : the definition file for the structure and 
                      default parameters for communication 
   ------------------------------------------------------------- 
                          2. Server
   -------------------------------------------------------------
   ser.c            : server for access kernel and communicate 
                      with client 
   Makefile         : the makefile for the server program
   qi_monitor.h     : the definition file for strutcture and
                      default parameters for communication.
  --------------------------------------------------------------

  Also several packages have been included to build the application:
  (for client) et80b6.tar.gz, tcl8.0p2.tar.gz, tk8.0p2.tar.gz


Installation & Compilation


   To compile client:

   1. At monitor.remote/client, gunzip tcl, tk, and et, which are
      included in the release, and then compile them (if you don't have
      these packages installed in your system).

      cd client
      gunzip -c tcl8.0p2.tar.gz | tar xf -
      gunzip -c tk8.0p2.tar.gz | tar xf -
      gunzip -c et80b6.tar.gz | tar xf -

      Different system may have different ways to compile the tcl, tk and et.
      Here are the steps we did it:

      cd tcl8.0/unix
      ./configure
      make

      cd ../../tk8.0/unix
      ./configure
      make

      cd ../../

      ET distribution is tricker.  We used the makefile included in
      monitor/Makefile.et, filled in the variables (TCL_SRC, TK_SRC, 
      X11_PATH, X11_PATH2), and copied the Makefile to monitor.remote/et.

      mv Makefile.et et/Makefile
      cd et
      make
      cd ..

   2. Make a copy of monitor.remote/client/Makefile.monitor, fill in
      the values as appropriate, and 'make' it.

      cp Makefile.monitor Makefile

      KERNEL_SRC= 
      TCL_SRC = 
      TK_SRC = 
      ET_SRC = 
      # for some reason, netbsd uses 8.0, freebsd uses 80
      TCLTK_LIB = -ltk80 -ltcl80     # freebsd
      # TCLTK_LIB = -ltk8.0 -ltcl8.0   # netbsd

      make

   3. Invoke client by typing 

      ./cli <ip dress of the router> <interface-name>
      <bandwidth>

      in the command input.  Bandwidth is in Kb/s.



   To compile server
  
   1. gunzip -c server.tar.gz | tar xf -
   
   2. fill in the value KERNEL_SRC in Makefile

   3 'make'


  To invoke monitor:

  1. set up the server 
      (if some server has been set up, you don't neet to set up again). 

      1.1 telnet to the router, in which the server has been installed and comiled. 

      1.2 type ./ser
          the server will set up and the default portname is 5555. 

   2. set up the client

      2.1 go back to your mechine, in which your client will be running. 

      2.2 type ./cli   



created on Sep. 20, 1998 by Qi He