#include <anna/diameter.comm/OamModule.hpp>
-#include <anna/diameter.comm/Engine.hpp>
#include <anna/diameter.comm/LocalServer.hpp>
#include <anna/diameter.comm/ServerSession.hpp>
#include <anna/diameter.comm/ServerSocket.hpp>
+#include <anna/diameter.comm/Engine.hpp>
#include <anna/core/functions.hpp>
#include <anna/statistics/Engine.hpp>
#include <anna/diameter.comm/TimerManager.hpp>
a_maxConnections(-1),
a_currentConnections(0),
a_allowedInactivityTime(ServerSession::DefaultAllowedInactivityTime),
- a_engine(NULL),
a_serverSocket(NULL),
a_category(0),
a_lock(false),
a_lastUsedResource(NULL) {}
-void LocalServer::initializeStatisticResources() throw() {
- std::string accName = "sent from local server '";
+void LocalServer::initializeStatisticResources() {
+ std::string accName = "local server '";
accName += anna::functions::socketLiteralAsString(a_key.first, a_key.second);
- accName += "' on origin-realm '";
- accName += a_engine ? a_engine->getOriginRealm() : "unknown"; // it should be known (createServer)
- accName += "' and origin-host '";
- accName += a_engine ? a_engine->getOriginHost() : "unknown"; // it should be known (createServer)
accName += "'";
a_messageStatistics.initialize(accName);
}
-void LocalServer::resetStatistics() throw() {
+void LocalServer::resetStatistics() {
a_messageStatistics.getAccumulator()->reset();
}
-void LocalServer::updateProcessingTimeStatisticConcept(const double &value, const anna::diameter::CommandId &cid) throw() {
+void LocalServer::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 LocalServer::updateReceivedMessageSizeStatisticConcept(const double &value, const anna::diameter::CommandId &cid) throw() {
+void LocalServer::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));
}
-ServerSession* LocalServer::allocateServerSession() throw() { return a_serverSessionsRecycler.create(); }
-void LocalServer::releaseServerSession(ServerSession *serverSession) throw() { a_serverSessionsRecycler.release(serverSession); }
+ServerSession* LocalServer::allocateServerSession() { return a_serverSessionsRecycler.create(); }
+void LocalServer::releaseServerSession(ServerSession *serverSession) { a_serverSessionsRecycler.release(serverSession); }
-LocalServer::serverSession_iterator LocalServer::serverSession_find(const serverSession_key &key) throw() {
+LocalServer::serverSession_iterator LocalServer::serverSession_find(const serverSession_key &key) {
return a_serverSessions.find(key);
}
-LocalServer::serverSession_key LocalServer::getServerSessionKey(const anna::comm::ClientSocket &clientSocket) const throw() {
- return (anna::functions::exclusiveHash(clientSocket.getRemoteAccessPoint().getINetAddress().serialize()));
+LocalServer::serverSession_key LocalServer::getServerSessionKey(const anna::comm::ClientSocket &clientSocket) const {
+ return (anna::functions::hash(clientSocket.getRemoteAccessPoint().getINetAddress().serialize().c_str()));
}
-void LocalServer::availabilityLost() throw() {
+void LocalServer::availabilityLost() {
a_available = false;
std::string socket = anna::functions::socketLiteralAsString(a_key.first, a_key.second);
LOGDEBUG(
OamModule &oamModule = OamModule::instantiate();
oamModule.activateAlarm(OamModule::Alarm::c_LostAvailabilityOverLocalServerDefinedAs__s__, socket.c_str());
oamModule.count(OamModule::Counter::LostAvailabilityOverLocalServer);
- a_engine->availabilityLost(this);
a_engine->refreshAvailabilityForLocalServers();
}
-void LocalServer::availabilityRecovered() throw() {
+void LocalServer::availabilityRecovered() {
a_available = true;
std::string socket = anna::functions::socketLiteralAsString(a_key.first, a_key.second);
LOGDEBUG(
OamModule &oamModule = OamModule::instantiate();
oamModule.cancelAlarm(OamModule::Alarm::c_LostAvailabilityOverLocalServerDefinedAs__s__, socket.c_str());
oamModule.count(OamModule::Counter::RecoveredAvailabilityOverLocalServer);
- a_engine->availabilityRecovered(this);
a_engine->refreshAvailabilityForLocalServers();
}
-bool LocalServer::refreshAvailability() throw() {
+bool LocalServer::refreshAvailability() {
// Here available
if(a_available) { // check not-bound state for all server-sessions:
// bool isolate = true;
}
-void LocalServer::enable(bool unlock) throw(anna::RuntimeException) {
+void LocalServer::enable(bool unlock) noexcept(false) {
// Unlock ?
if(unlock) a_lock = false;
attach();
}
-void LocalServer::attach() throw() {
+void LocalServer::attach() {
try {
// Attach to communicator
anna::comm::Communicator * communicator = anna::app::functions::component <anna::comm::Communicator> (ANNA_FILE_LOCATION);
}
}
-void LocalServer::attachPlanning() throw() {
+void LocalServer::attachPlanning() {
LOGMETHOD(anna::TraceMethod tttm("diameter::comm::LocalServer", "attachPlanning", ANNA_FILE_LOCATION));
try {
}
-void LocalServer::disable(bool lock) throw(anna::RuntimeException) {
+void LocalServer::disable(bool lock) noexcept(false) {
// Permanent ?
a_lock = lock;
anna::comm::Communicator * communicator = anna::app::functions::component <anna::comm::Communicator> (ANNA_FILE_LOCATION);
}
-void LocalServer::lostConnection() throw() {
+void LocalServer::lostConnection() {
a_currentConnections--;
enable();
}
-void LocalServer::newConnection() throw(anna::RuntimeException) {
+void LocalServer::newConnection() noexcept(false) {
a_currentConnections++;
// Check capacity
}
// Inform local server (availability changes):
- bool changes = refreshAvailability();
+ refreshAvailability();
+
// OAM
OamModule &oamModule = OamModule::instantiate();
oamModule.count(OamModule::Counter::CreatedConnectionForServerSession);
-ServerSession *LocalServer::createServerSession(const anna::comm::ClientSocket &clientSocket) throw(anna::RuntimeException) {
+ServerSession *LocalServer::createServerSession(const anna::comm::ClientSocket &clientSocket) noexcept(false) {
LOGMETHOD(anna::TraceMethod tttm("diameter::comm::LocalServer", "createServerSession", ANNA_FILE_LOCATION));
ServerSession* result(NULL);
// First erase deprecated ones:
result->setClientSocket((anna::comm::ClientSocket*)(&clientSocket));
result->a_parent = this;
result->a_socketId = key; // de momento...
- result->initializeSequences(); // despu�s de asignar el LocalServer y el socketId (*)
- // (*) Las secuencias se basan en la semilla: srand(::time(NULL) + anna::functions::exclusiveHash(anna::functions::asString("%s:%d|%d", getAddress().c_str(), getPort(), a_socketId)));
- result->a_engine = a_engine;
+ result->initializeSequences(); // despues de asignar el LocalServer y el socketId (sequences are seed-based by mean exclusive hash)
a_serverSessions.insert(serverSession_value_type(key, result));
newConnection();
a_deliveryIterator = serverSession_begin();
void LocalServer::closeServerSession(ServerSession* serverSession)
-throw(anna::RuntimeException) {
+noexcept(false) {
if(serverSession == NULL)
return;
ServerSession* LocalServer::findServerSession(int socketId, anna::Exception::Mode::_v emode)
-throw(anna::RuntimeException) {
+noexcept(false) {
serverSession_iterator ii = serverSession_find(socketId);
if(ii != serverSession_end())
}
ServerSession* LocalServer::findServerSession(const anna::comm::ClientSocket &clientSocket, anna::Exception::Mode::_v emode)
-throw(anna::RuntimeException) {
+noexcept(false) {
return findServerSession(getServerSessionKey(clientSocket), emode);
}
-int LocalServer::getOTARequests() const throw() {
+int LocalServer::getOTARequests() const {
int result = 0;
for(const_serverSession_iterator it = serverSession_begin(); it != serverSession_end(); it++)
return result;
}
-void LocalServer::close() throw(anna::RuntimeException) {
+void LocalServer::close() noexcept(false) {
LOGMETHOD(anna::TraceMethod tttm("diameter::comm::LocalServer", "close", ANNA_FILE_LOCATION));
// Close listener (permanently to avoid reopening when local connections are being deleted):
disable(true /* lock */);
closeServerSession(serverSession(it));
}
-void LocalServer::setClassCodeTimeout(const ClassCode::_v v, const anna::Millisecond & millisecond) throw() {
+void LocalServer::setClassCodeTimeout(const ClassCode::_v v, const anna::Millisecond & millisecond) {
LOGMETHOD(anna::TraceMethod tttm("diameter::comm::LocalServer", "setClassCodeTimeout", ANNA_FILE_LOCATION));
for(serverSession_iterator it = serverSession_begin(); it != serverSession_end(); it++) {
}
}
-void LocalServer::setMaxConnections(int maxConnections) throw(anna::RuntimeException) {
+void LocalServer::setMaxConnections(int maxConnections) noexcept(false) {
LOGMETHOD(anna::TraceMethod tttm("anna::diameter::comm::LocalServer", "setMaxConnections", ANNA_FILE_LOCATION));
// Negative & initial
}
-bool LocalServer::send(const Message* message, int socketId) throw(anna::RuntimeException) {
+bool LocalServer::send(const Message* message, int socketId) noexcept(false) {
LOGMETHOD(anna::TraceMethod tttm("diameter::comm::LocalServer", "send", ANNA_FILE_LOCATION));
if(!isAvailable()) {
// Send:
try {
- 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) {
ex.trace();
}
-bool LocalServer::broadcast(const Message* message) throw(anna::RuntimeException) {
+bool LocalServer::broadcast(const Message* message) noexcept(false) {
LOGMETHOD(anna::TraceMethod tttm("diameter::comm::LocalServer", "broadcast", ANNA_FILE_LOCATION));
- const Response* response;
bool allok = true;
for(serverSession_iterator it = serverSession_begin(); it != serverSession_end(); it++) {
try {
- response = serverSession(it)->send(message);
+ serverSession(it)->send(message);
} catch(anna::RuntimeException &ex) {
ex.trace();
allok = false;
return allok;
}
-void LocalServer::eventPeerShutdown(const ServerSession* serverSession) throw() {
+void LocalServer::eventPeerShutdown(const ServerSession* serverSession) {
LOGWARNING(
std::string msg(serverSession->asString());
msg += " | eventPeerShutdown";
);
}
-void LocalServer::eventRequestRetransmission(const ServerSession* serverSession, Message *request) throw() {
+void LocalServer::eventRequestRetransmission(const ServerSession* serverSession, Message *request) {
LOGWARNING(
std::string msg(serverSession->asString());
msg += " | eventRequestRetransmission";
);
}
-std::string LocalServer::asString() const throw() {
+std::string LocalServer::asString() const {
std::string result("diameter::comm::LocalServer { ");
- result += "Description: ";
+ result += "Key: ";
+ result += anna::functions::socketLiteralAsString(getKey().first, getKey().second);
+ result += " | Description: ";
result += (a_description != "") ? a_description : "undefined";
result += " | Available (any server session bound): ";
result += a_available ? "yes" : "no";
}
-anna::xml::Node* LocalServer::asXML(anna::xml::Node* parent) const throw() {
+anna::xml::Node* LocalServer::asXML(anna::xml::Node* parent) const {
anna::xml::Node* result = parent->createChild("diameter.LocalServer");
result->createAttribute("Description", (a_description != "") ? a_description : "undefined");
result->createAttribute("Available", a_available ? "yes" : "no");
//------------------------------------------------------------------------------
//------------------------------------ LocalServer::updateIncomingActivityTime()
//------------------------------------------------------------------------------
-void LocalServer::updateIncomingActivityTime() throw() {
+void LocalServer::updateIncomingActivityTime() {
a_lastIncomingActivityTime = anna::functions::millisecond();
LOGDEBUG
(
//------------------------------------------------------------------------------
//------------------------------------ LocalServer::updateOutgoingActivityTime()
//------------------------------------------------------------------------------
-void LocalServer::updateOutgoingActivityTime(void) throw() {
+void LocalServer::updateOutgoingActivityTime(void) {
a_lastOutgoingActivityTime = anna::functions::millisecond();
LOGDEBUG
(
projects / anna.git / blobdiff