1 // ANNA - Anna is Not Nothingness Anymore //
3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo //
5 // See project site at http://redmine.teslayout.com/projects/anna-suite //
6 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
9 #include <anna/diameter.comm/Server.hpp>
10 #include <anna/diameter.comm/Entity.hpp>
11 #include <anna/diameter.comm/Engine.hpp>
12 #include <anna/diameter.comm/OamModule.hpp>
13 #include <anna/diameter/codec/functions.hpp>
14 #include <anna/diameter/helpers/base/defines.hpp>
15 #include <anna/core/functions.hpp>
16 #include <anna/time/functions.hpp>
17 #include <anna/diameter/helpers/base/functions.hpp>
18 #include <anna/diameter/helpers/dcca/functions.hpp>
20 #include <anna/core/tracing/Logger.hpp>
21 #include <anna/core/functions.hpp>
22 #include <anna/core/tracing/TraceMethod.hpp>
26 using namespace anna::diameter;
27 using namespace anna::diameter::comm;
31 void Entity::initialize() throw() {
33 a_servers.clear(); // importante (el recycler creo que no lo tocaba)
36 a_socketListLiteral = "";
37 a_primarySocketLiteral = "";
38 a_secondarySocketLiteral = "";
41 a_lastUsedResource = NULL;
45 void Entity::assertReady() throw(anna::RuntimeException) {
46 if(a_servers.size() != a_maxServers) {
47 std::string msg(asString());
48 msg += " | Non-configured entity: you must add the remaining servers before any operation (bind, send, etc.)";
49 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
54 void Entity::addServer(const socket_t & serverId)
55 throw(anna::RuntimeException) {
56 if(a_servers.size() == a_maxServers) {
59 std::string msg = "Maximum number of servers reached for this entity (";
60 msg += anna::functions::asString(a_maxServers);
61 msg += "). Please use clear()/close() primitives";
62 anna::Logger::debug(msg, ANNA_FILE_LOCATION);
68 throw anna::RuntimeException("Invalid engine reference (NULL)", ANNA_FILE_LOCATION);
70 Server *s = a_engine->createServer(this, serverId);
71 a_servers.push_back(s);
72 a_deliveryIterator = begin();
76 int Entity::readSocketId(const Message* message, int maxClientSessions) const throw() {
78 // Service-Context-Id:
79 anna::diameter::helpers::dcca::ChargingContext::_v chargingContext;
80 std::string scid = anna::diameter::helpers::dcca::functions::getServiceContextId(message->getBody(), chargingContext);
82 switch(chargingContext) {
83 case anna::diameter::helpers::dcca::ChargingContext::Data:
84 case anna::diameter::helpers::dcca::ChargingContext::Voice:
85 case anna::diameter::helpers::dcca::ChargingContext::Content: {
86 // Session-Id: '<DiameterIdentity>;<high 32 bits>;<low 32 bits>[;<optional value>="">]'
87 std::string sid = anna::diameter::helpers::base::functions::getSessionId(message->getBody());
88 std::string diameterIdentity, optional;
90 anna::diameter::helpers::base::functions::decodeSessionId(sid, diameterIdentity, high, low /* context-teid */, optional);
91 return (low % maxClientSessions);
93 case anna::diameter::helpers::dcca::ChargingContext::SMS:
94 case anna::diameter::helpers::dcca::ChargingContext::MMS:
95 case anna::diameter::helpers::dcca::ChargingContext::Unknown:
97 return -1; // IEC model and Unknown traffic types
99 } catch(anna::RuntimeException &ex) {
101 std::string msg = ex.getText();
102 msg += " | Round-robin between sessions will be used to send";
103 anna::Logger::debug(msg, ANNA_FILE_LOCATION);
111 bool Entity::send(const Message* message, bool balance) throw(anna::RuntimeException) {
112 LOGMETHOD(anna::TraceMethod tttm("diameter::comm::Entity", "send", ANNA_FILE_LOCATION));
114 // Carried socket id (forwarding/proxy features):
115 std::string carriedSocketId = message->getRequestClientSessionKey();
117 if(carriedSocketId != "") {
118 // Send (it was a request, we forward the answer):
120 ClientSession * fixedClientSession = a_engine->findClientSession(carriedSocketId); // exception if not found
121 fixedClientSession->send(message);
123 } catch(anna::RuntimeException &ex) {
124 std::string msg = "Cannot deliver answer through a fixed client session (";
125 msg += carriedSocketId;
126 msg += "). Perhaps it existed but not now. Ignore";
127 anna::Logger::error(msg, ANNA_FILE_LOCATION);
132 ////////////////////////////////////////////////////////////////////////////////////////
133 // BALANCE vs STANDARD
134 // Balance algorythm remember last delivery resource used, balancing from start to end,
135 // understanding start as next resource to last used, and end as last used. Standard
136 // algorithm always starts at primary (first defined) server.
137 ////////////////////////////////////////////////////////////////////////////////////////
141 for(int k = 0; k < getMaxServers(); k++) { // try round-robin only over one cycle,
142 // no matter where you are: don't repeat same server
143 if(a_deliveryIterator == end()) a_deliveryIterator = begin();
145 a_lastUsedResource = (*a_deliveryIterator);
146 a_deliveryIterator++;
147 // At 'readSocketId' documentation:
148 // If server is configured as single session (max client sessions equal to 1), entity will ignore
149 // this method because it won't affect the session selection.
150 int serverSessions = a_lastUsedResource->getMaxClientSessions();
151 int socketId = (serverSessions > 1) ? readSocketId(message, serverSessions) : -1; // optimization
153 if(a_lastUsedResource->send(message, socketId)) // exception only possible at findClientSession within server send procedure
157 // Standard (no balance) // start at begining, try secondary, and so on until end.
158 std::vector<Server*>::iterator it = begin();
161 a_lastUsedResource = (*it);
163 // At 'readSocketId' documentation:
164 // If server is configured as single session (max client sessions equal to 1), entity will ignore
165 // this method because it won't affect the session selection.
166 int serverSessions = a_lastUsedResource->getMaxClientSessions();
167 int socketId = (serverSessions > 1) ? readSocketId(message, serverSessions) : -1; // optimization
169 if(a_lastUsedResource->send(message, socketId)) // exception only possible at findClientSession within server send procedure
174 // END BALANCE AND TRY ALGORITHM or STANDARD ///////////////////////////////////////////
175 ////////////////////////////////////////////////////////////////////////////////////////
176 // Here, sent has failed:
178 OamModule &oamModule = OamModule::instantiate();
180 if(a_maxServers != 2) {
181 oamModule.activateAlarm(OamModule::Alarm::UnableToDeliverDiameterMessageToEntityDefinedAs__s__, a_socketListLiteral.c_str());
182 oamModule.count(OamModule::Counter::UnableToDeliverOverEntity);
184 OamModule &oamModule = OamModule::instantiate();
185 oamModule.activateAlarm(OamModule::Alarm::UnableToDeliverDiameterMessageToEntityDefinedAsPrimary__s__AndSecondary__s__,
186 a_primarySocketLiteral.c_str(),
187 a_secondarySocketLiteral.c_str());
188 oamModule.count(OamModule::Counter::UnableToDeliverOverEntity);
194 bool Entity::broadcast(const Message* message) throw(anna::RuntimeException) {
195 LOGMETHOD(anna::TraceMethod tttm("diameter::comm::Entity", "broadcast", ANNA_FILE_LOCATION));
200 for(std::vector<Server*>::iterator it = begin(); it != end(); it++) {
202 ok = (*it)->broadcast(message);
204 if(!ok) allok = false;
205 } catch(anna::RuntimeException &ex) {
214 bool Entity::bind() throw(anna::RuntimeException) {
215 LOGMETHOD(anna::TraceMethod tttm("diameter::comm::Entity", "bind", ANNA_FILE_LOCATION));
217 bool result = true; // all OK return
219 for(std::vector<Server*>::iterator it = begin(); it != end(); it++) {
222 } catch(anna::RuntimeException &ex) {
231 void Entity::raiseAutoRecovery(bool autoRecovery) throw(anna::RuntimeException) {
232 LOGMETHOD(anna::TraceMethod tttm("diameter::comm::Entity", "raiseAutoRecovery", ANNA_FILE_LOCATION));
235 for(std::vector<Server*>::iterator it = begin(); it != end(); it++)
236 (*it)->raiseAutoRecovery(autoRecovery);
239 void Entity::setClassCodeTimeout(const ClassCode::_v v, const anna::Millisecond & millisecond) throw() {
240 LOGMETHOD(anna::TraceMethod tttm("diameter::comm::Entity", "setClassCodeTimeout", ANNA_FILE_LOCATION));
243 for(std::vector<Server*>::iterator it = begin(); it != end(); it++) {
245 (*it)->setClassCodeTimeout(v, millisecond);
246 } catch(anna::RuntimeException &ex) {
253 // Private close/destroy method
254 void Entity::close(bool destroy) throw(anna::RuntimeException) {
255 LOGMETHOD(anna::TraceMethod tttm("diameter::comm::Entity", "close", ANNA_FILE_LOCATION));
258 throw anna::RuntimeException("Invalid engine reference (NULL)", ANNA_FILE_LOCATION);
262 for(std::vector<Server*>::iterator it = begin(); it != end(); it++)
263 a_engine->closeServer(*it, destroy);
267 socket_v Entity::getAddressPortList() const throw() {
270 for(std::vector<Server*>::const_iterator it = begin(); it != end(); it++) {
271 socket_t address((*it)->getAddress(), (*it)->getPort());
272 result.push_back(address);
278 int Entity::getOTARequests() const throw() {
281 for(std::vector<Server*>::const_iterator it = begin(); it != end(); it++)
282 result += (*it)->getOTARequests();
287 void Entity::childIdle() const throw() {
288 // Check father engine idleness:
289 if(idle()) a_engine->eraseDeprecatedIdleEntities();
293 void Entity::hide() throw() {
294 for(std::vector<Server*>::iterator it = begin(); it != end(); it++)
298 void Entity::show() throw() {
299 for(std::vector<Server*>::iterator it = begin(); it != end(); it++)
303 bool Entity::hidden() const throw() {
304 for(std::vector<Server*>::const_iterator it = begin(); it != end(); it++)
305 if((*it)->shown()) return false;
309 bool Entity::shown() const throw() {
310 for(std::vector<Server*>::const_iterator it = begin(); it != end(); it++)
311 if((*it)->hidden()) return false;
316 void Entity::eventPeerShutdown(const ClientSession* clientSession) throw() {
318 std::string msg(clientSession->asString());
319 msg += " | eventPeerShutdown";
320 anna::Logger::warning(msg, ANNA_FILE_LOCATION);
324 void Entity::eventRequestRetransmission(const ClientSession* clientSession, Message *request) throw() {
326 std::string msg(clientSession->asString());
328 HopByHop hopByHop = codec::functions::getHopByHop(request->getBody()); // context identification
329 int retries = request->getRetries();
331 msg += anna::functions::asString(" | eventRequestRetransmission: request with application HopByHop: %u; remaining %d retries", hopByHop, retries);
332 anna::Logger::warning(msg, ANNA_FILE_LOCATION);
336 std::string Entity::asString() const throw() {
337 std::string result("diameter::comm::Entity { ");
338 std::string originRealm = a_engine->getOriginRealm();
339 std::string originHost = a_engine->getOriginHost();
341 result += "Parent Engine Origin-Realm: ";
342 result += (originRealm != "") ? originRealm:"<not configured>";
343 result += " | Parent Engine Origin-Host: ";
344 result += (originHost != "") ? originHost:"<not configured>";
346 result += " | Category: ";
347 result += anna::functions::asString(a_category);
349 if(a_description != "") {
350 result += " | Description: '";
351 result += a_description;
354 result += " | Available: ";
355 result += a_available ? "yes" : "no";
356 result += " | Deprecated: ";
357 result += a_deprecated ? "yes" : "no";
358 result += " | Max servers supported: ";
359 result += anna::functions::asString(a_maxServers);
360 result += " | Currently configured servers: ";
361 result += anna::functions::asString(a_servers.size());
362 result += anna::functions::asString(" | OTA requests: %d%s", getOTARequests(), idle() ? " (idle)" : "");
363 result += " | Last Incoming Activity Time: ";
364 result += a_lastIncomingActivityTime.asString();
365 result += " | Last Outgoing Activity Time: ";
366 result += a_lastOutgoingActivityTime.asString();
367 result += " | Hidden: ";
368 result += (hidden() ? "yes" : "no");
371 for(std::vector<Server*>::const_iterator it = begin(); it != end(); it++) {
373 result += (*it)->asString();
379 anna::xml::Node* Entity::asXML(anna::xml::Node* parent) const throw() {
380 anna::xml::Node* result = parent->createChild("diameter.Entity");
381 std::string originRealm = a_engine->getOriginRealm();
382 std::string originHost = a_engine->getOriginHost();
384 if(originRealm != "") result->createAttribute("ParentEngineOriginRealm", originRealm);
385 if(originHost != "") result->createAttribute("ParentEngineOriginHost", originHost);
387 result->createAttribute("Category", anna::functions::asString(a_category));
389 if(a_description != "") result->createAttribute("Description", a_description);
391 result->createAttribute("Available", a_available ? "yes" : "no");
392 result->createAttribute("Deprecated", a_deprecated ? "yes" : "no");
393 result->createAttribute("MaxServersSupported", anna::functions::asString(a_maxServers));
394 result->createAttribute("CurrentlyConfiguredServers", anna::functions::asString(a_servers.size()));
395 result->createAttribute("OTArequests", anna::functions::asString("%d%s", getOTARequests(), idle() ? " (idle)" : ""));
396 result->createAttribute("LastIncomingActivityTime", a_lastIncomingActivityTime.asString());
397 result->createAttribute("LastOutgoingActivityTime", a_lastOutgoingActivityTime.asString());
398 result->createAttribute("Hidden", hidden() ? "yes" : "no");
399 anna::xml::Node* servers = result->createChild("Entity.Servers");
401 for(std::vector<Server*>::const_iterator it = begin(); it != end(); it++)
402 (*it)->asXML(servers);
407 void Entity::availabilityLost() throw() {
410 std::string msg = "diameter::comm::Entity { Description: ";
411 msg += getDescription();
412 msg += " } has lost its availability";
413 anna::Logger::debug(msg, ANNA_FILE_LOCATION);
415 OamModule &oamModule = OamModule::instantiate();
417 if(a_maxServers != 2) {
418 oamModule.activateAlarm(OamModule::Alarm::c_LostAvailabilityOverEntityDefinedAs__s__, a_socketListLiteral.c_str());
419 oamModule.count(OamModule::Counter::LostAvailabilityOverEntity);
421 oamModule.activateAlarm(OamModule::Alarm::c_LostAvailabilityOverEntityDefinedAsPrimary__s__AndSecondary__s__,
422 a_primarySocketLiteral.c_str(),
423 a_secondarySocketLiteral.c_str());
424 oamModule.count(OamModule::Counter::LostAvailabilityOverEntity);
427 a_engine->availabilityLost(this);
428 a_engine->refreshAvailabilityForEntities();
432 void Entity::availabilityRecovered() throw() {
435 std::string msg = "diameter::comm::Entity { Description: ";
436 msg += getDescription();
437 msg += " } has recovered its availability";
438 anna::Logger::debug(msg, ANNA_FILE_LOCATION);
440 OamModule &oamModule = OamModule::instantiate();
442 if(a_maxServers != 2) {
443 oamModule.cancelAlarm(OamModule::Alarm::c_LostAvailabilityOverEntityDefinedAs__s__, a_socketListLiteral.c_str());
444 oamModule.count(OamModule::Counter::RecoveredAvailabilityOverEntity);
446 oamModule.cancelAlarm(OamModule::Alarm::c_LostAvailabilityOverEntityDefinedAsPrimary__s__AndSecondary__s__,
447 a_primarySocketLiteral.c_str(),
448 a_secondarySocketLiteral.c_str());
449 oamModule.count(OamModule::Counter::RecoveredAvailabilityOverEntity);
452 a_engine->availabilityRecovered(this);
453 a_engine->refreshAvailabilityForEntities();
457 bool Entity::refreshAvailability() throw() {
459 if(a_available) { // check not-bound state for all servers:
462 for(std::vector<Server*>::const_iterator it = begin(); it != end(); it++)
463 if((*it)->isAvailable()) { isolate = false; break; }
473 // Here not available
474 for(std::vector<Server*>::const_iterator it = begin(); it != end(); it++)
475 if((*it)->isAvailable()) {
476 availabilityRecovered();
483 //------------------------------------------------------------------------------
484 //----------------------------------------- Entity::updateIncomingActivityTime()
485 //------------------------------------------------------------------------------
486 void Entity::updateIncomingActivityTime() throw() {
487 a_lastIncomingActivityTime = anna::functions::millisecond();
490 std::string msg = "Updated INCOMING activity on entity (milliseconds unix): ";
491 msg += anna::functions::asString(a_lastIncomingActivityTime.getValue());
492 anna::Logger::debug(msg, ANNA_FILE_LOCATION);
497 //------------------------------------------------------------------------------
498 //----------------------------------------- Entity::updateOutgoingActivityTime()
499 //------------------------------------------------------------------------------
500 void Entity::updateOutgoingActivityTime(void) throw() {
501 a_lastOutgoingActivityTime = anna::functions::millisecond();
504 std::string msg = "Updated OUTGOING activity on entity (milliseconds unix): ";
505 msg += anna::functions::asString(a_lastOutgoingActivityTime.getValue());
506 anna::Logger::debug(msg, ANNA_FILE_LOCATION);