es.tid.pce.client.multiLayer.AutomaticTesterMLNetworkRandomTask Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of network-emulator Show documentation
Emulator of GMPLS-controlled transport Network
The newest version!
package es.tid.pce.client.multiLayer;

import java.io.BufferedWriter;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Inet4Address;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Timer;
import java.util.TimerTask;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import cern.jet.random.Exponential;
import cern.jet.random.engine.MersenneTwister;
import es.tid.emulator.node.transport.EmulatedPCCPCEPSession;
import es.tid.pce.client.ClientRequestManager;
import es.tid.pce.client.emulator.AutomaticTesterStatistics;
import es.tid.pce.pcep.PCEPProtocolViolationException;
import es.tid.pce.pcep.constructs.Path;
import es.tid.pce.pcep.constructs.Request;
import es.tid.pce.pcep.messages.PCEPRequest;
import es.tid.pce.pcep.messages.PCEPResponse;
import es.tid.pce.pcep.messages.PCEPTELinkSuggestion;
import es.tid.pce.pcep.objects.EndPointsIPv4;
import es.tid.pce.pcep.objects.ExplicitRouteObject;
import es.tid.pce.pcep.objects.RequestParameters;
import es.tid.rsvp.objects.subobjects.EROSubobject;
import es.tid.rsvp.objects.subobjects.IPv4prefixEROSubobject;
import es.tid.rsvp.objects.subobjects.SubObjectValues;

public class AutomaticTesterMLNetworkRandomTask  extends TimerTask {
	private static int counter=0;
	private ClientRequestManager crm;
	private Logger log;
	static long requestID=123;
	private EmulatedPCCPCEPSession psVNTM;
	/*Variable used for counter how many requests there are*/
	private Timer timer;
	PCEPRequest request;
	Exponential expSendRequest;
	Exponential connectionTime;
	
	private AutomaticTesterStatistics stats;
	private Timer planificationTimer;
	PrintWriter pw;
	PrintWriter apw;
	MersenneTwister mt;
	
	public AutomaticTesterMLNetworkRandomTask(Exponential expSendRequest,Exponential connectionTime, Timer timer,Timer planificationTimer,ClientRequestManager crm,EmulatedPCCPCEPSession psVNTM,AutomaticTesterStatistics stats,PrintWriter pw, PrintWriter apw,MersenneTwister mt ){
		this.mt=mt;
		log=LoggerFactory.getLogger("PCCClient");
		this.crm=crm;
		this.psVNTM=psVNTM;
		this.expSendRequest=expSendRequest;
		this.connectionTime = connectionTime;
		this.timer=timer;
		this.stats=stats;
		this.planificationTimer=planificationTimer;
		this.pw=pw;
		this.apw=apw;
		
		this.request = createRequestMessage();
	}
	

	
	@Override
	public void run() {
    
		//First, we schedule the next request
		double timeNextReqD=expSendRequest.nextDouble(); 
		long timeNextReq =(long)timeNextReqD;
		AutomaticTesterMLNetworkRandomTask exponentialTester = new AutomaticTesterMLNetworkRandomTask(expSendRequest,connectionTime,timer,planificationTimer, crm, psVNTM,stats,pw,apw,mt);
		log.info("Scheduling next request in "+timeNextReq+" MS ("+timeNextReqD+" )");
		timer.schedule(exponentialTester,timeNextReq);
		//Measure initial time
		long timeIni=System.nanoTime();
		PCEPResponse pr;
		
		request.getRequestList().getFirst().getRequestParameters().setRequestID(requestID);
		requestID=requestID+1;
		//Count one request
		stats.addRequest();
		//FIXME: COGER POSIBLES FALLOS EN EL REQUEST
		pr=crm.newRequest(this.request);
		long timeIni2=System.nanoTime();
		log.info("Response "+pr.toString());
		double reqTime_ms=(timeIni2-timeIni)/1000000;
		double reqTime_us=(timeIni2-timeIni)/1000;
		stats.analyzeReqTime(reqTime_us);
		log.info("Request Time "+reqTime_us+" us");
		String strPrev=null;
		if (pr.getResponseList().isEmpty()){
			log.error("ERROR in response");
			//FIXME: QUE HACEMOS? CANCELAMOS SIMULACION?
			//stats.addNoPathResponse();
			System.exit(1);
			return;
		}else {
			if (pr.getResponseList().get(0).getNoPath()!=null){
				log.info("NO PATH");
				stats.addNoPathResponse();
				stats.analyzeBlockingProbability(1);
				return;	
			}else {
				Path path=pr.getResponseList().get(0).getPath(0);
				ExplicitRouteObject ero=path.geteRO();
				LinkedList eroSubObjList=ero.getEROSubobjectList();
				boolean layerInfoFound=false;
				int numNewLinks=0;
				ArrayList sourceList = new ArrayList();
				ArrayList destinationList = new ArrayList();
				//cREAR LISTA DE EROS
				LinkedList eroList=new LinkedList();
				LinkedList eroSubObjList2=null;
				int counterArray=0;
				for (int i=0;i0){
					stats.addMLResponse();
				}else {
					stats.addSLResponse();
				}
				stats.analyzeBlockingProbability(0);
				for (int i=0;i=num_origen){
	   num_destino=num_destino+1;
	  }
	  String source_s =new String();
	  
	  source_s=base+ String.valueOf(num_origen)+"0";
	  String destiny_s = new String();
	  destiny_s=base+String.valueOf(num_destino)+"0";
	  System.out.println("source_s "+source_s);
	  System.out.println("destiny "+destiny_s);
	  Inet4Address src_ip=null;
	  Inet4Address dst_ip=null;
	try {
		src_ip = (Inet4Address) Inet4Address.getByName(source_s);
		dst_ip=(Inet4Address) Inet4Address.getByName(destiny_s);
	} catch (UnknownHostException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	
	 Request req = createRequest(src_ip,dst_ip);		
	//ObjectiveFunction of=new ObjectiveFunction();
	//of.setOFcode(algorithmRuleList.get(0).ar.of);
	//req.setObjectiveFunction(of);
	//p_r.setMonitoring(monitoring);
	//p_r.setPccReqId(pccReqId);
	p_r.addRequest(req);
	return p_r;
}


/**
 * Create a request object
 * @param src_ip
 * @param dst_ip
 * @return
 */
Request createRequest(Inet4Address src_ip, Inet4Address dst_ip){
	Request req = new Request();
	RequestParameters rp= new RequestParameters();
	rp.setPbit(true);
	req.setRequestParameters(rp);		
	rp.setRequestID(EmulatedPCCPCEPSession.getNewReqIDCounter());
	System.out.println("Creating test Request");
	
	int prio = 1;
	rp.setPrio(prio);
	boolean reo = false;
	rp.setReopt(reo);
	boolean bi = false;
	rp.setBidirect(bi);
	boolean lo = false;
	rp.setLoose(lo);
	EndPointsIPv4 ep=new EndPointsIPv4();				
	req.setEndPoints(ep);
	ep.setSourceIP(src_ip);	
	ep.setDestIP(dst_ip);
	
	return req;
}
}