genericlink.java

一个小型网络仿真器的实现

/*
   JaNetSim  ---  Java Network Simulator
   -------------------------------------

   This software was developed at the Network Research Lab, Faculty of
   Computer Science and Information Technology (FCSIT), University of Malaya.
   This software may be used and distributed freely. FCSIT assumes no responsibility
   whatsoever for its use by other parties, and makes no guarantees, expressed or
   implied, about its quality, reliability, or any other characteristic.

   We would appreciate acknowledgement if the software is used.

   FCSIT ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION AND
   DISCLAIM ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING
   FROM THE USE OF THIS SOFTWARE.
*/

package janetsim.component;

import janetsim.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class GenericLink extends SimComponent implements AnalyzerUser,
                                                          java.io.Serializable {
  private class LinkNeighbor implements java.io.Serializable {
    SimComponent to_link=null;
    SimParamDouble c_rate=null;
    SimParamDouble l_rate=null;
    SimParamInt packet_drop=null;
    SimParamLong bits_drop=null;
    long totalbits=0;
    long curbits=0;
    long prev_sample=0;
  }

  private class AnimPacket implements java.io.Serializable {
    int checkpoint;
    int neighbor_index;
  }

  private SimParamDouble ln_speed;
  private SimParamDouble ln_distance;
  private SimParamDouble ln_prop_speed;
  private SimParamDouble ln_ai;
  private SimParamBool ln_fail;
  private SimParamDouble ln_fail_start;
  private SimParamDouble ln_fail_len;
  private SimParamInt ln_fail_repeat;
  private SimParamDouble ln_fail_delay;
  private SimParamBool ln_fail_random_len;
  private SimParamBool ln_fail_random_delay;
  private SimParamBool ln_fail_start_delay;
  private SimParamBool ln_fail_notify;
  private SimParamBool ln_name_seed;
  private SimParamBool ln_anim;
  private SimParamInt ln_checkpoint;
  private SimParamDouble ln_anim_delay;
  private SimParamInt ln_log_factor;
  private java.util.List link_neighbors;

  private transient Analyzer analyzer=null;

  private java.util.Random randgen;

  //linke failure
  private int fail_time=0;
  private boolean fail_state=false;

  //animation
  private transient boolean registered=false;
  private java.util.Map animPackets=null;
  private int last_id=0;

//animation constants
  private static final Color [] ANIM_NEIGHBOR_COL = { Color.red, Color.green };


//compInfo IDs:
  public static final int GET_CAPACITY = SimProvider.CI_PRIVATE + 1;
                                      //Ask for the link's capacity
                                      //Returns a Double as the bandwidth
                                      //  in Mbps
  public static final int GET_OTHER_END = SimProvider.CI_PRIVATE + 2;
                                      //Ask for the other end of the link
                                      //Parameter: this end (SimComponent)
                                      //Returns the other end (SimComponent)
                                      //Returns null if no other end or
                                      //  this end not correct
  private static final int LINK_ANIM = SimProvider.CI_PRIVATE + 3;
                                      //used for animation only, not public


//private events
  private static final int MY_READY = SimProvider.EV_PRIVATE + 1;
  private static final int EV_AVERAGING_INTERVAL = SimProvider.EV_PRIVATE + 2;
  private static final int MY_CHECK_POINT = SimProvider.EV_PRIVATE + 3;
  private static final int EV_DO_FAIL = SimProvider.EV_PRIVATE + 4;
  private static final int EV_END_FAIL = SimProvider.EV_PRIVATE + 5;

  public GenericLink(String aName,String aClass,Sim aSim,int locx,int locy) {
    super(aName,aClass,aSim,locx,locy);

    randgen=new java.util.Random();
    ln_create();
  }

  public boolean isConnectable(SimComponent comp) {
    if(!super.isConnectable(comp)) return false;

    if(neighborCount()>=2) return false;
    if(comp.getCompClass().equals("BTE") ||
        comp.getCompClass().equals("Switch") ||
        comp.getCompClass().equals("Router")) return true;
    return false;
  }

  protected void neighborAdded(SimComponent comp) {
    LinkNeighbor n=new LinkNeighbor();
    n.to_link=comp;
    n.c_rate=new SimParamDouble("Current Link rate (Mbps) to "+comp.getName(),this,
                              theSim.now(),true,false,0);
    n.c_rate.update(theSim.now());
    n.l_rate=new SimParamDouble("Session Link rate (Mbps) to "+comp.getName(),this,
                              theSim.now(),true,false,0);
    n.l_rate.update(theSim.now());
    n.packet_drop=new SimParamInt("Packets dropped to "+comp.getName(),this,
                                  theSim.now(),true,false,0);
    n.packet_drop.update(theSim.now());
    n.bits_drop=new SimParamLong("Bits dropped to "+comp.getName(),this,
                                  theSim.now(),true,false,0);
    n.bits_drop.update(theSim.now());
    n.totalbits=0;
    n.curbits=0;
    n.prev_sample=0;
    link_neighbors.add(n);
    addParameter(n.c_rate);
    addParameter(n.l_rate);
    addParameter(n.packet_drop);
    addParameter(n.bits_drop);
  }

  protected void neighborRemoved(SimComponent comp) {
    for(int i=0;i<link_neighbors.size();i++) {
      LinkNeighbor n=(LinkNeighbor)link_neighbors.get(i);
      if(n.to_link==comp) {
        removeParameter(n.c_rate);
        removeParameter(n.l_rate);
        removeParameter(n.packet_drop);
        removeParameter(n.bits_drop);
        link_neighbors.remove(i);
        break;
      }
    }
    if(registered) {
      theSim.unregisterAnimation(this,LINK_ANIM);
      registered=false;
    }
  }

  public void copy(SimComponent comp) {
    if(comp instanceof GenericLink) {
      GenericLink theComp=(GenericLink)comp;
      ln_speed.setValue(theComp.ln_speed.getValue());
      ln_distance.setValue(theComp.ln_distance.getValue());
      ln_prop_speed.setValue(theComp.ln_prop_speed.getValue());
      ln_ai.setValue(theComp.ln_ai.getValue());
      ln_fail.setValue(theComp.ln_fail.getValue());
      ln_fail_start.setValue(theComp.ln_fail_start.getValue());
      ln_fail_len.setValue(theComp.ln_fail_len.getValue());
      ln_fail_repeat.setValue(theComp.ln_fail_repeat.getValue());
      ln_fail_delay.setValue(theComp.ln_fail_delay.getValue());
      ln_fail_random_len.setValue(theComp.ln_fail_random_len.getValue());
      ln_fail_random_delay.setValue(theComp.ln_fail_random_delay.getValue());
      ln_fail_start_delay.setValue(theComp.ln_fail_start_delay.getValue());
      ln_fail_notify.setValue(theComp.ln_fail_notify.getValue());
      ln_name_seed.setValue(theComp.ln_name_seed.getValue());
      ln_anim.setValue(theComp.ln_anim.getValue());
      ln_checkpoint.setValue(theComp.ln_checkpoint.getValue());
      ln_anim_delay.setValue(theComp.ln_anim_delay.getValue());
      ln_log_factor.setValue(theComp.ln_log_factor.getValue());
    }
  }

  public java.awt.Image getImage(java.awt.Component refcomp) {
    if(image==null) {
      int [] blank = new int[Sim.DEFAULT_COMP_WIDTH*Sim.DEFAULT_COMP_HEIGHT];
      for(int i=0;i<blank.length;i++) blank[i]=0;
      image=refcomp.createImage(new
            java.awt.image.MemoryImageSource(Sim.DEFAULT_COMP_WIDTH,Sim.DEFAULT_COMP_HEIGHT,
                                              blank,0,Sim.DEFAULT_COMP_WIDTH));
    }
    return image;
  }

  public void reset() {
    if(analyzer!=null) analyzer.reset();

    for(int i=0;i<link_neighbors.size();i++) {
      LinkNeighbor n=(LinkNeighbor)link_neighbors.get(i);
      n.c_rate.setValue(0);
      n.c_rate.update(theSim.now());
      n.l_rate.setValue(0);
      n.l_rate.update(theSim.now());
      n.packet_drop.setValue(0);
      n.packet_drop.update(theSim.now());
      n.bits_drop.setValue(0);
      n.bits_drop.update(theSim.now());
      n.totalbits=0;
      n.curbits=0;
      n.prev_sample=0;
    }

    //link failure
    fail_time=0;
    fail_state=false;

    if(registered) {
      theSim.unregisterAnimation(this,LINK_ANIM);
      registered=false;
    }
    animPackets.clear();
  }

  public void start() {
    int i;

    if(ln_name_seed.getValue()==true)
      randgen.setSeed(getName().hashCode());

    for(i=0;i<randgen.nextInt(100);i++) randgen.nextDouble();

    theSim.enqueue(new SimEvent(EV_AVERAGING_INTERVAL,this,this,
                   theSim.now()+SimClock.USec2Tick(ln_ai.getValue()),null));

    //notify neighbors about link up
    for(i=0;i<neighborCount();i++) {
      theSim.enqueue(new SimEvent(SimProvider.EV_LINK_UP,this,neighbor(i),theSim.now(),null));
    }

    //check whether link failure is enabled
    if(ln_fail.getValue()==true && ln_fail_repeat.getValue()!=0) {
      long tick=SimClock.Sec2Tick(ln_fail_start.getValue());
      if(ln_fail_start_delay.getValue()==true)
        tick+=getFailDelay();
      theSim.enqueue(new SimEvent(EV_DO_FAIL,this,this,theSim.now()+tick,null));
    }

    if(ln_anim.getValue()==true && !registered) {
      theSim.registerAnimation(this,LINK_ANIM);
      registered=true;
    }
  }

  public void resume() {
    if(ln_anim.getValue()==true && !registered) {
      theSim.registerAnimation(this,LINK_ANIM);
      registered=true;
    }
  }

  public void action(SimEvent e) {
    switch(e.getType()) {
      case SimProvider.EV_RECEIVE:
        ln_receive(e);
        break;
      case MY_READY:
        ln_ready(e);
        break;
      case EV_AVERAGING_INTERVAL:
        ln_averaging_interval();
        theSim.enqueue(new SimEvent(EV_AVERAGING_INTERVAL,this,this,
                       theSim.now()+SimClock.USec2Tick(ln_ai.getValue()),null));
        break;
      case EV_DO_FAIL:
        ln_do_fail();
        break;
      case EV_END_FAIL:
        ln_end_fail();
        break;
      case MY_CHECK_POINT:
        Object [] paramlist=(Object [])e.getParams();
        if(((Long)paramlist[0]).longValue()>System.currentTimeMillis()) {