using namespace anna::diameter::comm;
-void Server::initialize() throw() {
+void Server::initialize() {
a_parent = NULL;
a_engine = NULL;
a_clientSessions.clear(); // importante (el recycler creo que no lo tocaba)
a_maxClientSessions = 1; // mono client connection
a_lastIncomingActivityTime = (anna::Millisecond)0;
a_lastOutgoingActivityTime = (anna::Millisecond)0;
- a_statisticsAccumulator = anna::statistics::Engine::instantiate().createAccumulator();
a_lastUsedResource = NULL;
}
-void Server::initializeStatisticConcepts() throw() {
- // Realm name
- std::string realmName = a_engine ? a_engine->getRealm() : "unknown"; // it should be known (createServer)
-
- // Statistics:
- anna::statistics::Engine& statsEngine = anna::statistics::Engine::instantiate();
- // Concepts descriptions:
- std::string serverAsString = anna::functions::socketLiteralAsString(a_socket.first, a_socket.second);
- std::string c1desc = "Diameter processing time (for requests) at servers on "; c1desc += serverAsString; c1desc += " for realm '"; c1desc += realmName; c1desc += "'";
- std::string c2desc = "Diameter message sizes received from servers on "; c2desc += serverAsString; c2desc += " for realm '"; c2desc += realmName; c2desc += "'";
- // Registering
- a_processing_time__StatisticConceptId = statsEngine.addConcept(c1desc.c_str(), "ms", true/* integer values */);
- a_received_message_size__StatisticConceptId = statsEngine.addConcept(c2desc.c_str(), "bytes", true/* integer values */);
+void Server::initializeStatisticResources() {
+ std::string accName = "remote server '";
+ accName += anna::functions::socketLiteralAsString(a_socket.first, a_socket.second);
+ accName += "' from origin-realm '";
+ accName += a_engine ? a_engine->getOriginRealmName() : "unknown"; // it should be known (createServer)
+ accName += "' and origin-host '";
+ accName += a_engine ? a_engine->getOriginHostName() : "unknown"; // it should be known (createServer)
+ accName += "'";
+ a_messageStatistics.initialize(accName);
}
-void Server::resetStatistics() throw() {
- a_statisticsAccumulator->reset();
+void Server::resetStatistics() {
+ a_messageStatistics.getAccumulator()->reset();
}
-void Server::updateProcessingTimeStatisticConcept(const double &value) throw() {
- a_statisticsAccumulator->process(a_processing_time__StatisticConceptId, value);
- LOGDEBUG(anna::Logger::debug(a_statisticsAccumulator->asString(), ANNA_FILE_LOCATION));
+void Server::updateProcessingTimeStatisticConcept(const double &value, const anna::diameter::CommandId &cid) {
+ a_messageStatistics.process(MessageStatistics::ConceptType::SentRequestProcessingTime, cid, value);
+ LOGDEBUG(anna::Logger::debug(a_messageStatistics.getAccumulator()->asString(), ANNA_FILE_LOCATION));
}
-void Server::updateReceivedMessageSizeStatisticConcept(const double &value) throw() {
- a_statisticsAccumulator->process(a_received_message_size__StatisticConceptId, value);
- //LOGDEBUG(anna::Logger::debug(a_statisticsAccumulator->asString(), ANNA_FILE_LOCATION));
+void Server::updateReceivedMessageSizeStatisticConcept(const double &value, const anna::diameter::CommandId &cid) {
+ a_messageStatistics.process(MessageStatistics::ConceptType::ReceivedMessageSize, cid, value);
+ LOGDEBUG(anna::Logger::debug(a_messageStatistics.getAccumulator()->asString(), ANNA_FILE_LOCATION));
}
-void Server::assertReady() throw(anna::RuntimeException) {
+void Server::assertReady() noexcept(false) {
if(a_clientSessions.size() != a_maxClientSessions) {
std::string msg(asString());
msg += " | Non-configured server: you must add the remaining client-sessions before any operation (bind, send, etc.)";
void Server::addClientSession(int socketId)
-throw(anna::RuntimeException) {
+noexcept(false) {
if(a_clientSessions.size() == a_maxClientSessions) {
LOGDEBUG
(
a_clientSessions.push_back(s);
}
-int Server::getOTARequests() const throw() {
+int Server::getOTARequests() const {
int result = 0;
for(std::vector<ClientSession*>::const_iterator it = begin(); it != end(); it++)
}
-bool Server::send(const Message* message, int socketId) throw(anna::RuntimeException) {
+bool Server::send(const Message* message, int socketId) noexcept(false) {
LOGMETHOD(anna::TraceMethod tttm("diameter::comm::Server", "send", ANNA_FILE_LOCATION));
assertReady();
bool fixedSocket = (socketId != -1);
try {
// Send:
- const Response* response = a_lastUsedResource->send(message);
+ a_lastUsedResource->send(message);
return true; // no matter if response is NULL (answers, i.e.) or not.
} catch(anna::RuntimeException &ex) {
LOGDEBUG(
}
-bool Server::broadcast(const Message* message) throw(anna::RuntimeException) {
+bool Server::broadcast(const Message* message) noexcept(false) {
LOGMETHOD(anna::TraceMethod tttm("diameter::comm::Server", "broadcast", ANNA_FILE_LOCATION));
assertReady();
- const Response* response;
bool allok = true;
for(std::vector<ClientSession*>::iterator it = begin(); it != end(); it++) {
try {
- response = (*it)->send(message);
+ (*it)->send(message);
} catch(anna::RuntimeException &ex) {
ex.trace();
allok = false;
}
-bool Server::bind() throw(anna::RuntimeException) {
+bool Server::bind() noexcept(false) {
LOGMETHOD(anna::TraceMethod tttm("diameter::comm::Server", "bind", ANNA_FILE_LOCATION));
assertReady();
a_deliveryIterator = begin();
return result;
}
-void Server::raiseAutoRecovery(bool autoRecovery) throw(anna::RuntimeException) {
+void Server::raiseAutoRecovery(bool autoRecovery) noexcept(false) {
LOGMETHOD(anna::TraceMethod tttm("diameter::comm::Server", "raiseAutoRecovery", ANNA_FILE_LOCATION));
assertReady();
a_deliveryIterator = begin();
(*it)->setAutoRecovery(autoRecovery);
}
-void Server::setClassCodeTimeout(const ClassCode::_v v, const anna::Millisecond & millisecond) throw() {
+void Server::setClassCodeTimeout(const ClassCode::_v v, const anna::Millisecond & millisecond) {
LOGMETHOD(anna::TraceMethod tttm("diameter::comm::Server", "setClassCodeTimeout", ANNA_FILE_LOCATION));
assertReady();
// Private close/destroy method
-void Server::close(bool destroy) throw(anna::RuntimeException) {
+void Server::close(bool destroy) noexcept(false) {
LOGMETHOD(anna::TraceMethod tttm("diameter::comm::Server", "close", ANNA_FILE_LOCATION));
if(!a_engine)
}
-void Server::childIdle() const throw() {
+void Server::childIdle() const {
// Check father entity idleness:
if(idle()) a_parent->childIdle();
}
-void Server::hide() throw() {
+void Server::hide() {
for(std::vector<ClientSession*>::iterator it = begin(); it != end(); it++)
(*it)->hide();
}
-void Server::show() throw() {
+void Server::show() {
for(std::vector<ClientSession*>::iterator it = begin(); it != end(); it++)
(*it)->show();
}
-bool Server::hidden() const throw() {
+bool Server::hidden() const {
for(std::vector<ClientSession*>::const_iterator it = begin(); it != end(); it++)
if((*it)->shown()) return false;
return true;
}
-bool Server::shown() const throw() {
+bool Server::shown() const {
for(std::vector<ClientSession*>::const_iterator it = begin(); it != end(); it++)
if((*it)->hidden()) return false;
-std::string Server::socketAsString() const throw() {
+std::string Server::socketAsString() const {
std::string result = getAddress();
result += ":";
result += anna::functions::asString(getPort());
}
-std::string Server::asString() const throw() {
+std::string Server::asString() const {
std::string result("diameter::comm::Server { ");
result += " | Parent Entity: ";
result += a_parent->getDescription();
result += " | Hidden: ";
result += (hidden() ? "yes" : "no");
result += "\n";
- result += a_statisticsAccumulator->asString();
+ result += a_messageStatistics.getAccumulator()->asString();
for(std::vector<ClientSession*>::const_iterator it = begin(); it != end(); it++) {
result += "\n";
return result;
}
-anna::xml::Node* Server::asXML(anna::xml::Node* parent) const throw() {
+anna::xml::Node* Server::asXML(anna::xml::Node* parent) const {
anna::xml::Node* result = parent->createChild("diameter.Server");
result->createAttribute("ParentEntity", a_parent->getDescription());
result->createAttribute("ServerAddress", a_socket.first);
result->createAttribute("Hidden", hidden() ? "yes" : "no");
// Statistics
anna::xml::Node* stats = result->createChild("Statistics");
- a_statisticsAccumulator->asXML(stats);
+ a_messageStatistics.getAccumulator()->asXML(stats);
anna::xml::Node* clientSessions = result->createChild("Server.ClientSessions");
for(std::vector<ClientSession*>::const_iterator it = begin(); it != end(); it++)
}
-void Server::eventPeerShutdown(const ClientSession *clientSession) throw() {
+void Server::eventPeerShutdown(const ClientSession *clientSession) {
// Inform father entity:
a_parent->eventPeerShutdown(clientSession);
}
-void Server::eventRequestRetransmission(const ClientSession* clientSession, Message *request) throw() {
+void Server::eventRequestRetransmission(const ClientSession* clientSession, Message *request) {
// Inform father entity:
a_parent->eventRequestRetransmission(clientSession, request);
}
-void Server::eventResponse(const Response& response) throw(anna::RuntimeException) {
+void Server::eventResponse(const Response& response, const anna::diameter::comm::OriginHost *myNode) noexcept(false) {
// Inform father entity:
- a_parent->eventResponse(response);
+ a_parent->eventResponse(response, myNode);
}
-void Server::eventRequest(ClientSession *clientSession, const anna::DataBlock & request) throw(anna::RuntimeException) {
+void Server::eventRequest(ClientSession *clientSession, const anna::DataBlock & request, const anna::diameter::comm::OriginHost *myNode) noexcept(false) {
// Inform father entity:
- a_parent->eventRequest(clientSession, request);
+ a_parent->eventRequest(clientSession, request, myNode);
}
-void Server::eventUnknownResponse(ClientSession *clientSession, const anna::DataBlock & response) throw(anna::RuntimeException) {
+void Server::eventUnknownResponse(ClientSession *clientSession, const anna::DataBlock & response, const anna::diameter::comm::OriginHost *myNode) noexcept(false) {
// Inform father entity:
- a_parent->eventUnknownResponse(clientSession, response);
+ a_parent->eventUnknownResponse(clientSession, response, myNode);
}
-void Server::eventDPA(ClientSession *clientSession, const anna::DataBlock & response) throw(anna::RuntimeException) {
+void Server::eventDPA(ClientSession *clientSession, const anna::DataBlock & response, const anna::diameter::comm::OriginHost *myNode) noexcept(false) {
// Inform father entity:
- a_parent->eventDPA(clientSession, response);
+ a_parent->eventDPA(clientSession, response, myNode);
}
-void Server::availabilityLost() throw() {
+void Server::availabilityLost() {
a_available = false;
std::string socket = anna::functions::socketLiteralAsString(a_socket.first, a_socket.second);
LOGDEBUG(
OamModule &oamModule = OamModule::instantiate();
oamModule.activateAlarm(OamModule::Alarm::c_LostAvailabilityOverServerDefinedAs__s__, socket.c_str());
oamModule.count(OamModule::Counter::LostAvailabilityOverServer);
- a_engine->availabilityLost(this);
a_parent->refreshAvailability();
}
-void Server::availabilityRecovered() throw() {
+void Server::availabilityRecovered() {
a_available = true;
std::string socket = anna::functions::socketLiteralAsString(a_socket.first, a_socket.second);
LOGDEBUG(
OamModule &oamModule = OamModule::instantiate();
oamModule.cancelAlarm(OamModule::Alarm::c_LostAvailabilityOverServerDefinedAs__s__, socket.c_str());
oamModule.count(OamModule::Counter::RecoveredAvailabilityOverServer);
- a_engine->availabilityRecovered(this);
a_parent->refreshAvailability();
}
-bool Server::refreshAvailability() throw() {
+bool Server::refreshAvailability() {
// Here available
if(a_available) { // check not-bound state for all client-sessions:
bool isolate = true;
//------------------------------------------------------------------------------
//---------------------------------------- Server::updateIncomingActivityTime()
//------------------------------------------------------------------------------
-void Server::updateIncomingActivityTime() throw() {
+void Server::updateIncomingActivityTime() {
a_lastIncomingActivityTime = anna::functions::millisecond();
LOGDEBUG
(
//------------------------------------------------------------------------------
//---------------------------------------- Server::updateOutgoingActivityTime()
//------------------------------------------------------------------------------
-void Server::updateOutgoingActivityTime(void) throw() {
+void Server::updateOutgoingActivityTime(void) {
a_lastOutgoingActivityTime = anna::functions::millisecond();
LOGDEBUG
(
projects / anna.git / blobdiff