All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • es.tid.bgp.bgp4Peer.updateTEDB.UpdateProccesorThread Maven / Gradle / Ivy

    The newest version!
    package es.tid.bgp.bgp4Peer.updateTEDB;

import es.tid.bgp.bgp4.messages.BGP4Update;
import es.tid.bgp.bgp4.update.fields.*;
import es.tid.bgp.bgp4.update.fields.pathAttributes.*;
import es.tid.bgp.bgp4.update.tlv.linkstate_attribute_tlvs.*;
import es.tid.bgp.bgp4.update.tlv.node_link_prefix_descriptor_subTLVs.*;
import es.tid.ospf.ospfv2.lsa.tlv.subtlv.*;
import es.tid.ospf.ospfv2.lsa.tlv.subtlv.complexFields.BitmapLabelSet;
import es.tid.tedb.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.concurrent.LinkedBlockingQueue;
/**
 * This class process the update messages updating the TEDB.
 * 
 *  WARNING: it is suppose to be a SimpleTEDB!!! It is not finished yet.
 * @author pac
 *
 */
public class UpdateProccesorThread extends Thread {
	/**
	 * Parameter to run the class if it is true
	 */
	private boolean running;
	/**
	 * Queue which stores the BGP4 update messages to be read and process
	 */
	private LinkedBlockingQueue updateList;

	/** LINK ATTRIBUTE TLVs */
	MaximumLinkBandwidthLinkAttribTLV maximumLinkBandwidthTLV;
	MaxReservableBandwidthLinkAttribTLV maxReservableBandwidthTLV;
	UnreservedBandwidthLinkAttribTLV unreservedBandwidthTLV;
	AdministrativeGroupLinkAttribTLV administrativeGroupTLV;
	LinkProtectionTypeLinkAttribTLV linkProtectionTLV;
	MetricLinkAttribTLV metricTLV;
	IPv4RouterIDLocalNodeLinkAttribTLV iPv4RouterIDLocalNodeLATLV;
	IPv4RouterIDRemoteNodeLinkAttribTLV iPv4RouterIDRemoteNodeLATLV;
	DefaultTEMetricLinkAttribTLV TEMetricTLV;	
	TransceiverClassAndAppAttribTLV transceiverClassAndAppATLV;
	MF_OTPAttribTLV mF_OTP_ATLV;
	int linkDelay;
	int linkDelayVar;
	int minDelay;
	int maxDelay;
	int linkLoss;
	int residualBw;
	int availableBw;
	int utilizedBw;
	/** NODE ATTRIBUTE TLVs 
	 * Ipv4 of local node link attribute TLV also used
	 * 
	 * */
	NodeFlagBitsNodeAttribTLV nodeFlagBitsTLV = new NodeFlagBitsNodeAttribTLV();
	NodeNameNodeAttribTLV nodeNameTLV = new NodeNameNodeAttribTLV();
	IS_IS_AreaIdentifierNodeAttribTLV areaIDTLV = new IS_IS_AreaIdentifierNodeAttribTLV();
	SidLabelNodeAttribTLV sidTLV = new SidLabelNodeAttribTLV();

	/**PREFIX ATTRIBUTE TLVs */
	IGPFlagBitsPrefixAttribTLV igpFlagBitsTLV = new IGPFlagBitsPrefixAttribTLV();
	RouteTagPrefixAttribTLV routeTagTLV = new RouteTagPrefixAttribTLV();
	PrefixMetricPrefixAttribTLV prefixMetricTLV = new PrefixMetricPrefixAttribTLV();
	OSPFForwardingAddressPrefixAttribTLV OSPFForwardingAddrTLV = new OSPFForwardingAddressPrefixAttribTLV();

	private AvailableLabels availableLabels;
	/**
	 * Logger
	 */
	private Logger log;
	/**
	 * Topology database for interDomain Links which will be updated.
	 */
	private MultiDomainTEDB multiTedb;
	/**
	 * Topology database for intradomain Links. It owns several domains and.
	 */
	private Hashtable intraTEDBs;

	private LinkedList updateLinks;

	private TE_Information te_info;




	public UpdateProccesorThread(LinkedBlockingQueue updateList,
			MultiDomainTEDB multiTedb ,Hashtable intraTEDBs ){
		log=LoggerFactory.getLogger("BGP4Server");
		running=true;
		this.updateList=updateList;
		this.multiTedb = multiTedb;

		this.intraTEDBs=intraTEDBs;
		this.availableLabels= new AvailableLabels();
		this.updateLinks=new LinkedList();
	}

	/**
	 * Starts processing updates
	 */
	public void run(){	
		BGP4Update updateMsg;
		while (running) {
			try {
				clearAttributes();
				PathAttribute att_ls = null;
				PathAttribute att_mpreach  = null; 
				PathAttribute att = null;
				updateMsg= updateList.take();
				log.debug("Update Procesor Thread Reading the message: \n"+ updateMsg.toString());
				//Andrea To be checked
				String learntFrom = updateMsg.getLearntFrom();
				log.debug("Received from "+learntFrom);
				ArrayList pathAttributeList = updateMsg.getPathAttributes();
				ArrayList pathAttributeListUtil = new ArrayList();			

				// buscamos los dos atributos que nos interesan...
				for (int i=0;i nodeDescriptorsSubTLV;
		//Dominios
		Inet4Address localDomainID= null ;
		Inet4Address remoteDomainID = null ;

		Inet4Address areaID= null ;
		Inet4Address bgplsID = null;

		Inet4Address LocalNodeIGPId = null;
		Inet4Address RemoteNodeIGPId = null;

		//Local Node descriptors 
		if (linkNLRI.getLocalNodeDescriptors().getAutonomousSystemSubTLV()!=null){
			localDomainID=linkNLRI.getLocalNodeDescriptors().getAutonomousSystemSubTLV().getAS_ID();
		}
		if (linkNLRI.getLocalNodeDescriptors().getAreaID()!=null) {
			areaID=linkNLRI.getLocalNodeDescriptors().getAreaID().getAREA_ID();
		}
		if (linkNLRI.getLocalNodeDescriptors().getBGPLSIDSubTLV()!=null) {
			bgplsID=linkNLRI.getLocalNodeDescriptors().getBGPLSIDSubTLV().getBGPLS_ID();
		}
		if (linkNLRI.getLocalNodeDescriptors().getIGPRouterID()!=null){
			LocalNodeIGPId=linkNLRI.getLocalNodeDescriptors().getIGPRouterID().getIpv4AddressOSPF();
		}

		if (linkNLRI.getRemoteNodeDescriptorsTLV().getAutonomousSystemSubTLV()!=null) {
			remoteDomainID=linkNLRI.getRemoteNodeDescriptorsTLV().getAutonomousSystemSubTLV().getAS_ID();
		}
		if (linkNLRI.getRemoteNodeDescriptorsTLV().getAreaID()!=null) {
			areaID =linkNLRI.getRemoteNodeDescriptorsTLV().getAreaID().getAREA_ID();
		}
		if (linkNLRI.getRemoteNodeDescriptorsTLV().getBGPLSIDSubTLV()!=null) {
			bgplsID=linkNLRI.getRemoteNodeDescriptorsTLV().getBGPLSIDSubTLV().getBGPLS_ID();
		}
		if (linkNLRI.getRemoteNodeDescriptorsTLV().getIGPRouterID()!=null) {
			RemoteNodeIGPId = linkNLRI.getRemoteNodeDescriptorsTLV().getIGPRouterID().getIpv4AddressOSPF();
		}
		if(linkNLRI.getUndirectionalLinkDelayTLV()!=null){
			linkDelay = linkNLRI.getUndirectionalLinkDelayTLV().getDelay();
		}
		if(linkNLRI.getUndirectionalDelayVariationTLV()!=null){
			linkDelayVar = linkNLRI.getUndirectionalDelayVariationTLV().getDelayVar();
		}
		if(linkNLRI.getMinMaxUndirectionalLinkDelayTLV()!=null){
			maxDelay = linkNLRI.getMinMaxUndirectionalLinkDelayTLV().getHighDelay();
			minDelay = linkNLRI.getMinMaxUndirectionalLinkDelayTLV().getLowDelay();
		}
		if(linkNLRI.getUndirectionalLinkLossTLV()!=null){
			linkLoss = linkNLRI.getUndirectionalLinkLossTLV().getLinkLoss();
		}
		if(linkNLRI.getUndirectionalResidualBwTLV()!=null){
			residualBw = linkNLRI.getUndirectionalResidualBwTLV().getResidualBw();
		}
		if(linkNLRI.getUndirectionalAvailableBwTLV()!=null){
			availableBw = linkNLRI.getUndirectionalAvailableBwTLV().getAvailableBw();
		}
		if(linkNLRI.getUndirectionalUtilizedBwTLV()!=null){
			utilizedBw = linkNLRI.getUndirectionalUtilizedBwTLV().getUtilizedBw();
		}
		/**Creamos el grafo*/
		//Let's see if our link is intradomain or interdomain...
		//log.info("as_local "+localDomainID);
		//log.info("as_remote "+remoteDomainID);

		if(localDomainID.equals(remoteDomainID)){
			log.debug("INTRADOMAIN...for domain"+localDomainID.getCanonicalHostName());
			IntraDomainEdge intraEdge = new IntraDomainEdge();

			if (linkNLRI.getLinkIdentifiersTLV() != null){				
				intraEdge.setSrc_if_id(linkNLRI.getLinkIdentifiersTLV().getLinkLocalIdentifier());
				intraEdge.setDst_if_id(linkNLRI.getLinkIdentifiersTLV().getLinkRemoteIdentifier());						
			}
			/*
			Enumeration el2 = intraTEDBs.keys();
			while (el2.hasMoreElements()) {
				String key = (String) el2.nextElement();
				log.info("Intra-after.....the key is: "+key);
			}
			*/

			DomainTEDB domainTEDB=(DomainTEDB)intraTEDBs.get(localDomainID.getHostAddress());
			SimpleTEDB simpleTEDBxx=null;
			if (domainTEDB instanceof SimpleTEDB){
				simpleTEDBxx = (SimpleTEDB) domainTEDB;
			}else if (domainTEDB==null){
				simpleTEDBxx = new SimpleTEDB();
				simpleTEDBxx.createGraph();
				simpleTEDBxx.setDomainID(localDomainID);
				this.intraTEDBs.put(localDomainID.getHostAddress(), simpleTEDBxx);
			}else {
				log.error("PROBLEM: TEDB not compatible");
				return;
			}


			/**Actualizando TED*/

			if (!(simpleTEDBxx.getNetworkGraph().containsVertex(LocalNodeIGPId))){
				//log.info("Not containing source vertex");
				simpleTEDBxx.getNetworkGraph().addVertex(LocalNodeIGPId);//add vertex ya comprueba si existe el nodo en la ted-->se puede hacer mas limpio
				simpleTEDBxx.notifyNewVertex(LocalNodeIGPId);
			}
			//			else{ 
			//				log.info("Local Vertex: "+LocalNodeIGPId.toString() +" already present in TED...");
			//			}

			if (!(simpleTEDBxx.getNetworkGraph().containsVertex(RemoteNodeIGPId))){
				//log.info("Not containing dst vertex");
				simpleTEDBxx.getNetworkGraph().addVertex(RemoteNodeIGPId);
				simpleTEDBxx.notifyNewVertex(RemoteNodeIGPId);

			}
			//			else {
			//				log.info("Remote Vertex: "+RemoteNodeIGPId.toString() +" already present in TED...");
			//			}

			te_info =  createTE_Info(simpleTEDBxx);
			intraEdge.setTE_info(te_info);
			intraEdge.setLearntFrom(learntFrom);

			if (!(simpleTEDBxx.getNetworkGraph().containsEdge(LocalNodeIGPId, RemoteNodeIGPId))){
				//log.info("Graph does not contain intra-edge");

				log.debug("Adding information of local node to edge..." + simpleTEDBxx.getNodeTable().get(LocalNodeIGPId));
				intraEdge.setLocal_Node_Info(simpleTEDBxx.getNodeTable().get(LocalNodeIGPId));
				log.debug("Adding information of remote node to edge..." + simpleTEDBxx.getNodeTable().get(RemoteNodeIGPId));
				intraEdge.setRemote_Node_Info(simpleTEDBxx.getNodeTable().get(RemoteNodeIGPId));
				log.debug("Adding edge from origin vertex"+LocalNodeIGPId.toString()+ " to destination vertex" +RemoteNodeIGPId.toString());
				
				simpleTEDBxx.getNetworkGraph().addEdge(LocalNodeIGPId, RemoteNodeIGPId, intraEdge);
				simpleTEDBxx.notifyNewEdge(LocalNodeIGPId, RemoteNodeIGPId);
				
				simpleTEDBxx.getNetworkGraph().getEdge(LocalNodeIGPId, RemoteNodeIGPId).setNumberFibers(1);
				IntraDomainEdge edge=simpleTEDBxx.getNetworkGraph().getEdge(LocalNodeIGPId, RemoteNodeIGPId);
				if(intraEdge.getTE_info().getAvailableLabels()!=null)
					((BitmapLabelSet)edge.getTE_info().getAvailableLabels().getLabelSet()).initializeReservation(((BitmapLabelSet)intraEdge.getTE_info().getAvailableLabels().getLabelSet()).getBytesBitMap());

			}
			else{
				//log.info("Graph contains intra-edge");

				IntraDomainEdge edge;
				edge=simpleTEDBxx.getNetworkGraph().getEdge(LocalNodeIGPId, RemoteNodeIGPId);
				if (this.availableLabels!=null){
					if(((BitmapLabelSet)this.availableLabels.getLabelSet()).getDwdmWavelengthLabel()!=null){
						((BitmapLabelSet)edge.getTE_info().getAvailableLabels().getLabelSet()).arraycopyBytesBitMap(((BitmapLabelSet)intraEdge.getTE_info().getAvailableLabels().getLabelSet()).getBytesBitMap());

						if (((BitmapLabelSet)intraEdge.getTE_info().getAvailableLabels().getLabelSet()).getBytesBitmapReserved()!=null){
							((BitmapLabelSet)edge.getTE_info().getAvailableLabels().getLabelSet()).arraycopyReservedBytesBitMap(((BitmapLabelSet)intraEdge.getTE_info().getAvailableLabels().getLabelSet()).getBytesBitmapReserved());

						}
					}
				}
			}
			/*
			Enumeration el3 = intraTEDBs.keys();
			while (el3.hasMoreElements()) {
				String key = (String) el3.nextElement();
				log.info("Intra-before.....the key is: "+key);
			}
			*/
		}

		else{
			log.debug("INTERDOMAIN...");
			InterDomainEdge interEdge = new InterDomainEdge();
			if (linkNLRI.getLinkIdentifiersTLV() != null){				
				interEdge.setSrc_if_id(linkNLRI.getLinkIdentifiersTLV().getLinkLocalIdentifier());
				interEdge.setDst_if_id(linkNLRI.getLinkIdentifiersTLV().getLinkRemoteIdentifier());						
			}
			//terminamos de caracterizar el interedge...
			interEdge.setSrc_router_id(LocalNodeIGPId);
			interEdge.setDst_router_id(RemoteNodeIGPId);

			interEdge.setDomain_dst_router(remoteDomainID);

			interEdge.setDomain_src_router(localDomainID);

			//check soyrce domain
			DomainTEDB domain= (DomainTEDB)intraTEDBs.get(localDomainID.getHostAddress());
			SimpleTEDB simpleTEDBs=null;
			if (domain instanceof SimpleTEDB){
				//log.info("is instance sssss");
				simpleTEDBs = (SimpleTEDB) domain;
			}else if (domain==null){
				//log.info("nullssss");
				simpleTEDBs = new SimpleTEDB();
				simpleTEDBs.createGraph();
				simpleTEDBs.setDomainID(localDomainID);
				this.intraTEDBs.put(localDomainID.getHostAddress(), simpleTEDBs);
			}
			else {
				log.error("PROBLEM: TEDB not compatible");
				return;
			}


			//check soyrce domain
			DomainTEDB domaind= (DomainTEDB)intraTEDBs.get(remoteDomainID.getHostAddress());
			SimpleTEDB simpleTEDBd=null;
			if (domaind instanceof SimpleTEDB){
				//log.info("is instancedddddd");
				simpleTEDBd = (SimpleTEDB) domaind;
			}else if (domaind==null){
				//log.info("nulldddd");
				simpleTEDBd = new SimpleTEDB();
				simpleTEDBd.createGraph();
				simpleTEDBd.setDomainID(remoteDomainID);
				this.intraTEDBs.put(remoteDomainID.getHostAddress(), simpleTEDBd);

			}else {
				log.error("PROBLEM: TEDB not compatible");
				return;
			}




			/**Actualizando TED*/
			//log.info("Updating Interdomain list...");
			//FIXME: See what to do to create SSON Info
			DomainTEDB simpleTEDB=new SimpleTEDB();
			te_info =  createTE_Info(simpleTEDB);
			interEdge.setTE_info(te_info);
			interEdge.setLearntFrom(learntFrom);

			//FIXME: ADD I-D links to the Simple TEDBs
			/**	
			if(simpleTEDB.getInterdomainLink(LocalNodeIGPId, RemoteNodeIGPId) == null){
				simpleTEDB.getInterDomainLinks().add(interEdge);
				InterDomainEdge edge = simpleTEDB.getInterdomainLink(LocalNodeIGPId, RemoteNodeIGPId);
				((BitmapLabelSet)edge.getTE_info().getAvailableLabels().getLabelSet()).initializeReservation(((BitmapLabelSet)interEdge.getTE_info().getAvailableLabels().getLabelSet()).getBytesBitMap());
			}
			 */

			multiTedb.addInterdomainLink(localDomainID, LocalNodeIGPId, linkNLRI.getLinkIdentifiersTLV().getLinkLocalIdentifier(), remoteDomainID, RemoteNodeIGPId, linkNLRI.getLinkIdentifiersTLV().getLinkRemoteIdentifier(), te_info);


		}
	} 

	private TE_Information createTE_Info(DomainTEDB domainTEDB){
		TE_Information te_info = new TE_Information();
		if(linkDelay>0){
			UndirectionalLinkDelayDescriptorSubTLV uSTLV = new UndirectionalLinkDelayDescriptorSubTLV();
			uSTLV.setDelay(linkDelay);
			te_info.setUndirLinkDelay(uSTLV);
		}
		if(linkDelayVar>0){
			UndirectionalDelayVariationDescriptorSubTLV uSTLV = new UndirectionalDelayVariationDescriptorSubTLV();
			uSTLV.setDelayVar(linkDelayVar);
			te_info.setUndirDelayVar(uSTLV);
		}
		if(minDelay>0 && maxDelay>0){
			MinMaxUndirectionalLinkDelayDescriptorSubTLV uSTLV = new MinMaxUndirectionalLinkDelayDescriptorSubTLV();
			uSTLV.setHighDelay(maxDelay);
			uSTLV.setLowDelay(minDelay);
			te_info.setMinMaxUndirLinkDelay(uSTLV);
		}
		if(linkLoss>0){
			UndirectionalLinkLossDescriptorSubTLV uSTLV = new UndirectionalLinkLossDescriptorSubTLV();
			uSTLV.setLinkLoss(linkLoss);
			te_info.setUndirLinkLoss(uSTLV);
		}
		if(residualBw>0){
			UndirectionalResidualBandwidthDescriptorSubTLV uSTLV = new UndirectionalResidualBandwidthDescriptorSubTLV();
			uSTLV.setResidualBw(residualBw);
			te_info.setUndirResidualBw(uSTLV);
		}
		if(availableBw>0){
			UndirectionalAvailableBandwidthDescriptorSubTLV uSTLV = new UndirectionalAvailableBandwidthDescriptorSubTLV();
			uSTLV.setAvailableBw(availableBw);
			te_info.setUndirAvailableBw(uSTLV);
		}
		if(utilizedBw>0){
			UndirectionalUtilizedBandwidthDescriptorSubTLV uSTLV = new UndirectionalUtilizedBandwidthDescriptorSubTLV();
			uSTLV.setUtilizedBw(utilizedBw);
			te_info.setUndirUtilizedBw(uSTLV);
		}
		if (maximumLinkBandwidthTLV!=null){
			MaximumBandwidth maximumBandwidth = new MaximumBandwidth();
			maximumBandwidth.setMaximumBandwidth(maximumLinkBandwidthTLV.getMaximumBandwidth());
			te_info.setMaximumBandwidth(maximumBandwidth);
		}
		if (maxReservableBandwidthTLV!=null){
			MaximumReservableBandwidth maximumReservableBandwidth = new MaximumReservableBandwidth();
			maximumReservableBandwidth.setMaximumReservableBandwidth(maxReservableBandwidthTLV.getMaximumReservableBandwidth());
			te_info.setMaximumReservableBandwidth(maximumReservableBandwidth);
		}
		if (unreservedBandwidthTLV!=null){
			UnreservedBandwidth unreservedBandwidth = new UnreservedBandwidth();
			unreservedBandwidth.setUnreservedBandwidth(unreservedBandwidthTLV.getUnreservedBandwidth());
			te_info.setUnreservedBandwidth(unreservedBandwidth);
		}
		if(iPv4RouterIDLocalNodeLATLV!=null){
			IPv4RouterIDLocalNodeLinkAttribTLV iPv4RouterIDLocalNode = new IPv4RouterIDLocalNodeLinkAttribTLV();
			iPv4RouterIDLocalNode.setIpv4Address(iPv4RouterIDLocalNodeLATLV.getIpv4Address());
			te_info.setiPv4LocalNode(iPv4RouterIDLocalNode);
		}
		if(iPv4RouterIDRemoteNodeLATLV!=null){
			IPv4RouterIDRemoteNodeLinkAttribTLV iPv4RouterIDRemoteNode = new IPv4RouterIDRemoteNodeLinkAttribTLV();
			iPv4RouterIDRemoteNode.setIpv4Address(iPv4RouterIDRemoteNodeLATLV.getIpv4Address());
			te_info.setiPv4RemoteNode(iPv4RouterIDRemoteNode);
		}
		if(metricTLV!=null){
			MetricLinkAttribTLV metric = new MetricLinkAttribTLV();
			metric.setMetric(metricTLV.getMetric());
			te_info.setMetric(metric);
		}
		if(TEMetricTLV!=null){
			TrafficEngineeringMetric teMetric = new TrafficEngineeringMetric();
			teMetric.setLinkMetric((long)TEMetricTLV.getLinkMetric());
			te_info.setTrafficEngineeringMetric(teMetric);
		}
		if(administrativeGroupTLV!=null){
			AdministrativeGroup adminGroup = new AdministrativeGroup();
			adminGroup.setAdministrativeGroup(administrativeGroupTLV.getAdministrativeGroup());
			te_info.setAdministrativeGroup(adminGroup);
		}
		if(linkProtectionTLV!=null){
			LinkProtectionTypeLinkAttribTLV linkProtection = new LinkProtectionTypeLinkAttribTLV();
			linkProtection.setProtection_type(linkProtectionTLV.getProtection_type());
			te_info.setLinkProtectionBGPLS(linkProtection);
		}
		if(this.mF_OTP_ATLV!=null){
			MF_OTPAttribTLV mF_OTP_ATLV = this.mF_OTP_ATLV.duplicate();
			te_info.setMfOTF(mF_OTP_ATLV);
		}

		if(this.transceiverClassAndAppATLV!=null){
			TransceiverClassAndAppAttribTLV tap = new TransceiverClassAndAppAttribTLV();
			tap.setTrans_class(transceiverClassAndAppATLV.getTrans_class());
			tap.setTrans_app_code(transceiverClassAndAppATLV.getTrans_app_code());	
			te_info.setTrans(tap);
		}

		if (availableLabels!= null){
			if(((BitmapLabelSet)this.availableLabels.getLabelSet()).getDwdmWavelengthLabel()!=null){
				if(domainTEDB.getSSONinfo()==null){
					log.debug("NEW SSON INFO");
					SSONInformation ssonInfo = new SSONInformation();
					ssonInfo.setCs(((BitmapLabelSet)this.availableLabels.getLabelSet()).getDwdmWavelengthLabel().getChannelSpacing());
					ssonInfo.setGrid(((BitmapLabelSet)this.availableLabels.getLabelSet()).getDwdmWavelengthLabel().getGrid());
					ssonInfo.setNumLambdas(((BitmapLabelSet)this.availableLabels.getLabelSet()).getNumLabels());
					ssonInfo.setCommonAvailableLabels(this.availableLabels.dublicate());
					ssonInfo.setnMin(0);
					domainTEDB.setSSONinfo(ssonInfo);
				}
				if(domainTEDB.getWSONinfo()==null){
					log.debug("NEW WSON INFO");
					WSONInformation wsonInfo = new WSONInformation();
					wsonInfo.setCs(((BitmapLabelSet)this.availableLabels.getLabelSet()).getDwdmWavelengthLabel().getChannelSpacing());
					wsonInfo.setGrid(((BitmapLabelSet)this.availableLabels.getLabelSet()).getDwdmWavelengthLabel().getGrid());
					wsonInfo.setNumLambdas(((BitmapLabelSet)this.availableLabels.getLabelSet()).getNumLabels());
					wsonInfo.setCommonAvailableLabels(this.availableLabels.dublicate());
					wsonInfo.setnMin(0);
					domainTEDB.setWSONinfo(wsonInfo);
				}
			}
			te_info.setAvailableLabels(availableLabels.dublicate());
		}


		return te_info;
	}
	

	private void fillITNodeInformation(ITNodeNLRI itNodeNLRI, String learntFrom){
/*		try {
			Thread.sleep(2000);                 //1000 milliseconds is one second.
		} catch(InterruptedException ex) {
			Thread.currentThread().interrupt();
		}
	*/	DomainTEDB domainTEDB= null;

		domainTEDB=(DomainTEDB)intraTEDBs.get(itNodeNLRI.getNodeId());
		SimpleTEDB simpleTEDB=null;
		if (domainTEDB instanceof SimpleTEDB){
			simpleTEDB = (SimpleTEDB) domainTEDB;
		}else if (domainTEDB==null){
			simpleTEDB = new SimpleTEDB();
			simpleTEDB.createGraph();


			try {
				simpleTEDB.setDomainID((Inet4Address) InetAddress.getByName(itNodeNLRI.getNodeId()));
			} catch (UnknownHostException e) {
				e.printStackTrace();
			}
			this.intraTEDBs.put(itNodeNLRI.getNodeId(), simpleTEDB);

		}
		else {
			log.error("PROBLEM: TEDB not compatible");
			return;
		}

		log.info("Received IT info for domain "+itNodeNLRI.getNodeId()+" from peer "+learntFrom);
		IT_Resources itResources = new IT_Resources();
		itResources.setControllerIT(itNodeNLRI.getControllerIT());
		itResources.setCpu(itNodeNLRI.getCpu());
		itResources.setMem(itNodeNLRI.getMem());
		itResources.setStorage(itNodeNLRI.getStorage());
		itResources.setLearntFrom(learntFrom);
		itResources.setITdomainID(itNodeNLRI.getNodeId());

		simpleTEDB.setItResources(itResources);




	}

	private void fillNodeInformation(NodeNLRI nodeNLRI, String learntFrom){

		Inet4Address as_number = null;
		Inet4Address areaID= null ;
		Inet4Address bgplsID = null;
		int IGP_type = 0;
		Inet4Address IGPID = null;
		Node_Info node_info = new Node_Info();
		Hashtable NodeTable;
		if (nodeNLRI.getLocalNodeDescriptors().getAutonomousSystemSubTLV()!=null){
			as_number=nodeNLRI.getLocalNodeDescriptors().getAutonomousSystemSubTLV().getAS_ID();
			node_info.setAs_number(as_number);
		}
		if (nodeNLRI.getLocalNodeDescriptors().getAreaID()!=null){
			areaID=nodeNLRI.getLocalNodeDescriptors().getAreaID().getAREA_ID();
		}
		if (nodeNLRI.getLocalNodeDescriptors().getBGPLSIDSubTLV()!=null){
			bgplsID=nodeNLRI.getLocalNodeDescriptors().getBGPLSIDSubTLV().getBGPLS_ID();
		}
		if (nodeNLRI.getLocalNodeDescriptors().getIGPRouterID()!=null){
			IGP_type=nodeNLRI.getLocalNodeDescriptors().getIGPRouterID().getIGP_router_id_type();
			switch(IGP_type){
			case 3:
				IGPID = nodeNLRI.getLocalNodeDescriptors().getIGPRouterID().getIpv4AddressOSPF();

				node_info.setIpv4Address(IGPID);
				break;
			default:
				log.info("añadir este tipo de IGP Identifier por implementar ");
			}
		}


		if(iPv4RouterIDLocalNodeLATLV != null){
			log.debug("adding ipv4 of local node to table......");
			node_info.setIpv4AddressLocalNode(iPv4RouterIDLocalNodeLATLV.getIpv4Address());
		}
		if(nodeFlagBitsTLV!= null){
			log.debug("adding flags of local node to table...");
			node_info.setAbr_bit(nodeFlagBitsTLV.isAbr_bit());
			node_info.setAttached_bit(nodeFlagBitsTLV.isAttached_bit());
			node_info.setExternal_bit(nodeFlagBitsTLV.isExternal_bit());
			node_info.setOverload_bit(nodeFlagBitsTLV.isOverload_bit());
		}

		if(nodeNameTLV != null){
			log.debug("adding name of local node to table....");
			node_info.setName(nodeNameTLV.getName());
		}

		if(areaIDTLV != null){
			log.debug("adding areaID of local node to table....");
			node_info.setIpv4areaIDs(areaIDTLV.getIpv4areaIDs());
		}

		if(sidTLV != null){
			log.debug("adding SID of local node to table....");
			node_info.setSID(sidTLV.getSid());
		}
		//.... finally we set the 'learnt from' attribute
		node_info.setLearntFrom(learntFrom);
		log.debug("learnt from: " +learntFrom);
		if (as_number==null){
			log.error(" as_number is NULL");
		}
		DomainTEDB domainTEDB=(DomainTEDB)intraTEDBs.get(as_number.getHostAddress());

		SimpleTEDB simpleTEDB=null;
		if (domainTEDB instanceof SimpleTEDB){
			simpleTEDB = (SimpleTEDB) domainTEDB;
		}else if (domainTEDB==null){
			simpleTEDB = new SimpleTEDB();
			simpleTEDB.createGraph();
			this.intraTEDBs.put(as_number.getHostAddress(), simpleTEDB);
			simpleTEDB.setDomainID(as_number);
		}else {
			log.error("PROBLEM: TEDB not compatible");
			return;
		}

		NodeTable =simpleTEDB.getNodeTable();
		if(NodeTable!=null){
			if(NodeTable.containsKey(IGPID))
				NodeTable.remove(IGPID);
		}


		NodeTable.put(IGPID, node_info);

		simpleTEDB.setNodeTable(NodeTable);
		if (this.multiTedb!=null) {
			if (node_info.getIpv4Address()!=null){
				this.multiTedb.addReachabilityIPv4(as_number, node_info.getIpv4Address(), 32);
			}

		}
		log.debug("Node Table:" + NodeTable.toString());
		log.debug("Node Information Table Updated....");

	}


	private void clearAttributes(){
		maximumLinkBandwidthTLV= null;
		maxReservableBandwidthTLV= null;
		unreservedBandwidthTLV= null;
		administrativeGroupTLV = null;
		linkProtectionTLV =null;
		metricTLV = null;
		iPv4RouterIDLocalNodeLATLV = null;
		iPv4RouterIDRemoteNodeLATLV = null;
		TEMetricTLV = null;				
		transceiverClassAndAppATLV = null;
		mF_OTP_ATLV = null;
		availableLabels=null;
		linkDelay=0;
		linkDelayVar=0;
		minDelay=0;
		maxDelay=0;
		linkLoss=0;
		residualBw=0;
		availableBw=0;
		utilizedBw=0;

	}



}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy