--- a/src/DAF/AE/AE.cc
+++ b/src/DAF/AE/AE.cc
@@ -24,14 +24,35 @@
}
void AE::initSignalsAndListeners() {
- //cModule* catcher = this->getParentModule()->getParentModule();
+ cModule* catcher1 = this->getParentModule();
+ cModule* catcher2 = this->getParentModule()->getParentModule()->getParentModule();
//Signals that this module is emitting
sigAEAllocReq = registerSignal(SIG_AE_AllocateRequest);
sigAEDeallocReq = registerSignal(SIG_AE_DeallocateRequest);
+ sigAESendData = registerSignal(SIG_AE_DataSend);
+ sigAEAllocResPosi = registerSignal(SIG_AERIBD_AllocateResponsePositive);
+ sigAEAllocResNega = registerSignal(SIG_AERIBD_AllocateResponseNegative);
//Signals that this module is processing
-
+ lisAERcvData = new LisAEReceiveData(this);
+ catcher1->subscribe(SIG_CDAP_DateReceive, lisAERcvData);
+
+ // AllocationRequest from FAI
+ lisAEAllReqFromFai = new LisAEAllReqFromFai(this);
+ catcher2->subscribe(SIG_FAI_AllocateRequest, lisAEAllReqFromFai);
+
+ // DeallocationRequest from FAI
+ lisAEDeallReqFromFai = new LisAEDeallReqFromFai(this);
+ catcher2->subscribe(SIG_FAI_DeallocateRequest, lisAEDeallReqFromFai);
+ lisAEDeallResFromFai = new LisAEDeallReqFromFai(this);
+ catcher2->subscribe(SIG_FAI_DeallocateResponse, lisAEDeallResFromFai);
+
+ lisAEAllResPosi = new LisAEAllResPosi(this);
+ catcher2->subscribe(SIG_FAI_AllocateResponsePositive, lisAEAllResPosi);
+
+ lisAEAllResNega = new LisAEAllResNega(this);
+ catcher2->subscribe(SIG_FAI_AllocateResponseNegative, lisAEAllResNega);
}
void AE::initialize() {
@@ -48,52 +69,316 @@
void AE::handleMessage(cMessage* msg) {
}
-void AE::createBinding(Flow& flow) {
+bool AE::createBindings(Flow& flow) {
EV << this->getFullPath() << " created bindings and registered a new flow" << endl;
//Create new gates
- cGate* g1i;
- cGate* g1o;
- Irm->getOrCreateFirstUnconnectedGatePair(GATE_AEIO, false, true, *&g1i, *&g1o);
-
- //cGate* g0i;
- //cGate* g0o;
- //this->getOrCreateFirstUnconnectedGatePair("southIo", true, true, *&g0i, *&g0o);
+ cGate* gIrmIn;
+ cGate* gIrmOut;
+ Irm->getOrCreateFirstUnconnectedGatePair(GATE_AEIO, false, true, *&gIrmIn, *&gIrmOut);
//Get AE gates
- cGate* g2i;
- cGate* g2o;
- this->getOrCreateFirstUnconnectedGatePair(GATE_DATAIO, false, true, *&g2i, *&g2o);
+ cGate* gAeIn;
+ cGate* gAeOut;
+ this->getParentModule()->getOrCreateFirstUnconnectedGatePair(GATE_DATAIO, false, true, *&gAeIn, *&gAeOut);
+
+ //CDAPParent Module gates
+ cGate* gCdapParentIn;
+ cGate* gCdapParentOut;
+ Cdap->getOrCreateFirstUnconnectedGatePair(GATE_SOUTHIO, false, true, *&gCdapParentIn, *&gCdapParentOut);
+
+ //CDAPSplitter gates
+ cModule* CdapSplit = Cdap->getSubmodule(MOD_CDAPSPLIT);
+ cGate* gSplitIn;
+ cGate* gSplitOut;
+ CdapSplit->getOrCreateFirstUnconnectedGatePair(GATE_SOUTHIO, false, true, *&gSplitIn, *&gSplitOut);
+ cGate* gSplitCaceIn;
+ cGate* gSplitCaceOut;
+ CdapSplit->getOrCreateFirstUnconnectedGatePair(GATE_CACEIO, false, true, *&gSplitCaceIn, *&gSplitCaceOut);
+ cGate* gSplitAuthIn;
+ cGate* gSplitAuthOut;
+ CdapSplit->getOrCreateFirstUnconnectedGatePair(GATE_AUTHIO, false, true, *&gSplitAuthIn, *&gSplitAuthOut);
+ cGate* gSplitCdapIn;
+ cGate* gSplitCdapOut;
+ CdapSplit->getOrCreateFirstUnconnectedGatePair(GATE_CDAPIO, false, true, *&gSplitCdapIn, *&gSplitCdapOut);
+
+ //CACE Module gates
+ cModule* CdapCace = Cdap->getSubmodule(MOD_CDAPCACE);
+ cGate* gCaceIn;
+ cGate* gCaceOut;
+ CdapCace->getOrCreateFirstUnconnectedGatePair(GATE_SPLITIO, false, true, *&gCaceIn, *&gCaceOut);
+
+ //AUTH Module gates
+ cModule* CdapAuth = Cdap->getSubmodule(MOD_CDAPAUTH);
+ cGate* gAuthIn;
+ cGate* gAuthOut;
+ CdapAuth->getOrCreateFirstUnconnectedGatePair(GATE_SPLITIO, false, true, *&gAuthIn, *&gAuthOut);
+
+ //CDAP Module gates
+ cModule* CdapCdap = Cdap->getSubmodule(MOD_CDAPCDAP);
+ cGate* gCdapIn;
+ cGate* gCdapOut;
+ CdapCdap->getOrCreateFirstUnconnectedGatePair(GATE_SPLITIO, false, true, *&gCdapIn, *&gCdapOut);
//Connect gates together
- g1o->connectTo(g2i);
- g2o->connectTo(g1i);
+ gIrmOut->connectTo(gAeIn);
+ gAeIn->connectTo(gCdapParentIn);
+ gCdapParentIn->connectTo(gSplitIn);
+
+
+ gSplitOut->connectTo(gCdapParentOut);
+ gCdapParentOut->connectTo(gAeOut);
+ gAeOut->connectTo(gIrmIn);
+
+
+ gSplitCaceOut->connectTo(gCaceIn);
+ gCaceOut->connectTo(gSplitCaceIn);
+
+ gSplitAuthOut->connectTo(gAuthIn);
+ gAuthOut->connectTo(gSplitAuthIn);
+
+ gSplitCdapOut->connectTo(gCdapIn);
+ gCdapOut->connectTo(gSplitCdapIn);
+
//Set north-half of the routing in ConnectionTable
- ConTab->setNorthGates(&flow, g1i, g1o);
+ ConTab->setNorthGates(&flow, gIrmIn, gIrmOut);
+
+ //Return true if all dynamically created gates have same index
+ return gIrmIn->getIndex() == gAeIn->getIndex()
+ && gIrmIn->getIndex() == gCdapParentIn->getIndex()
+ && gIrmIn->getIndex() == gSplitIn->getIndex()
+ && gIrmIn->getIndex() == gSplitCaceIn->getIndex()
+ && gIrmIn->getIndex() == gSplitAuthIn->getIndex()
+ && gIrmIn->getIndex() == gSplitCdapIn->getIndex();
}
void AE::initPointers() {
Irm = ModuleAccess<IRM>(MOD_IRM).get();
ConTab = ModuleAccess<ConnectionTable>(MOD_CONNTABLE).get();
-}
-
-void AE::signalizeAllocateRequest(Flow* flow) {
- emit(sigAEAllocReq, flow);
+ Cdap = this->getParentModule()->getSubmodule(MOD_CDAP);
+
+ if (!Irm || !ConTab || !Cdap)
+ error("Pointers to Irm or ConnectionTable or Cdap is not initialized!");
}
void AE::insertFlow(Flow& flow) {
//Add a new flow to the end of the Flow list
flows.push_back(flow);
- //Create a new record in ConnectionTable
- ConTab->insertNew(&flows.back());
+ //Prepare flow
+ Irm->newFlow(&flows.back());
//Interconnect IRM and AE
- createBinding(flows.back());
+ bool status = createBindings(flow);
+ if (!status) {
+ throw("Gate inconsistency during creation of a new flow!");
+ }
+}
+
+void AE::signalizeAllocateRequest(Flow* flow) {
+ emit(sigAEAllocReq, flow);
}
void AE::signalizeDeallocateRequest(Flow* flow) {
emit(sigAEDeallocReq, flow);
}
-
+void AE::receiveData(CDAPMessage* msg) {
+ Enter_Method("receiveData()");
+ //M_READ_Request
+ if (dynamic_cast<CDAP_M_Read*>(msg)) {
+ processMRead(msg);
+ }
+ //M_READ_Response
+ else if (dynamic_cast<CDAP_M_Read_R*>(msg)) {
+ processMReadR(msg);
+ }
+
+ delete msg;
+}
+
+void AE::receiveAllocationRequestFromFAI(Flow* flow) {
+ Enter_Method("receiveAllocationRequestFromFai()");
+ //EV << this->getFullPath() << " received AllocationRequest from FAI" << endl;
+
+ //TODO: Vesely - More sophisticated decission
+ if (QoSRequirements.countFeasibilityScore(flow->getQosParameters()) > 0) {
+ //Initialize flow within AE
+ insertFlow(*flow);
+ //EV << "======================" << endl << flow->info() << endl;
+ //Interconnect IRM and IPC
+ Irm->receiveAllocationResponsePositiveFromIpc(flow);
+
+ this->signalizeAllocateResponsePositive(flow);
+ }
+ else {
+ this->signalizeAllocateResponseNegative(flow);
+ }
+}
+
+void AE::signalizeSendData(cMessage* msg) {
+ EV << "Emits SendData signal for message " << msg->getName() << endl;
+ emit(sigAESendData, msg);
+}
+
+void AE::signalizeAllocateResponsePositive(Flow* flow) {
+ emit(sigAEAllocResPosi, flow);
+}
+
+void AE::receiveAllocationResponseNegative(Flow* flow) {
+ Enter_Method("receiveAllocationResponseNegative()");
+ //Change allocation status
+ ConTab->setStatus(flow, ConnectionTableEntry::CON_ERROR);
+}
+
+void AE::receiveAllocationResponsePositive(Flow* flow) {
+ Enter_Method("receiveAllocationResponsePositive()");
+ //Interconnect IRM and IPC
+ Irm->receiveAllocationResponsePositiveFromIpc(flow);
+
+ //Change allocation status
+ ConTab->setStatus(flow, ConnectionTableEntry::CON_CONNECTPENDING);
+
+ //TODO: Vesely - Work with return value?
+}
+
+void AE::sendAllocationRequest(Flow* flow) {
+ //TODO: Vesely - Substitute with signal
+ Irm->receiveAllocationRequestFromAe(flow);
+}
+
+void AE::sendDeallocationRequest(Flow* flow) {
+ //TODO: Vesely - Substitute with signal
+ Irm->receiveDeallocationRequestFromAe(flow);
+}
+
+void AE::signalizeAllocateResponseNegative(Flow* flow) {
+ emit(sigAEAllocResNega, flow);
+}
+
+void AE::sendData(Flow* flow, CDAPMessage* msg) {
+ //Retrieve handle from ConTab record
+ ConnectionTableEntry* cte = ConTab->findEntryByFlow(flow);
+ if (cte && cte->getNorthGateIn()) {
+ msg->setHandle(cte->getNorthGateIn()->getIndex());
+ //Pass Data to CDAP
+ signalizeSendData(msg);
+ }
+ else {
+ EV << "Sending data before flow is allocated!" << endl;
+ delete msg;
+ }
+}
+
+void AE::processMRead(CDAPMessage* msg) {
+
+}
+
+void AE::receiveDeallocationRequestFromFAI(Flow* flow) {
+ Enter_Method("receiveDeallocationRequestFromFai()");
+
+ bool status;
+ status = deleteBindings(*flow);
+ if (!status) {
+ EV << "deleteBindings() failed during DeallocateRequest processing!" << endl;
+ return;
+ }
+
+ status = Irm->deleteBindings(flow);
+ if (!status) {
+ EV << "IRM.deleteBindings() failed during DeallocateRequest processing!" << endl;
+ return;
+ }
+
+ //EV << "Statusak> " << status;
+}
+
+bool AE::deleteBindings(Flow& flow) {
+ EV << this->getFullPath() << " deleted bindings" << endl;
+
+ int handle = -1;
+ ConnectionTableEntry* cte = ConTab->findEntryByFlow(&flow);
+ if (cte && cte->getNorthGateIn())
+ handle = cte->getNorthGateIn()->getIndex();
+
+ //Disconnect gates
+ cGate* gIrmIn = Irm->gateHalf(GATE_AEIO, cGate::INPUT, handle);
+ cGate* gIrmOut = Irm->gateHalf(GATE_AEIO, cGate::OUTPUT, handle);
+
+ //Get AE gates
+ cGate* gAeIn = this->getParentModule()->gateHalf(GATE_DATAIO, cGate::INPUT, handle);
+ cGate* gAeOut = this->getParentModule()->gateHalf(GATE_DATAIO, cGate::OUTPUT, handle);;
+
+ //CDAPParent Module gates
+ cGate* gCdapParentIn = Cdap->gateHalf(GATE_SOUTHIO, cGate::INPUT, handle);
+ cGate* gCdapParentOut = Cdap->gateHalf(GATE_SOUTHIO, cGate::OUTPUT, handle);
+
+ //CDAPSplitter gates
+ cModule* CdapSplit = Cdap->getSubmodule(MOD_CDAPSPLIT);
+ cGate* gSplitIn = CdapSplit->gateHalf(GATE_SOUTHIO, cGate::INPUT, handle);
+ cGate* gSplitOut = CdapSplit->gateHalf(GATE_SOUTHIO, cGate::OUTPUT, handle);
+
+ cGate* gSplitCaceIn = CdapSplit->gateHalf(GATE_CACEIO, cGate::INPUT, handle);
+ cGate* gSplitCaceOut = CdapSplit->gateHalf(GATE_CACEIO, cGate::OUTPUT, handle);
+
+ cGate* gSplitAuthIn = CdapSplit->gateHalf(GATE_AUTHIO, cGate::INPUT, handle);
+ cGate* gSplitAuthOut = CdapSplit->gateHalf(GATE_AUTHIO, cGate::OUTPUT, handle);
+
+ cGate* gSplitCdapIn = CdapSplit->gateHalf(GATE_CDAPIO, cGate::INPUT, handle);
+ cGate* gSplitCdapOut = CdapSplit->gateHalf(GATE_CDAPIO, cGate::OUTPUT, handle);
+
+
+ //CACE Module gates
+ cModule* CdapCace = Cdap->getSubmodule(MOD_CDAPCACE);
+ cGate* gCaceIn = CdapCace->gateHalf(GATE_SPLITIO, cGate::INPUT, handle);
+ cGate* gCaceOut = CdapCace->gateHalf(GATE_SPLITIO, cGate::OUTPUT, handle);
+
+ //AUTH Module gates
+ cModule* CdapAuth = Cdap->getSubmodule(MOD_CDAPAUTH);
+ cGate* gAuthIn = CdapAuth->gateHalf(GATE_SPLITIO, cGate::INPUT, handle);
+ cGate* gAuthOut = CdapAuth->gateHalf(GATE_SPLITIO, cGate::OUTPUT, handle);
+
+ //CDAP Module gates
+ cModule* CdapCdap = Cdap->getSubmodule(MOD_CDAPCDAP);
+ cGate* gCdapIn = CdapCdap->gateHalf(GATE_SPLITIO, cGate::INPUT, handle);
+ cGate* gCdapOut = CdapCdap->gateHalf(GATE_SPLITIO, cGate::OUTPUT, handle);
+
+ //Disconnect gates
+ gIrmOut->disconnect();
+ gAeIn->disconnect();
+ gCdapParentIn->disconnect();
+ gSplitIn->disconnect();
+
+ gSplitOut->disconnect();
+ gCdapParentOut->disconnect();
+ gAeOut->disconnect();
+ gIrmIn->disconnect();
+
+ gSplitCaceOut->disconnect();
+ gCaceIn->disconnect();
+ gCaceOut->disconnect();
+ gSplitCaceIn->disconnect();
+
+ gSplitAuthOut->disconnect();
+ gAuthIn->disconnect();
+ gAuthOut->disconnect();
+ gSplitAuthIn->disconnect();
+
+ gSplitCdapOut->disconnect();
+ gCdapIn->disconnect();
+ gCdapOut->disconnect();
+ gSplitCdapIn->disconnect();
+
+ //Return true if all dynamically created gates are disconnected
+ return !gIrmIn->isConnected() && !gIrmOut->isConnected()
+ && !gAeIn->isConnected() && !gAeOut->isConnected()
+ && !gCdapParentIn->isConnected() && !gCdapParentOut->isConnected()
+ && !gSplitIn->isConnected() && !gSplitOut->isConnected()
+ && !gSplitCaceIn->isConnected() && !gSplitCaceOut->isConnected()
+ && !gSplitAuthIn->isConnected() && !gSplitAuthOut->isConnected()
+ && !gSplitCdapIn->isConnected() && !gSplitCdapOut->isConnected();
+}
+
+void AE::processMReadR(CDAPMessage* msg) {
+
+}