example/diameter/launcher/Launcher.cpp

   1 // ANNA - Anna is Not Nothingness Anymore                                                         //
   2 //                                                                                                //
   3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
   4 //                                                                                                //
   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 //
   7
   8
   9 // Standard
  10 #include <sstream>      // std::istringstream
  11 #include <iostream>     // std::cout
  12 #include <math.h> // ceil
  13 #include <climits>
  14 #include <unistd.h> // chdir
  15
  16 // Project
  17 #include <anna/timex/Engine.hpp>
  18 #include <anna/statistics/Engine.hpp>
  19 #include <anna/diameter/codec/functions.hpp>
  20 #include <anna/diameter/codec/Engine.hpp>
  21 #include <anna/diameter/codec/EngineManager.hpp>
  22 #include <anna/http/Transport.hpp>
  23 #include <anna/diameter/stack/Engine.hpp>
  24 #include <anna/diameter/helpers/base/functions.hpp>
  25 #include <anna/time/functions.hpp>
  26 #include <anna/diameter.comm/ApplicationMessageOamModule.hpp>
  27 #include <anna/xml/xml.hpp>
  28
  29 // Process
  30 #include <Launcher.hpp>
  31 #include <OriginHost.hpp>
  32 #include <MyDiameterEngine.hpp>
  33 #include <TestManager.hpp>
  34 #include <TestCase.hpp>
  35
  36
  37 #define SIGUSR2_TASKS_INPUT_FILENAME "sigusr2.in"
  38 #define SIGUSR2_TASKS_OUTPUT_FILENAME "sigusr2.out"
  39
  40
  41 const char *ServicesDTD = "\
  42 <?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\
  43 <!-- Diameter services DTD -->\n\
  44 \n\
  45 <!ELEMENT services (stack*, node*)>\n\
  46 \n\
  47 <!ELEMENT stack EMPTY>\n\
  48 <!ATTLIST stack id CDATA #REQUIRED dictionary CDATA #REQUIRED validationMode (BeforeEncoding | AfterDecoding | Always | Never) #IMPLIED validationDepth (Complete | FirstError) #IMPLIED fixMode (BeforeEncoding | AfterDecoding | Always | Never) #IMPLIED ignoreFlagsOnValidation (yes | no) #IMPLIED>\n\
  49 <!--\n\
  50    Stack record\n\
  51 \n\
  52     id:                      Normally the id corresponds to the Application-Id for which the dictionary provided is designed\n\
  53                              (in multistack applications, it shall be mandatory respect such association to know the stack used\n\
  54                              for processed messages).\n\
  55     dictionary:              Path to the dictionary file.\n\
  56     validationMode:          Sets the validation mode. Default is 'AfterDecoding'.\n\
  57     validationDepth:         Sets the validation depth. Default is 'FirstError'.\n\
  58     fixMode:                 Sets the fix mode. Default is 'BeforeEncoding'.\n\
  59     ignoreFlagsOnValidation: Ignore flags during message validation. Default is 'no'.\n\
  60 -->\n\
  61 \n\
  62 <!ELEMENT node EMPTY>\n\
  63 <!ATTLIST node originHost CDATA #REQUIRED applicationId CDATA #REQUIRED originRealm CDATA #IMPLIED cer CDATA #IMPLIED dwr CDATA #IMPLIED cea CDATA #IMPLIED allowedInactivityTime CDATA #IMPLIED tcpConnectDelay CDATA #IMPLIED answersTimeout CDATA #IMPLIED ceaTimeout CDATA #IMPLIED watchdogPeriod CDATA #IMPLIED entity CDATA #IMPLIED entityServerSessions CDATA #IMPLIED diameterServer CDATA #IMPLIED diameterServerSessions CDATA #IMPLIED balance (yes | no) #IMPLIED sessionBasedModelsClientSocketSelection (SessionIdLowPart | SessionIdHighPart | SessionIdOptionalPart | RoundRobin) #IMPLIED retries CDATA #IMPLIED log CDATA #IMPLIED splitLog (yes | no) #IMPLIED detailedLog (yes | no) #IMPLIED dumpLog (yes | no) #IMPLIED burstLog (yes | no) #IMPLIED>\n\
  64 <!--\n\
  65    Node record\n\
  66 \n\
  67    originHost:                              Node identifier as diameter application host name.\n\
  68    applicationId:                           The Application-Id provided must exists as a registered 'stack id'.\n\
  69    originRealm:                             Origin-Realm (domain-name internally used by default).\n\
  70 \n\
  71 \n\
  72    - Diameter clients:\n\
  73 \n\
  74    entity:                                  Target diameter entity (comma-separated '<address>:<port>' format).\n\
  75                                             For example: 10.20.30.40:3868,10.20.30.41:3868. If missing, no entity will be enabled.\n\
  76    entityServerSessions:                    Diameter entity server sessions (0: diameter entity disabled). Default value of 1.\n\
  77    cer:                                     User defined CER path file to be encoded to establish diameter connections.\n\
  78                                             If missing, will be harcoded.\n\
  79    dwr:                                     User defined DWR path file to be encoded for diameter protocol keep alive.\n\
  80                                             If missing, will be harcoded.\n\
  81    tcpConnectDelay:                         Milliseconds to wait TCP connect to any server. If missing, default value of 200 will\n\
  82                                             be assigned\n\
  83    ceaTimeout:                              Milliseconds to wait CEA from diameter server. If missing, default value of 'answersTimeout'\n\
  84                                             will be assigned.\n\
  85    watchdogPeriod:                          Milliseconds for watchdog timer (Tw) for diameter keep-alive procedure. If missing, default\n\
  86                                             value of 30000 will be assigned.\n\
  87    balance:                                 Balance over entity servers instead of doing standard behaviour (first primary, secondary\n\
  88                                             if fails, etc.). Default value 'no'.\n\
  89    sessionBasedModelsClientSocketSelection: By default, round-robin will be applied for IEC model (SMS/MMS), and Session-Id Low Part\n\
  90                                             will be analyzed for ECUR/SCUR model (data, voice and content). You could change ECUR/SCUR\n\
  91                                             analysis behaviour providing 'SessionIdHighPart', 'SessionIdOptionalPart' (atoi applied;\n\
  92                                             usually subscriber id data, i.e. MSISDN or IMSI) and 'RoundRobin' (also 'SessionIdLowPart').\n\
  93 \n\
  94 \n\
  95    - Diameter servers:\n\
  96 \n\
  97    diameterServer:                          Diameter own server address in '<address>:<port>' format. For example: 10.20.30.40:3868.\n\
  98                                             If missing, no local server will be enabled.\n\
  99    diameterServerSessions:                  Diameter own server available connections (0: diameter server disabled). Default value of 1.\n\
 100                                             Negative value implies no limit accepting incoming connections.\n\
 101    cea:                                     User defined CEA path file to be encoded to answer client CERs.\n\
 102                                             If missing, will be harcoded.\n\
 103    allowedInactivityTime:                   Milliseconds for the maximum allowed inactivity time on server sessions born over the\n\
 104                                             local server before being reset. If missing, default value of 90000 will be assigned.\n\
 105 \n\
 106 \n\
 107    - General:\n\
 108 \n\
 109    answersTimeout:                          Milliseconds to wait pending application answers from diameter peers. If missing,\n\
 110                                             default value of 10000 will be assigned.\n\
 111    retries:                                 Expired responses will cause a number of request retransmissions. Disabled by default (0 retries).\n\
 112    log:                                     Process log file (operations result, traffic log, etc.). By default '<originHost>.launcher.log'.\n\
 113                                             Empty string or \"null\" name, to disable. Warning: there is no rotation for log files\n\
 114                                             (use logrotate or whatever you consider).\n\
 115    splitLog:                                Splits log file (appends to log filename, extensions with the type of event: see help on\n\
 116                                             startup information-level traces). No log files for code/decode and load operations are created.\n\
 117                                             Default value 'no'.\n\
 118    detailedLog:                             Insert detailed information at log files (timestamps, communication resources, etc.). Useful\n\
 119                                             to analyze the messages flow along the sockets (specially on 'balance' mode). Default 'no'.\n\
 120    dumpLog:                                 Write to disk every incoming/outcoming message named as:\n\
 121                                                '<unix ms timestamp>.<originHost>.<hop by hop>.<end to end>.<message code>.<request|answer>.<type of event>.xml'\n\
 122                                             Default value 'no'.\n\
 123    burstLog:                                Burst operations log file. By default '<originHost>.launcher.burst'. Empty string or \"null\" name, to disable.\n\
 124                                             Warning: there is no rotation for log files (use logrotate or whatever). Output: dot (.) for each\n\
 125                                             burst message sent/pushed, cross (x) for popped ones, and order number when multiple of 1% of burst\n\
 126                                             list size, plus OTA requests when changed.\n\
 127 \n\
 128 -->\n\
 129 \n\
 130 ";
 131
 132
 133 Launcher::Launcher() : anna::comm::Application("launcher", "DiameterLauncher", "1.1"), a_communicator(NULL) {
 134   a_timeEngine = NULL;
 135   a_counterRecorder = NULL;
 136   a_admlMinResolution = 2 * anna::timex::Engine::minResolution; // 2*10 = 20 ms; 1000/20 = 50 ticks per second;
 137   //a_admlMinResolution = (anna::Millisecond)100;
 138   a_counterRecorderClock = NULL;
 139
 140   // a_originHosts.clear();
 141   a_workingNode = NULL;
 142
 143   a_httpServerSocket = NULL;
 144 }
 145
 146
 147 std::string Launcher::getSignalUSR2InputFile() const throw() {
 148   return (a_initialWorkingDirectory + "/" + SIGUSR2_TASKS_INPUT_FILENAME);
 149 }
 150
 151 std::string Launcher::getSignalUSR2OutputFile() const throw() {
 152   return (a_initialWorkingDirectory + "/" + SIGUSR2_TASKS_OUTPUT_FILENAME);
 153 }
 154
 155
 156 void Launcher::servicesFromXML(const anna::xml::Node* servicesNode, bool eventOperation) throw(anna::RuntimeException) {
 157
 158   CommandLine& cl(anna::CommandLine::instantiate());
 159   bool allLogsDisabled = cl.exists("disableLogs");
 160
 161     //<!ATTLIST stack id CDATA #REQUIRED dictionary CDATA #REQUIRED>
 162   const anna::xml::Attribute *id, *dictionary;
 163
 164   // <!ATTLIST node originHost CDATA #REQUIRED applicationId CDATA #REQUIRED cer CDATA #IMPLIED dwr CDATA #IMPLIED allowedInactivityTime CDATA #IMPLIED tcpConnectDelay CDATA #IMPLIED answersTimeout CDATA #IMPLIED ceaTimeout CDATA #IMPLIED watchdogPeriod CDATA #IMPLIED entity CDATA #IMPLIED entityServerSessions CDATA #IMPLIED diameterServer CDATA #IMPLIED diameterServerSessions CDATA #IMPLIED balance (yes | no) #IMPLIED sessionBasedModelsClientSocketSelection (SessionIdLowPart | SessionIdHighPart | SessionIdOptionalPart | RoundRobin) #IMPLIED retries CDATA #IMPLIED log CDATA #IMPLIED splitLog (yes | no) #IMPLIED detailedLog (yes | no) #IMPLIED dumpLog (yes | no) #IMPLIED burstLog (yes | no) #IMPLIED>
 165   const anna::xml::Attribute *originHost, *appId, *originRealm, *cer, *dwr, *cea, *allowedInactivityTime, *tcpConnectDelay,
 166   *answersTimeout, *ceaTimeout, *watchdogPeriod, *entity, *entityServerSessions,
 167   *diameterServer, *diameterServerSessions, *balance, *sessionBasedModelsClientSocketSelection,
 168   *retries, *log, *splitLog, *detailedLog, *dumpLog, *burstLog;
 169   // Never clear services content from here (append new data from xml). At the moment no node removing is implemented in this process
 170
 171   // Stacks
 172   anna::diameter::stack::Engine &stackEngine = anna::diameter::stack::Engine::instantiate();
 173   anna::diameter::stack::Dictionary *d;
 174   const anna::diameter::stack::Dictionary *bpd = NULL; // base protocol dictionary
 175
 176   // Codec engine manager:
 177   anna::diameter::codec::EngineManager &em = anna::diameter::codec::EngineManager::instantiate();
 178   anna::diameter::codec::Engine *ce;
 179
 180   ///////////////////////////////////////////
 181   // APPLICATION MESSAGE OAM MODULE SCOPES //
 182   ///////////////////////////////////////////
 183   // We will register a scope per stack id registered. The counters will be dynamically registered at count method.
 184   anna::diameter::comm::ApplicationMessageOamModule & appMsgOamModule = anna::diameter::comm::ApplicationMessageOamModule::instantiate();
 185   appMsgOamModule.enableCounters(); // this special module is disabled by default (the only)
 186   static int scope_id = 3;
 187   unsigned int id_value;
 188   std::string codecEngineName;
 189
 190   for(anna::xml::Node::const_child_iterator it = servicesNode->child_begin(); it != servicesNode->child_end(); it++) {
 191     std::string nodeName = (*it)->getName();
 192
 193     if(nodeName == "stack") {
 194       // Input data:
 195       id = (*it)->getAttribute("id");
 196       dictionary = (*it)->getAttribute("dictionary");
 197       id_value = id->getIntegerValue();
 198
 199       if (stackEngine.getDictionary(id_value)) { // Ignore (but don't fail) dictionary load with same stack id already registered
 200         LOGWARNING(anna::Logger::warning(anna::functions::asString("Ignore dictionary load for stack id already registered: %llu", id_value), ANNA_FILE_LOCATION));
 201         continue;
 202       }
 203
 204       try {
 205         d = stackEngine.createDictionary(id_value, dictionary->getValue());
 206         LOGDEBUG(anna::Logger::debug(anna::functions::asString("Created dictionary (%p) for stack id %llu", d, id_value), ANNA_FILE_LOCATION));
 207
 208         // OAM module for counters:
 209         appMsgOamModule.createStackCounterScope(scope_id, id_value /* application-id */);
 210         scope_id++;
 211
 212       } catch(anna::RuntimeException &ex) {
 213         //_exit(ex.asString());
 214         throw ex;
 215       }
 216
 217       bpd = d; // base protocol dictionary in case of monostack. If multistack, will be calculated later
 218
 219       // Create codec engine and register it in the codec engine manager:
 220       codecEngineName = anna::functions::asString("CodecEngineForStackId_%llu", id_value);
 221       ce = new anna::diameter::codec::Engine(codecEngineName.c_str(), d);
 222       em.registerCodecEngine(id_value, ce);
 223
 224       // Codec engine configuration:
 225       const anna::xml::Attribute *vm_attr = (*it)->getAttribute("validationMode", false /* no exception */);
 226       const anna::xml::Attribute *vd_attr = (*it)->getAttribute("validationDepth", false /* no exception */);
 227       const anna::xml::Attribute *fm_attr = (*it)->getAttribute("fixMode", false /* no exception */);
 228       const anna::xml::Attribute *if_attr = (*it)->getAttribute("ignoreFlagsOnValidation", false /* no exception */);
 229
 230       std::string vm_value = vm_attr ? vm_attr->getValue() : "AfterDecoding";
 231       std::string vd_value = vd_attr ? vd_attr->getValue() : "FirstError";
 232       std::string fm_value = fm_attr ? fm_attr->getValue() : "BeforeEncoding";
 233
 234       anna::diameter::codec::Engine::ValidationMode::_v vm;
 235       if (vm_value == "BeforeEncoding") vm = anna::diameter::codec::Engine::ValidationMode::BeforeEncoding;
 236       else if (vm_value == "AfterDecoding") vm = anna::diameter::codec::Engine::ValidationMode::AfterDecoding;
 237       else if (vm_value == "Always") vm = anna::diameter::codec::Engine::ValidationMode::Always;
 238       else if (vm_value == "Never") vm = anna::diameter::codec::Engine::ValidationMode::Never;
 239       ce->setValidationMode(vm);
 240
 241       anna::diameter::codec::Engine::ValidationDepth::_v vd;
 242       if (vd_value == "Complete") vd = anna::diameter::codec::Engine::ValidationDepth::Complete;
 243       else if (vd_value == "FirstError") vd = anna::diameter::codec::Engine::ValidationDepth::FirstError;
 244       ce->setValidationDepth(vd);
 245
 246       anna::diameter::codec::Engine::FixMode::_v fm;
 247       if (fm_value == "BeforeEncoding") fm = anna::diameter::codec::Engine::FixMode::BeforeEncoding;
 248       else if (fm_value == "AfterDecoding") fm = anna::diameter::codec::Engine::FixMode::AfterDecoding;
 249       else if (fm_value == "Always") fm = anna::diameter::codec::Engine::FixMode::Always;
 250       else if (fm_value == "Never") fm = anna::diameter::codec::Engine::FixMode::Never;
 251       ce->setFixMode(fm);
 252
 253       bool if_value = (if_attr ? (if_attr->getValue() == "yes") : false);
 254       ce->ignoreFlagsOnValidation(if_value);
 255     }
 256   }
 257
 258   // Show loaded stacks:
 259   std::cout << "Stacks currently loaded:" << std::endl;
 260   std::cout << anna::functions::tab(stackEngine.asString(false /* light */)) << std::endl;
 261
 262   // Basic checking for multistack:
 263   bool multistack = (stackEngine.stack_size() > 1);
 264   if (multistack) {
 265     bpd = stackEngine.getDictionary(0);
 266     if(!bpd)
 267       throw anna::RuntimeException("In multistack applications is mandatory register a stack id = 0 using a dictionary which contains the needed elements to build base protocol messages (CER/A, DWR/A, DPR/A, STR/A, etc.)", ANNA_FILE_LOCATION);
 268   }
 269
 270   // REALMS:
 271   for(anna::xml::Node::const_child_iterator it = servicesNode->child_begin(); it != servicesNode->child_end(); it++) {
 272     std::string nodeName = (*it)->getName();
 273
 274     if(nodeName == "node") {
 275       // Input data:
 276       originHost = (*it)->getAttribute("originHost");
 277       appId = (*it)->getAttribute("applicationId");
 278       originRealm = (*it)->getAttribute("originRealm", false /* no exception */);
 279       cer = (*it)->getAttribute("cer", false /* no exception */);
 280       dwr = (*it)->getAttribute("dwr", false /* no exception */);
 281       cea = (*it)->getAttribute("cea", false /* no exception */);
 282       allowedInactivityTime = (*it)->getAttribute("allowedInactivityTime", false /* no exception */);
 283       tcpConnectDelay = (*it)->getAttribute("tcpConnectDelay", false /* no exception */);
 284       answersTimeout = (*it)->getAttribute("answersTimeout", false /* no exception */);
 285       ceaTimeout = (*it)->getAttribute("ceaTimeout", false /* no exception */);
 286       watchdogPeriod = (*it)->getAttribute("watchdogPeriod", false /* no exception */);
 287       entity = (*it)->getAttribute("entity", false /* no exception */);
 288       entityServerSessions = (*it)->getAttribute("entityServerSessions", false /* no exception */);
 289       diameterServer = (*it)->getAttribute("diameterServer", false /* no exception */);
 290       diameterServerSessions = (*it)->getAttribute("diameterServerSessions", false /* no exception */);
 291       balance = (*it)->getAttribute("balance", false /* no exception */); // (yes | no)
 292       sessionBasedModelsClientSocketSelection = (*it)->getAttribute("sessionBasedModelsClientSocketSelection", false /* no exception */); // (SessionIdHighPart | SessionIdOptionalPart | RoundRobin)
 293       retries = (*it)->getAttribute("retries", false /* no exception */);
 294       log = (*it)->getAttribute("log", false /* no exception */);
 295       splitLog = (*it)->getAttribute("splitLog", false /* no exception */); // (yes | no)
 296       detailedLog = (*it)->getAttribute("detailedLog", false /* no exception */); // (yes | no)
 297       dumpLog = (*it)->getAttribute("dumpLog", false /* no exception */); // (yes | no)
 298       burstLog = (*it)->getAttribute("burstLog", false /* no exception */); // (yes | no)
 299
 300       // Basic checkings:
 301       origin_hosts_it nodeIt = a_originHosts.find(originHost->getValue());
 302       if (nodeIt != a_originHosts.end()) {
 303         std::string msg = "Already registered such Origin-Host: "; msg += originHost->getValue();
 304         throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
 305       }
 306
 307       unsigned int applicationId = appId->getIntegerValue();
 308       if (!stackEngine.getDictionary(applicationId)) {
 309         std::string msg = "Cannot found a registered stack id with the value of applicationId provided: "; msg += appId->getValue();
 310         throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
 311       }
 312
 313       // Engine time measures checking & assignment:
 314       anna::Millisecond allowedInactivityTimeMs(90000);
 315       anna::Millisecond tcpConnectDelayMs(200);
 316       anna::Millisecond answersTimeoutMs(10000);
 317       anna::Millisecond ceaTimeoutMs(10000);
 318       anna::Millisecond watchdogPeriodMs(30000);
 319
 320       if (allowedInactivityTime) allowedInactivityTimeMs = checkTimeMeasure("allowedInactivityTime", allowedInactivityTime->getValue());
 321       if (tcpConnectDelay)       tcpConnectDelayMs =       checkTimeMeasure("tcpConnectDelay",       tcpConnectDelay->getValue());
 322       if (answersTimeout)        answersTimeoutMs =        checkTimeMeasure("answersTimeout",        answersTimeout->getValue());
 323       if (ceaTimeout)            ceaTimeoutMs =            checkTimeMeasure("ceaTimeout",            ceaTimeout->getValue());
 324       if (watchdogPeriod)        watchdogPeriodMs =        checkTimeMeasure("watchdogPeriod",        watchdogPeriod->getValue());
 325
 326       // Checking command line parameters
 327       std::string sessionBasedModelsType;
 328       if(sessionBasedModelsClientSocketSelection) {
 329         sessionBasedModelsType = sessionBasedModelsClientSocketSelection->getValue();
 330         if((sessionBasedModelsType != "SessionIdHighPart") && (sessionBasedModelsType != "SessionIdOptionalPart") && (sessionBasedModelsType != "RoundRobin")) {
 331           throw anna::RuntimeException("Parameter 'sessionBasedModelsClientSocketSelection' only accepts 'SessionIdHighPart'/'SessionIdOptionalPart'/'RoundRobin' as parameter values", ANNA_FILE_LOCATION);
 332         }
 333       }
 334
 335       int retransmissions = retries ? retries->getIntegerValue() : 0;
 336       if(retransmissions < 0) {
 337         throw anna::RuntimeException("Parameter 'retries' must be non-negative", ANNA_FILE_LOCATION);
 338       }
 339
 340       // Create new Node instance /////////////////////////////////////////////////////////////////
 341       a_workingNode = new OriginHost(originHost->getValue(), applicationId, bpd);
 342       MyDiameterEngine *commEngine = a_workingNode->getMyDiameterEngine();
 343       /////////////////////////////////////////////////////////////////////////////////////////////
 344
 345       // Assignments:
 346       commEngine->setMaxConnectionDelay(tcpConnectDelayMs);
 347       commEngine->setWatchdogPeriod(watchdogPeriodMs);
 348
 349       // Realm information:
 350       commEngine->setOriginHost(originHost->getValue());
 351       if (originRealm) commEngine->setOriginRealm(originRealm->getValue());
 352
 353       // Diameter entity:
 354       if(entity) {
 355         int sessions = entityServerSessions ? entityServerSessions->getIntegerValue() : 1;
 356
 357         if(sessions > 0) {
 358           // Number of sessions:
 359           commEngine->setNumberOfClientSessionsPerServer(sessions);
 360
 361           // Client CER and DWR
 362           std::string cerPathfile = cer ? cer->getValue() : "";
 363           std::string dwrPathfile = dwr ? dwr->getValue() : "";
 364           commEngine->setClientCERandDWR(cerPathfile, dwrPathfile);
 365
 366           // Register one entity for this engine:
 367           a_workingNode->createEntity(entity->getValue(), ceaTimeoutMs, answersTimeoutMs);
 368           a_workingNode->setRequestRetransmissions(retransmissions);
 369           a_workingNode->getEntity()->setSessionBasedModelsType(sessionBasedModelsType);
 370           a_workingNode->getEntity()->setBalance(balance ? (balance->getValue() == "yes") : false); // for sendings
 371           if (eventOperation) a_workingNode->getEntity()->bind();
 372         }
 373       }
 374
 375       // Diameter Server:
 376       if(diameterServer) {
 377         // Server CEA
 378         std::string ceaPathfile = cea ? cea->getValue() : "";
 379
 380         int sessions = diameterServerSessions ? diameterServerSessions->getIntegerValue() : 1;
 381         a_workingNode->startDiameterServer(diameterServer->getValue(), sessions, allowedInactivityTimeMs, answersTimeoutMs, ceaPathfile);
 382       }
 383
 384       // Logs:
 385       if (!allLogsDisabled) {
 386         std::string host = commEngine->getOriginHost();
 387         std::string s_log = host + ".launcher.log"; if (log) s_log = log->getValue();
 388         bool b_splitLog = (splitLog ? (splitLog->getValue() == "yes") : false);
 389         bool b_detailedLog = (detailedLog ? (detailedLog->getValue() == "yes") : false);
 390         bool b_dumpLog = (dumpLog ? (dumpLog->getValue() == "yes") : false);
 391         std::string s_burstLog = host + ".launcher.burst"; if (burstLog) s_burstLog = burstLog->getValue();
 392         a_workingNode->setLogs(s_log, b_splitLog, b_detailedLog, b_dumpLog, s_burstLog);
 393       }
 394
 395
 396       // Lazy initialization for comm engine:
 397       if (eventOperation) commEngine->lazyInitialize();
 398
 399       // Node and Codec Engine registration ///////////////////////////////////////////////////////
 400       a_originHosts[originHost->getValue()] = a_workingNode;
 401       /////////////////////////////////////////////////////////////////////////////////////////////
 402     }
 403   }
 404
 405   if (!uniqueOriginHost())
 406     a_workingNode = NULL; // by default, mode auto
 407
 408   // Diameter comm engines which are loaded after application start (via management operation 'services') are not really started,
 409   //  but this don't care because application startComponents() -> initialize() -> do_initialize() -> do nothing.
 410   // And when stopped, running state is not checked and it will be stopped anyway.
 411 }
 412
 413
 414 void Launcher::loadServices(const std::string & xmlPathFile, bool eventOperation) throw(anna::RuntimeException) {
 415
 416   if (xmlPathFile == "null" || xmlPathFile == "") {
 417     LOGWARNING(anna::Logger::warning("Ignoring services configuration on start: empty or 'null' string provided as xml file. Use management interface (operation 'services') in order to add services", ANNA_FILE_LOCATION));
 418     return;
 419   }
 420
 421   LOGDEBUG(
 422       std::string trace = "Loading ADML services file '";
 423   trace += xmlPathFile;
 424   trace += "'";
 425   anna::Logger::debug(trace, ANNA_FILE_LOCATION);
 426   );
 427   anna::xml::DocumentFile xmlDocument; // has private copy constructor defined but not implemented to avoid inhenrit/copy (is very heavy)
 428   anna::xml::DTDMemory xmlDTD;
 429   const anna::xml::Node *rootNode;
 430   xmlDocument.initialize(xmlPathFile.c_str()); // fail here is i/o error
 431   xmlDTD.initialize(ServicesDTD);
 432   try {
 433     rootNode = xmlDocument.parse(xmlDTD); // Parsing: fail here if xml violates dtd
 434   }
 435   catch (anna::RuntimeException &ex) {
 436     LOGWARNING(
 437         std::string msg = "Services DTD schema:\n\n";
 438     msg += ServicesDTD;
 439     anna::Logger::warning(msg, ANNA_FILE_LOCATION);
 440     );
 441     throw ex;
 442   }
 443
 444   LOGDEBUG(
 445       std::string trace = "Loaded XML file (";
 446   trace += xmlPathFile;
 447   trace += "):\n";
 448   trace += anna::xml::Compiler().apply(rootNode);
 449   anna::Logger::debug(trace, ANNA_FILE_LOCATION);
 450   );
 451   servicesFromXML(rootNode, eventOperation);
 452 }
 453
 454
 455 anna::Millisecond Launcher::checkTimeMeasure(const std::string &parameter, const std::string &value) throw(anna::RuntimeException) {
 456
 457   if(anna::functions::isLike("^[0-9]+$", value)) {  // para incluir numeros decimales: ^[0-9]+(.[0-9]+)?$
 458     int msecs;
 459     std::istringstream ( value ) >> msecs;
 460
 461     if(msecs > a_timeEngine->getMaxTimeout()) { // 600000 ms
 462       std::string msg = "Configuration value for '";
 463       msg += parameter;
 464       msg += "' ("; msg += value; msg += " msecs) is greater than allowed max timeout for timming engine: ";
 465       msg += anna::functions::asString(a_timeEngine->getMaxTimeout());
 466       throw RuntimeException(msg, ANNA_FILE_LOCATION);
 467     }
 468
 469     if(msecs > 300000) {
 470       std::string msg = "Configuration value for '";
 471       msg += parameter;
 472       msg += "' ("; msg += value; msg += " msecs) is perhaps very big (over 5 minutes).";
 473       LOGWARNING(anna::Logger::warning(msg, ANNA_FILE_LOCATION));
 474     }
 475
 476     if(msecs <= a_timeEngine->getResolution()) {
 477       std::string msg = "Configuration value for '";
 478       msg += parameter;
 479       msg += "' ("; msg += value; msg += " msecs) as any other time measure, must be greater than timming engine resolution: ";
 480       msg += anna::functions::asString(a_timeEngine->getResolution());
 481       throw RuntimeException(msg, ANNA_FILE_LOCATION);
 482     }
 483
 484     return (anna::Millisecond)msecs; // ok
 485   }
 486
 487   // Non-integer exception:
 488   std::string msg = "Configuration error for '";
 489   msg += parameter;
 490   msg += "' = '";
 491   msg += value;
 492   msg += "': must be a non-negative integer number";
 493   throw RuntimeException(msg, ANNA_FILE_LOCATION);
 494 }
 495
 496 bool Launcher::setWorkingNode(const std::string &name) throw() {
 497   bool result = false;
 498
 499   origin_hosts_it nodeIt = a_originHosts.find(name);
 500   if (nodeIt == a_originHosts.end()) {
 501     LOGWARNING(
 502         std::string msg = "Unknown node with name '"; msg += name; msg += "'. Ignoring ...";
 503     anna::Logger::warning(msg, ANNA_FILE_LOCATION);
 504     );
 505   }
 506   else {
 507     a_workingNode = const_cast<OriginHost*>(nodeIt->second);
 508     result = true;
 509   }
 510
 511   return result;
 512 }
 513
 514 OriginHost *Launcher::getOriginHost(const std::string &oh) const throw(anna::RuntimeException) {
 515   origin_hosts_it it = a_originHosts.find(oh);
 516   if (it != a_originHosts.end()) return it->second;
 517   throw anna::RuntimeException(anna::functions::asString("There is no origin host registered as '%s' (set Origin-Host avp correctly or force a specific host with 'node' operation)", oh.c_str()), ANNA_FILE_LOCATION);
 518 }
 519
 520 OriginHost *Launcher::getOriginHost(const anna::diameter::codec::Message &message) const throw(anna::RuntimeException) {
 521   std::string originHost = message.getAvp(anna::diameter::helpers::base::AVPID__Origin_Host)->getDiameterIdentity()->getValue();
 522   return (getOriginHost(originHost));
 523 }
 524
 525 void Launcher::updateOperatedOriginHostWithMessage(const anna::diameter::codec::Message &message) throw(anna::RuntimeException) {
 526   if (!a_operatedHost) // priority for working node by mean 'node' operation
 527     a_operatedHost = getOriginHost(message);
 528 }
 529
 530 OriginHost *Launcher::getOperatedHost() const throw(anna::RuntimeException) {
 531   if(!a_operatedHost)
 532     throw anna::RuntimeException("Node not identified (try to force a specific Origin-Host with 'node' operation)", ANNA_FILE_LOCATION);
 533
 534   return a_operatedHost;
 535 }
 536
 537 MyDiameterEntity *Launcher::getOperatedEntity() const throw(anna::RuntimeException) {
 538   MyDiameterEntity *result = getOperatedHost()->getEntity();
 539   if (!result)
 540     throw anna::RuntimeException("No entity configured for the operated node", ANNA_FILE_LOCATION);
 541   return result;
 542 }
 543
 544 MyLocalServer *Launcher::getOperatedServer() const throw(anna::RuntimeException) {
 545   MyLocalServer *result = getOperatedHost()->getDiameterServer();
 546   if (!result)
 547     throw anna::RuntimeException("No local server configured for the operated node", ANNA_FILE_LOCATION);
 548   return result;
 549 }
 550
 551 MyDiameterEngine *Launcher::getOperatedEngine() const throw(anna::RuntimeException) {
 552   return getOperatedHost()->getMyDiameterEngine(); // never will be NULL
 553 }
 554
 555 void Launcher::initialize()
 556 throw(anna::RuntimeException) {
 557   anna::comm::Application::initialize();
 558   CommandLine& cl(anna::CommandLine::instantiate());
 559   anna::comm::Communicator::WorkMode::_v workMode(anna::comm::Communicator::WorkMode::Single);
 560   a_communicator = new MyCommunicator(workMode);
 561   a_timeEngine = new anna::timex::Engine((anna::Millisecond)600000, a_admlMinResolution);
 562   TestManager::instantiate().setTimerController(a_timeEngine);
 563
 564   // Counters record procedure:
 565   const char *varname = "cntRecordPeriod";
 566   anna::Millisecond cntRecordPeriod = (cl.exists(varname)) ? checkTimeMeasure(varname, cl.getValue(varname)) : (anna::Millisecond)300000;
 567   if(cntRecordPeriod != 0) {
 568     a_counterRecorderClock = new MyCounterRecorderClock("Counters record procedure clock", cntRecordPeriod); // clock
 569     std::string cntDir = ".";
 570     if(cl.exists("cntDir")) cntDir = cl.getValue("cntDir");
 571     a_counterRecorder = new MyCounterRecorder(cntDir + anna::functions::asString("/Counters.Pid%d", (int)getPid()));
 572   }
 573
 574   // Testing framework:
 575   std::string tmDir = ".";
 576   if(cl.exists("tmDir")) tmDir = cl.getValue("tmDir");
 577   TestManager::instantiate().setReportsDirectory(tmDir);
 578
 579   // Tracing:
 580   if(cl.exists("trace"))
 581     anna::Logger::setLevel(anna::Logger::asLevel(cl.getValue("trace")));
 582
 583   // Load launcher services:
 584   loadServices(cl.getValue("services")); // before run (have components to be created)
 585 }
 586
 587 void Launcher::run()
 588 throw(anna::RuntimeException) {
 589   LOGMETHOD(anna::TraceMethod tm("Launcher", "run", ANNA_FILE_LOCATION));
 590   CommandLine& cl(anna::CommandLine::instantiate());
 591   anna::diameter::stack::Engine &stackEngine = anna::diameter::stack::Engine::instantiate();
 592
 593   // Start time:
 594   a_start_time.setNow();
 595
 596   // Initial working directory:
 597   char cwd[1024];
 598   if (getcwd(cwd, sizeof(cwd)) == NULL)
 599     throw anna::RuntimeException("Cannot retrieve initial working directory !!", ANNA_FILE_LOCATION);
 600   a_initialWorkingDirectory = cwd;
 601
 602   // Statistics:
 603   anna::statistics::Engine::instantiate().enable();
 604
 605   LOGINFORMATION(
 606       // Help on startup traces:
 607       anna::Logger::information(help(), ANNA_FILE_LOCATION);
 608   // Test messages dtd:
 609   std::string msg = "\n                     ------------- TESTMESSAGES DTD -------------\n";
 610   msg += anna::diameter::codec::MessageDTD;
 611   anna::Logger::information(msg, ANNA_FILE_LOCATION);
 612   );
 613
 614   // HTTP Server:
 615   if(cl.exists("httpServer")) {
 616     anna::comm::Network& network = anna::comm::Network::instantiate();
 617     std::string address;
 618     int port;
 619     anna::functions::getAddressAndPortFromSocketLiteral(cl.getValue("httpServer"), address, port);
 620     //const anna::comm::Device* device = network.find(Device::asAddress(address)); // here provide IP
 621     const anna::comm::Device* device = *((network.resolve(address)->device_begin())); // trick to solve
 622     a_httpServerSocket = new anna::comm::ServerSocket(anna::comm::INetAddress(device, port), cl.exists("httpServerShared") /* shared bind */, &anna::http::Transport::getFactory());
 623   }
 624
 625   ///////////////////////////////
 626   // Diameter library COUNTERS //
 627   ///////////////////////////////
 628   anna::diameter::comm::OamModule & oamDiameterComm = anna::diameter::comm::OamModule::instantiate();
 629   oamDiameterComm.initializeCounterScope(1);  // 1000 - 1999
 630   oamDiameterComm.enableCounters();
 631   oamDiameterComm.enableAlarms();
 632   anna::diameter::codec::OamModule & oamDiameterCodec = anna::diameter::codec::OamModule::instantiate();
 633   oamDiameterCodec.initializeCounterScope(2);  // 2000 - 2999
 634   oamDiameterCodec.enableCounters();
 635   oamDiameterCodec.enableAlarms();
 636   /////////////////
 637   // COMM MODULE //
 638   /////////////////
 639   /* Main events */
 640   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestReceived, "" /* get defaults for enum type*/, 0 /*1000*/);
 641   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::AnswerReceived,                 "", 1 /*1001*/);
 642   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestReceivedOnClientSession, "", 2 /*1002*/);
 643   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::AnswerReceivedOnClientSession,  "", 3 /*1003*/);
 644   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestReceivedOnServerSession, "", 4 /* etc. */);
 645   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::AnswerReceivedOnServerSession,  "", 5);
 646   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestSentOK,                  "", 6);
 647   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestSentNOK,                 "", 7);
 648   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::AnswerSentOK,                   "", 8);
 649   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::AnswerSentNOK,                  "", 9);
 650   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestSentOnClientSessionOK,   "", 10);
 651   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestSentOnClientSessionNOK,  "", 11);
 652   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::AnswerSentOnClientSessionOK,    "", 12);
 653   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::AnswerSentOnClientSessionNOK,   "", 13);
 654   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestSentOnServerSessionOK,   "", 14);
 655   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestSentOnServerSessionNOK,  "", 15);
 656   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::AnswerSentOnServerSessionOK,    "", 16);
 657   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::AnswerSentOnServerSessionNOK,   "", 17);
 658   /* Diameter Base (capabilities exchange & keep alive) */
 659   // as client
 660   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::CERSentOK,   "", 18);
 661   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::CERSentNOK,  "", 19);
 662   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::CEAReceived, "", 20);
 663   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::DWRSentOK,   "", 21);
 664   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::DWRSentNOK,  "", 22);
 665   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::DWAReceived, "", 23);
 666   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::DPRSentOK,   "", 24);
 667   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::DPRSentNOK,  "", 25);
 668   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::DPAReceived, "", 26);
 669   // as server
 670   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::CERReceived, "", 27);
 671   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::CEASentOK,   "", 28);
 672   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::CEASentNOK,  "", 29);
 673   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::DWRReceived, "", 30);
 674   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::DWASentOK,   "", 31);
 675   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::DWASentNOK,  "", 32);
 676   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::DPRReceived, "", 33);
 677   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::DPASentOK,   "", 34);
 678   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::DPASentNOK,  "", 35);
 679   /* server socket operations (enable/disable listening port for any local server) */
 680   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::ServerSocketsOpened, "", 36);
 681   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::ServerSocketsClosed, "", 37);
 682   /* Connectivity */
 683   // clients
 684   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::UnableToDeliverOverEntity,                  "", 38);
 685   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::LostAvailabilityOverClientSession,          "", 39);
 686   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RecoveredAvailabilityOverClientSession,     "", 40);
 687   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::LostAvailabilityOverServer,                 "", 41);
 688   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RecoveredAvailabilityOverServer,            "", 42);
 689   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::LostAvailabilityOverEntity,                 "", 43);
 690   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RecoveredAvailabilityOverEntity,            "", 44);
 691   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::LostAvailabilityOverEngineForEntities,      "", 45);
 692   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RecoveredAvailabilityOverEngineForEntities, "", 46);
 693   // servers
 694   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::UnableToDeliverToClient,                                    "", 47);
 695   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::LostConnectionForServerSession,                             "", 48);
 696   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::UnbindConnectionForServerSessionDueToInactivityTimeAnomaly, "", 49);
 697   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::CreatedConnectionForServerSession,                          "", 50);
 698   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::LostAvailabilityOverLocalServer,                            "", 51);
 699   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RecoveredAvailabilityOverLocalServer,                       "", 52);
 700   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::LostAvailabilityOverEngineForLocalServers,                  "", 53);
 701   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RecoveredAvailabilityOverEngineForLocalServers,             "", 54);
 702   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestSentExpired,  "", 55);
 703   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestSentOnClientSessionExpired,  "", 56);
 704   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestSentOnServerSessionExpired,  "", 57);
 705   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestRetransmitted,  "", 58);
 706   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestRetransmittedOnClientSession,  "", 59);
 707   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::RequestRetransmittedOnServerSession,  "", 60);
 708   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::AnswerReceivedUnknown,  "", 61);
 709   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::AnswerReceivedOnClientSessionUnknown,  "", 62);
 710   oamDiameterComm.registerCounter(anna::diameter::comm::OamModule::Counter::AnswerReceivedOnServerSessionUnknown,  "", 63);
 711   //////////////////
 712   // CODEC MODULE //
 713   //////////////////
 714   /* Avp decoding */
 715   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::AvpDecode__NotEnoughBytesToCoverAvpHeaderLength,                          "", 0 /*2000*/);
 716   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::AvpDecode__IncoherenceBetweenActivatedVBitAndZeroedVendorIDValueReceived, "", 1 /*2001*/);
 717   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::AvpDecode__IncorrectLength,                                               "", 2 /*2002*/);
 718   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::AvpDecode__DataPartInconsistence,                                         "", 3 /*2003*/);
 719   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::AvpDecode__UnknownAvpWithMandatoryBit,                                    "", 4 /*2004*/);
 720   /* Message decoding */
 721   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::MessageDecode__NotEnoughBytesToCoverMessageHeaderLength, "", 5 /*2005*/);
 722   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::MessageDecode__NotEnoughBytesToCoverMessageLength,       "", 6 /*2006*/);
 723   /* Avp validation */
 724   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::AvpValidation__EnumeratedAvpWithValueDoesNotComplyRestriction, "", 10 /*2010*/);
 725   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::AvpValidation__AvpFlagsDoesNotFulfillTheDefinedFlagRules,      "", 11 /*2011*/);
 726   /* Message validation */
 727   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::MessageValidation__UnknownOperationUnableToValidate, "", 12 /*2012*/);
 728   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::MessageValidation__OperationHaveIncoherentFlags,     "", 13 /*2013*/);
 729   /* Level validation */
 730   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::LevelValidation__MissingFixedRule,                                       "", 14 /*2014*/);
 731   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::LevelValidation__FailedRuleForCardinality,                               "", 15 /*2015*/);
 732   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::LevelValidation__FailedRuleForCardinalityLessThanNeeded,                 "", 16 /*2016*/);
 733   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::LevelValidation__FailedRuleForCardinalityMoreThanNeeded,                 "", 17 /*2017*/);
 734   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::LevelValidation__FailedGenericAvpRuleForCardinalityFoundDisregardedItem, "", 18 /*2018*/);
 735   oamDiameterCodec.registerCounter(anna::diameter::codec::OamModule::Counter::LevelValidation__FoundDisregardedItemsAndGenericAVPWasNotSpecified,      "", 19 /*2019*/);
 736
 737
 738   /////////////////////////////////
 739   // Counter recorder associated //
 740   /////////////////////////////////
 741   if(a_counterRecorderClock) {
 742     oamDiameterComm.setCounterRecorder(a_counterRecorder);
 743     oamDiameterCodec.setCounterRecorder(a_counterRecorder);
 744     anna::diameter::comm::ApplicationMessageOamModule::instantiate().setCounterRecorder(a_counterRecorder);
 745     a_timeEngine->activate(a_counterRecorderClock); // start clock
 746   }
 747
 748   // Log statistics concepts
 749   if(cl.exists("logStatisticSamples")) {
 750     std::string list = cl.getValue("logStatisticSamples");
 751     anna::statistics::Engine &statEngine = anna::statistics::Engine::instantiate();
 752
 753     if(list == "all") {
 754       if(statEngine.enableSampleLog(/* -1: all concepts */))
 755         LOGDEBUG(anna::Logger::debug("Sample log activation for all statistic concepts", ANNA_FILE_LOCATION));
 756     } else {
 757       anna::Tokenizer lst;
 758       lst.apply(cl.getValue("logStatisticSamples"), ",");
 759
 760       if(lst.size() >= 1) {
 761         anna::Tokenizer::const_iterator tok_min(lst.begin());
 762         anna::Tokenizer::const_iterator tok_max(lst.end());
 763         anna::Tokenizer::const_iterator tok_iter;
 764         int conceptId;
 765
 766         for(tok_iter = tok_min; tok_iter != tok_max; tok_iter++) {
 767           conceptId = atoi(anna::Tokenizer::data(tok_iter));
 768
 769           if(statEngine.enableSampleLog(conceptId))
 770             LOGDEBUG(anna::Logger::debug(anna::functions::asString("Sample log activation for statistic concept id = %d", conceptId), ANNA_FILE_LOCATION));
 771         }
 772       }
 773     }
 774   }
 775
 776
 777   // Start client connections //////////////////////////////////////////////////////////////////////////////////
 778   MyDiameterEntity *entity;
 779   for (origin_hosts_it it = a_originHosts.begin(); it != a_originHosts.end(); it++) {
 780     entity = it->second->getEntity();
 781     if (entity) entity->bind();
 782   }
 783
 784   // Go into communicator poll
 785   // Reconnection period (tcp reconnect retry time):
 786   const char *varname = "reconnectionPeriod";
 787   anna::Millisecond reconnectionPeriod = (cl.exists(varname)) ? checkTimeMeasure(varname, cl.getValue(varname)) : (anna::Millisecond)10000;
 788
 789   a_communicator->setRecoveryTime(reconnectionPeriod);
 790   if(cl.exists("httpServer")) a_communicator->attach(a_httpServerSocket);  // HTTP
 791   a_communicator->accept();
 792 }
 793
 794
 795 bool Launcher::getDataBlockFromHexFile(const std::string &pathfile, anna::DataBlock &db) const throw() {
 796   // Get hex string
 797   static char buffer[8192];
 798   std::ifstream infile(pathfile.c_str(), std::ifstream::in);
 799
 800   if(infile.is_open()) {
 801     infile >> buffer;
 802     std::string hexString(buffer, strlen(buffer));
 803     // Allow colon separator in hex string: we have to remove them before processing with 'fromHexString':
 804     hexString.erase(std::remove(hexString.begin(), hexString.end(), ':'), hexString.end());
 805     LOGDEBUG(
 806         std::string msg = "Hex string (remove colons if exists): ";
 807     msg += hexString;
 808     anna::Logger::debug(msg, ANNA_FILE_LOCATION);
 809     );
 810     anna::functions::fromHexString(hexString, db);
 811     // Close file
 812     infile.close();
 813     return true;
 814   }
 815
 816   return false;
 817 }
 818
 819 void Launcher::resetStatistics() throw() {
 820   if (a_workingNode) {
 821     a_workingNode->getMyDiameterEngine()->resetStatistics();
 822   }
 823   else {
 824     for (origin_hosts_it it = a_originHosts.begin(); it != a_originHosts.end(); it++) {
 825       it->second->getMyDiameterEngine()->resetStatistics();
 826     }
 827   }
 828 }
 829
 830 void Launcher::resetCounters() throw() {
 831   anna::diameter::comm::OamModule::instantiate().resetCounters();
 832   anna::diameter::comm::ApplicationMessageOamModule::instantiate().resetCounters();
 833   anna::diameter::codec::OamModule::instantiate().resetCounters();
 834 }
 835
 836 void Launcher::signalUSR2() throw(anna::RuntimeException) {
 837
 838   std::string inputFile = getSignalUSR2InputFile();
 839   std::string outputFile = getSignalUSR2OutputFile();
 840
 841   LOGNOTICE(
 842   std::string msg = "Captured signal SIGUSR2. Reading tasks at '";
 843   msg += inputFile;
 844   msg += "' (results will be written at '";
 845   msg += outputFile;
 846   msg += "')";
 847   anna::Logger::notice(msg, ANNA_FILE_LOCATION);
 848   );
 849
 850   // Operation:
 851   std::string line;
 852   std::string response_content;
 853   std::ifstream in_file(inputFile);
 854   std::ofstream out_file(outputFile);
 855
 856   if(!in_file.is_open()) throw RuntimeException("Unable to read tasks", ANNA_FILE_LOCATION);
 857   if(!out_file.is_open()) throw RuntimeException("Unable to write tasks", ANNA_FILE_LOCATION);
 858
 859   while(getline(in_file, line)) {
 860
 861     // Ignore comments and blank lines:
 862     if (line[0] == '#')  continue;
 863     if (std::string::npos == line.find_first_not_of(" \t")) continue;
 864
 865     LOGDEBUG(
 866         std::string msg = "Processing line: ";
 867     msg += line;
 868     anna::Logger::debug(msg, ANNA_FILE_LOCATION);
 869     );
 870
 871     try {
 872       eventOperation(line, response_content);
 873     } catch(RuntimeException &ex) {
 874       ex.trace();
 875     }
 876
 877     out_file << response_content << "\n";
 878   }
 879
 880   in_file.close();
 881   out_file << "EOF\n";
 882   out_file.close();
 883 }
 884
 885 std::string Launcher::help() const throw() {
 886   std::string result = "\n";
 887   result += "\n                     ------------- HELP -------------\n";
 888   result += "\n";
 889   result += "\nOVERVIEW";
 890   result += "\n--------";
 891   result += "\n";
 892   result += "\nThe ADML (ANNA Diameter MultiHost Launcher) process is a multi-host node with client and server";
 893   result += "\n capabilities as well as balancer (proxy) features. It could be used as diameter server (i.e. to";
 894   result += "\n simulate PCRF nodes, OCS systems, etc.), as diameter client (GGSNs, DPIs, etc.), and balancer";
 895   result += "\n systems to provide failover to external round-robin launchers. Also, auxiliary encoder/decoder/loader";
 896   result += "\n function could be deployed to reinterpret certain external flow and send it to another process.";
 897   result += "\n ";
 898   result += "\nThe ANNA::diameter_comm built-in module provides a great set of characteristics as multiple connections";
 899   result += "\n on both server and client side, definition for multiple-server entities (and not only two as standard";
 900   result += "\n establish as minimum), separate statistics analyzer per each resource, automatic CER/CEA and DWR/DWA";
 901   result += "\n generation, expiration control and many more features.";
 902   result += "\n";
 903   result += "\nThe ADML process can easily configure a many origin-host nodes as needed, which will have own endpoints.";
 904   result += "\nYou should avoid loop configurations (client and server for that client) because automatic forwarding,";
 905   result += "\n is implemented and this would get in a never ending cycle when a request is sent.";
 906   result += "\n";
 907   result += "\nProcess traces are dump on \"launcher.trace\" and could have any trace level (POSIX levels), usually";
 908   result += "\n 'debug' or 'warning'. See ANNA documentation for more details.";
 909   result += "\n";
 910   result += "\nAs any other ANNA process, context dump could be retrieved sending SIGUSR1 signal:";
 911   result += "\n   kill -10 <pid>";
 912   result += "\n    or";
 913   result += "\n   kill -s SIGUSR1 <pid>";
 914   result += "\n    and then";
 915   result += "\n   vi /var/tmp/anna.context.<pid>";
 916   result += "\n";
 917   result += "\nA complete xml report will show all the context information (counters, alarms, statistics,";
 918   result += "\n handlers, diameter stacks, etc.), and a powerful log module could dump all the events";
 919   result += "\n processed and flow information. Statistics could be analized at context dump and optionally";
 920   result += "\n written to disk as sample files (useful for graphs and spreadsheet reports) with all the";
 921   result += "\n measurements.";
 922   result += "\n";
 923   result += "\nAlso SIGUSR2 is handled for management purposes. We will talk later about this.";
 924   result += "\n";
 925   result += "\n";
 926   result += "\nCOMMAND LINE";
 927   result += "\n------------";
 928   result += "\n";
 929   result += "\nStart the launcher process without arguments in order to see all the startup configuration";
 930   result += "\n posibilities, many of which could be modified on the air through the management interface";
 931   result += "\n (we will talk later about this great feature). There is only one mandatory parameter which";
 932   result += "\n is the services definition: --services <services xml file>. You must follow the dtd schema";
 933   result += "\n to build a valid services xml file. Some basic examples are:";
 934   result += "\n";
 935   result += "\nClient configuration:";
 936   result += "\n";
 937   result += "\n<services>";
 938   result += "\n  <!-- Stacks -->";
 939   result += "\n  <stack id=\"0\" dictionary=\"dictionary.xml\"/>";
 940   result += "\n";
 941   result += "\n  <!-- Nodes -->";
 942   result += "\n  <node originHost=\"ADML-client\" applicationId=\"0\" entity=\"localhost:3868\"/>";
 943   result += "\n</services>";
 944   result += "\n";
 945   result += "\nServer configuration:";
 946   result += "\n";
 947   result += "\n<services>";
 948   result += "\n  <!-- Stacks -->";
 949   result += "\n  <stack id=\"0\" dictionary=\"dictionary.xml\"/>";
 950   result += "\n";
 951   result += "\n  <!-- Nodes -->";
 952   result += "\n  <node originHost=\"ADML-server\" applicationId=\"0\" diameterServer=\"localhost:3868\"/>";
 953   result += "\n</services>";
 954   result += "\n";
 955   result += "\nIf you act as a proxy or a translation agent, you need to combine both former setups, and probably";
 956   result += "\n will need to program the answers to be replied through the operations interface. To balance the";
 957   result += "\n traffic at your client side you shall use '--balance' and '--sessionBasedModelsClientSocketSelection'";
 958   result += "\n arguments in order to define the balancing behaviour. To make hybrid setups you only must mix the nodes:";
 959   result += "\n";
 960   result += "\nClient and server configuration:";
 961   result += "\n";
 962   result += "\n<services>";
 963   result += "\n  <!-- Stacks -->";
 964   result += "\n  <stack id=\"16777236\" dictionary=\"dictionary_Rx.xml\"/>";
 965   result += "\n  <stack id=\"16777238\" dictionary=\"dictionary_Gx.xml\"/>";
 966   result += "\n  <stack id=\"0\" dictionary=\"dictionary_base.xml\"/>";
 967   result += "\n";
 968   result += "\n  <!-- Nodes -->";
 969   result += "\n  <node originHost=\"ADML-Rx-client\" applicationId=\"16777236\" entity=\"localhost:3868\" cer=\"cer_Rx.xml\"/>";
 970   result += "\n  <node originHost=\"ADML-Gx-client\" applicationId=\"16777238\" entity=\"localhost:3868\" cer=\"cer_Gx.xml\"/>";
 971   result += "\n</services>";
 972   result += "\n";
 973   result += "\n";
 974   result += "\nThe process builds automatically CER and DWR messages as a client, but you could specify your own";
 975   result += "\n as shown in the hybrid former example. Note that the base protocol stack must be registered because";
 976   result += "\n the configuration corresponds to a multistack process which change the stack using the application-id";
 977   result += "\n processed (0 in the case of base protocol messages: CER, CEA, DWR, DWA, DPR, DPA).";
 978   result += "\n";
 979   result += "\nDYNAMIC OPERATIONS";
 980   result += "\n------------------";
 981   result += "\n";
 982   result += "\nADML supports several operations which could be reconized via HTTP interface or SIGUSR2 caugh.";
 983   result += "\nAn operation is specified by mean a string containing the operation name and needed arguments";
 984   result += "\n separated by pipes. These are the available commands:";
 985   result += "\n";
 986   result += "\n--------------------------------------------------------------------------------------- General purpose";
 987   result += "\n";
 988   result += "\nhelp                                 This help.";
 989   result += "\n";
 990   result += "\n--------------------------------------------------------------------------------------- Node management";
 991   result += "\n";
 992   result += "\nnode[|<name>]                         Selects a context working node by mean a registered name (origin-host).";
 993   result += "\n                                      All the subsequent operations will be forced to work with";
 994   result += "\n                                      this node, which makes possible some rare scenarios like";
 995   result += "\n                                      sending unexpected messages on remote peers. This is also";
 996   result += "\n                                      useful for some operations in order to restrict the scope";
 997   result += "\n                                      of action (statistics, communication visibility, etc.).";
 998   result += "\n                                      Empty parameter will show the current configuration.";
 999   result += "\n";
1000   result += "\nnode_auto                             Returns to the default behaviour (smart node selection).";
1001   result += "\n                                      Depending on the operation, this could imply a global";
1002   result += "\n                                      action scope, affecting to all the registered hosts.";
1003   result += "\n                                      This should be the normal configuration. Take into";
1004   result += "\n                                      account that if you fix the working node, this could";
1005   result += "\n                                      affect to things like test programming: communication";
1006   result += "\n                                      resources will override those which would be inferred";
1007   result += "\n                                      from programmed messages Origin-Host avps.";
1008   result += "\n";
1009   result += "\n------------------------------------------------------------------------------------ Parsing operations";
1010   result += "\n";
1011   result += "\ncode|<source_file>|<target_file>     Encodes source file (pathfile) into target file (pathfile).";
1012   result += "\ndecode|<source_file>|<target_file>   Decodes source file (pathfile) into target file (pathfile).";
1013   result += "\nloadxml|<source_file>                Reinterpret xml source file (pathfile).";
1014   result += "\n";
1015   result += "\n------------------------------------------------------------------------------------------- Hot changes";
1016   result += "\n";
1017   result += "\nservices[|source file]               Adds and starts the services specified in the xml file provided.";
1018   result += "\n                                      (if missing, the file 'services.xml' will be used). This is used";
1019   result += "\n                                      to load new nodes once the ADML is started, regardless if command";
1020   result += "\n                                      line '--services' parameter was used or not. Those services which";
1021   result += "\n                                      are not correctly loaded will be ignored to keep the process alive.";
1022   result += "\n                                     If you need to load services as deltas, you must firstly load the";
1023   result += "\n                                      diameter base dictionary with stack id 0, because all the nodes";
1024   result += "\n                                      will use this dictionary to encode/decode base protocol messages";
1025   result += "\n                                      managed by the communication engine.";
1026   result += "\n";
1027   result += "\ndiameterServerSessions|<integer>     Updates the maximum number of accepted connections to diameter";
1028   result += "\n                                      server socket.";
1029   result += "\ncontext[|target file]                Application context could also be written by mean this operation,";
1030   result += "\n                                      and not only through SIGUSR1. If optional path file is missing,";
1031   result += "\n                                      default '/var/tmp/anna.context.<pid>' will be used.";
1032   result += "\ncollect                              Reset statistics and counters to start a new test stage of";
1033   result += "\n                                      performance measurement. Context data can be written at";
1034   result += "\n                                      '/var/tmp/anna.context.<pid>' by mean 'kill -10 <pid>'.";
1035   result += "\n                                      or sending operation 'context|[target file]'.";
1036   result += "\n                                     This operation applies over all the registered host nodes";
1037   result += "\n                                      except if one specific working node has been set.";
1038   result += "\nforceCountersRecord                  Forces dump to file the current counters of the process.";
1039   result += "\nchange-dir[|directory]               Changes the execution point which could be fine to ease some";
1040   result += "\n                                     file system interaction tasks. Be care about some requirements";
1041   result += "\n                                     (for example if you have a user defined counters directory as";
1042   result += "\n                                     relative path this must exists from the new execution directory).";
1043   result += "\n                                     If nothing provided, initial working directory will be restored.";
1044   result += "\nshow-oam                             Dumps current counters of the process. This is also done at";
1045   result += "\n                                      process context dump.";
1046   result += "\nshow-stats                           Dumps statistics of the process. This is also done at process";
1047   result += "\n                                      context dump.";
1048   result += "\n";
1049   result += "\n<visibility action>[|<address>:<port>][|socket id]";
1050   result += "\n";
1051   result += "\n       Actions: hide, show (update state) and hidden, shown (query state).";
1052   result += "\n       Acts over a client session for messages delivery (except CER/A, DWR/A, DPR/A).";
1053   result += "\n       If missing server (first parameter) all applications sockets will be affected.";
1054   result += "\n       If missing socket (second parameter) for specific server, all its sockets will be affected.";
1055   result += "\n";
1056   result += "\n       All application client sessions are shown on startup, but standard delivery only use primary";
1057   result += "\n        server ones except if fails. Balance configuration use all the allowed sockets. You could also";
1058   result += "\n        use command line 'sessionBasedModelsClientSocketSelection' to force traffic flow over certain";
1059   result += "\n        client sessions, but for this, hide/show feature seems easier.";
1060   result += "\n";
1061   result += "\n--------------------------------------------------------------------------------------- Flow operations";
1062   result += "\n";
1063   result += "\nsendxml2e|<source_file>    Sends xml source file (pathfile) through configured entity.";
1064   result += "\nsendxml2c|<source_file>    Sends xml source file (pathfile) to client.";
1065   result += "\nanswerxml2e[|source_file]  Answer xml source file (pathfile) for incoming request with same code from entity.";
1066   result += "\n                           The answer is stored in a FIFO queue for a specific message code, then there are";
1067   result += "\n                           as many queues as different message codes have been programmed.";
1068   result += "\nanswerxml2c[|source_file]  Answer xml source file (pathfile) for incoming request with same code from client.";
1069   result += "\n                           The answer is stored in a FIFO queue for a specific message code, then there are";
1070   result += "\n                           as many queues as different message codes have been programmed.";
1071   result += "\nanswerxml<2e/2c>           List programmed answers (to entity/client) if no parameter provided.";
1072   result += "\nanswerxml<2e/2c>|dump      Write programmed answers (to entity/client) to file 'programmed_answer.<message code>.<sequence>',";
1073   result += "\n                           where 'sequence' is the order of the answer in each FIFO code-queue of programmed answers.";
1074   result += "\nanswerxml<2e/2c>|clear     Clear programmed answers (to entity/client).";
1075   result += "\nanswerxml<2e/2c>|exhaust   Disable the corresponding queue rotation, which is the default behaviour.";
1076   result += "\nanswerxml<2e/2c>|rotate    Enable the corresponding queue rotation, useful in performance tests.";
1077   result += "\n                           Rotation consists in add again to the queue, each element retrieved for answering.";
1078   result += "\n";
1079   result += "\nSend operations are available using hexadecimal content (hex formatted files) which also allow to test";
1080   result += "\nspecial scenarios (protocol errors):";
1081   result += "\n";
1082   result += "\nsendhex2e|<source_file>    Sends hex source file (pathfile) through configured entity.";
1083   result += "\nsendhex2c|<source_file>    Sends hex source file (pathfile) to client.";
1084   result += "\n";
1085   result += "\nAnswer programming in hexadecimal is not really neccessary (you could use send primitives) and also";
1086   result += "\n is intended to be used with decoded messages in order to replace things like hop by hop, end to end,";
1087   result += "\n subscriber id, session id, etc. Anyway you could use 'decode' operation and then program the xml created.";
1088   result += "\n";
1089   result += "\nIf a request is received, answer map (built with 'answerxml<2e/2c>' operations) will be";
1090   result += "\n checked to find a corresponding programmed answer to be replied(*). If no ocurrence is found,";
1091   result += "\n or answer message was received, the message is forwarded to the other side (entity or client),";
1092   result += "\n or nothing but trace when no peer at that side is configured. Answer to client have sense when";
1093   result += "\n diameter server socket is configured, answer to entity have sense when entity does.";
1094   result += "\n";
1095   result += "\nIn the most complete situation (process with both client and server side) there are internally";
1096   result += "\n two maps with N FIFO queues, one for each different message code within programmed answers.";
1097   result += "\nOne map is for answers towards the client, and the other is to react entity requests. Then in";
1098   result += "\n each one we could program different answers corresponding to different request codes received.";
1099   result += "\n";
1100   result += "\n(*) sequence values (hop-by-hop and end-to-end), Session-Id and Subscription-Id avps, are mirrored";
1101   result += "\n    to the peer which sent the request. If user wants to test a specific answer without changing it,";
1102   result += "\n    use sendxml<2e/2c>/sendhex<2e/2c> operations better than programming.";
1103   result += "\n";
1104   result += "\nBalance ('--balance' command line parameter) could be used to forward server socket receptions through";
1105   result += "\n entity servers by mean a round-robin algorithm. Both diameter server socket and entity targets should";
1106   result += "\n have been configured, that is to say: launcher acts as client and server. If no balance is used, an";
1107   result += "\n standard delivery is performed: first primary entity server, secondary when fails, etc.";
1108   result += "\n";
1109   result += "\n--------------------------------------------------------------------------- Processing types (log tags)";
1110   result += "\n";
1111   result += "\nUsed as log file extensions (when '--splitLog' is provided on command line) and context preffixes on log";
1112   result += "\n details when unique log file is dumped:";
1113   result += "\n";
1114   result += "\n   [sent2e/send2eError]   Send to entity (success/error)";
1115   result += "\n   [sent2c/send2cError]   Send to client (success/error)";
1116   result += "\n   [fwd2e/fwd2eError]     Forward to entity a reception from client (success/error)";
1117   result += "\n   [fwd2c/fwd2cError]     Forward to client a reception from entity (success/error)";
1118   result += "\n   [recvfc]               Reception from client";
1119   result += "\n   [recvfe]               Reception from entity";
1120   result += "\n   [req2c-expired]        A request sent to client has been expired";
1121   result += "\n   [req2e-expired]        A request sent to entity has been expired";
1122   result += "\n   [recvfc-ans-unknown]   Reception from client of an unknown answer (probably former [req2c-expired]";
1123   result += "\n                           has been logged)";
1124   result += "\n   [recvfe-ans-unknown]   Reception from entity of an unknown answer (probably former [req2e-expired]";
1125   result += "\n                           has been logged)";
1126   result += "\n   [retry]                Request retransmission";
1127   result += "\n";
1128   result += "\n------------------------------------------------------------------------------------------- Burst tests";
1129   result += "\n";
1130   result += "\nIn order to simplify user experience, burst category operations are only allowed in single host node";
1131   result += "\n configuration. Indeed, you could send messages with unmatched Origin-Host, and no warning is shown.";
1132   result += "\nAll the operations are performed through the unique host: if you need to use more interfaces, you may";
1133   result += "\n launch different ADML instances. Is nonsense to allow burst in a multi-host configured ADML, because";
1134   result += "\n this feature is not able to coordinate the messages.";
1135   result += "\n";
1136   result += "\nburst|<action>[|parameter]     Used for performance testing, we first program diameter requests";
1137   result += "\n                                messages in order to launch them from client side to the configured";
1138   result += "\n                                diameter entity. We could start the burst with an initial load";
1139   result += "\n                                (non-asynchronous sending), after this, a new request will be sent";
1140   result += "\n                                per answer received or expired context. There are 10 actions: clear,";
1141   result += "\n                                load, start, push, pop, stop, repeat, send, goto and look.";
1142   result += "\n";
1143   result += "\n   burst|clear                 Clears all loaded burst messages.";
1144   result += "\n   burst|load|<source_file>    Loads the next diameter message into launcher burst.";
1145   result += "\n   burst|start|<initial load>  Starts (or restarts if already in progress) the message sending with";
1146   result += "\n                                a certain initial load.";
1147   result += "\n   burst|push|<load amount>    Sends specific non-aynchronous load.";
1148   result += "\n   burst|pop|<release amount>  Skip send burst messages in order to reduce over-the-air requests.";
1149   result += "\n                               Popping all OTA requests implies burst stop because no more answer";
1150   result += "\n                                will arrive to the process. Burst output file (--burstLog command";
1151   result += "\n                                line parameter) shows popped messages with crosses (x). Each cross";
1152   result += "\n                                represents one received answer for which no new request is sent.";
1153   result += "\n   burst|stop                  Stops the burst cycle. You can resume pushing 1 load amount.";
1154   result += "\n   burst|repeat[|[yes]|no]     Restarts the burst launch when finish. If initial load or push load";
1155   result += "\n                                amount is greater than burst list size, they will be limited when";
1156   result += "\n                                the list is processed except when repeat mode is enabled.";
1157   result += "\n   burst|send|<amount>         Sends messages from burst list. The main difference with start/push";
1158   result += "\n                                operations is that burst won't be awaken. Externally we could control";
1159   result += "\n                                sending time (no request will be sent for answers).";
1160   result += "\n   burst|goto|<order>          Updates current burst pointer position.";
1161   result += "\n   burst|look[|order]          Show programmed burst message for order provided, current when missing.";
1162   result += "\n";
1163   result += "\n-------------------------------------------------------------------------------------- Advanced testing";
1164   result += "\n";
1165   result += "\n                           Burst mode only allows single interface interaction. For multiple interface";
1166   result += "\n                            (origin-host) coordination, you could use the advanced test cases programming:";
1167   result += "\n";
1168   result += "\n";
1169   result += "\n   test|<id>|<command>[|parameters]";
1170   result += "\n";
1171   result += "\n                           Adds a new step to the test case with provided identifier. If provided identifier";
1172   result += "\n                            is not registered yet, a new test case will be created with that value and the";
1173   result += "\n                            step will be added as the first. For a specific 'id', the steps are stored in";
1174   result += "\n                            order as they are programmed. Check possible runtime exceptions when adding a";
1175   result += "\n                            new step because those which fail, will be ignored/skipped during test case";
1176   result += "\n                            programming giving an incomplete sequence invalid for the testing purpose.";
1177   result += "\n";
1178   result += "\n                           <id>: integer number, normally monotonically increased for each test case. Some external";
1179   result += "\n                                 script/procedure shall clone a test case template in order to build a collection";
1180   result += "\n                                 of independent and coherent test cases (normally same type) with different context";
1181   result += "\n                                 values (Session-Id, Subscriber-Id, etc.).";
1182   result += "\n";
1183   result += "\n                           <command>: commands to be executed for the test id provided. Each command programmed";
1184   result += "\n                                      constitutes a test case 'step', numbered from 1 to N.";
1185   result += "\n";
1186   result += "\n                              timeout|<msecs>            Sets an asynchronous timer to restrict the maximum timeout";
1187   result += "\n                                                          until last test step. Normally, this command is invoked";
1188   result += "\n                                                          in the first step, anyway it measures the time from the";
1189   result += "\n                                                          execution point whatever it is. The expiration will abort";
1190   result += "\n                                                          the test if still running. One or more timeouts could be";
1191   result += "\n                                                          programmed (not usual), but the more restrict will apply.";
1192   result += "\n                                                         It is highly recommended to program a initial timeout step,";
1193   result += "\n                                                          or the test case could be eternally in-progress.";
1194   result += "\n";
1195   result += "\n                              sendxml2e|<source_file>[|<step number>]";
1196   result += "\n                                                         Sends xml source file (pathfile) to entity (it would be a";
1197   result += "\n                                                          'forward' event if it came through local server endpoint).";
1198   result += "\n                                                         The step number should be provided for answers to indicate";
1199   result += "\n                                                          the 'wait for request' corresponding step. If you miss this";
1200   result += "\n                                                          reference, the sequence information (hop-by-hop, end-to-end)";
1201   result += "\n                                                          will be sent as they are in the answer xml message (realize";
1202   result += "\n                                                          the difficulty of predicting these information). Be sure to";
1203   result += "\n                                                          refer to a 'wait for request' step. Conditions like 'regexp'";
1204   result += "\n                                                          (as we will see later) are not verified.";
1205   result += "\n                                                         In the case of requests, the step number is used to force the";
1206   result += "\n                                                          copy of Session-Id value from the referred step.";
1207   result += "\n";
1208   result += "\n                              sendxml2c|<source_file>[|<step number>]";
1209   result += "\n                                                         Sends xml source file (pathfile) to client (it would be a";
1210   result += "\n                                                          'forward' event if it came through remote server endpoint).";
1211   result += "\n                                                         Same commented for 'sendxml2e' regarding the step number.";
1212   result += "\n";
1213   result += "\n                              delay|<msecs>              Blocking step until the time lapse expires. Useful to give ";
1214   result += "\n                                                          some cadence control and time schedule for a specific case.";
1215   result += "\n                                                         A value of 0 could be used as a dummy step.";
1216   result += "\n                              wait<fe/fc>|<condition>    Blocking step until condition is fulfilled. The message could";
1217   result += "\n                                                          received from entity (waitfe) or from client (waitfc).";
1218   result += "\n";
1219   result += "\n                              wait<fe/fc>-regexp|<regexp>";
1220   result += "\n                                                         Wait condition, from entity (waitfe-regexp) or client (waitfc-regexp)";
1221   result += "\n                                                          to match the serialized xml content for received messages. CPU cost";
1222   result += "\n                                                          is bigger than the former ones because the whole message must be";
1223   result += "\n                                                          decoded and converted to xml instead of doing a direct hexadecimal";
1224   result += "\n                                                          buffer search. The main advantage is the great flexibility to identify";
1225   result += "\n                                                          any content with a regular expression.";
1226   result += "\n";
1227   result += "\n                              sh-command|<script>        External execution for script/executable via shell through a dedicated";
1228   result += "\n                                                          thread, providing the command and parameters. You could use dynamic";
1229   result += "\n                                                          variables ##<tag> to have more flexibility:";
1230   result += "\n                                                             Test pool cycle id: "; result += SH_COMMAND_TAG_FOR_REPLACE__CYCLE_ID;
1231   result += "\n                                                             Test case id:       "; result += SH_COMMAND_TAG_FOR_REPLACE__TESTCASE_ID;
1232   result += "\n                                                             Test step id:       "; result += SH_COMMAND_TAG_FOR_REPLACE__TESTSTEP_ID;
1233   result += "\n";
1234   result += "\n                                                         For example, your command could be something like this:";
1235   result += "\n                                                          insert_sql_"; result += SH_COMMAND_TAG_FOR_REPLACE__TESTCASE_ID; result += ".sh -db dbname --verbose";
1236   result += "\n                                                             > /tmp/cycle-"; result += SH_COMMAND_TAG_FOR_REPLACE__CYCLE_ID;
1237   result += ".testcase-"; result += SH_COMMAND_TAG_FOR_REPLACE__TESTCASE_ID;
1238   result += ".teststep-"; result += SH_COMMAND_TAG_FOR_REPLACE__TESTSTEP_ID;
1239   result += ".out";
1240   result += "\n                                                         Try to redirect stdout and stderr to avoid ADML output contamination";
1241   result += "\n                                                          with the possible outputs from the scripts. You could also put your";
1242   result += "\n                                                          job in background although sh-command will return 0-value immediately.";
1243   result += "\n";
1244   result += "\n                           <condition>: Optional parameters which must be fulfilled to continue through the next step.";
1245   result += "\n                                        Any received message over diameter interfaces will be evaluated against the";
1246   result += "\n                                         corresponding test case starting from the current step until the first one";
1247   result += "\n                                         whose condition is fulfilled. If no condition is fulfilled the event will be";
1248   result += "\n                                         classified as 'uncovered' (normally a test case bad configuration, or perhaps";
1249   result += "\n                                         a real unexpected message).";
1250
1251   // TODO(***)
1252   //  result += "\n                                        The way to identify the test case, is through registered Session-Id values for";
1253   //  result += "\n                                         programmed requests. But this depends on the type of node. Acting as clients,";
1254   //  result += "\n                                         requests received have Session-Id values which are already registered with";
1255   //  result += "\n                                         one test case, causing an error if not found. Acting as servers, requests are";
1256   //  result += "\n                                         received over a diameter local server from a client which are generating that";
1257   //  result += "\n                                         Session-Id values. Then we know nothing about such values. The procedure in";
1258   //  result += "\n                                         this case is find out a test case not-started containing a condition which";
1259   //  result += "\n                                         comply with the incoming message, and reactivates it.";
1260   // The other solution: register Session-Id values for answers send to client from a local diameter server.
1261
1262   result += "\n                                        How to answer: a wait condition for a request will store the incoming message";
1263   result += "\n                                         which fulfills that condition. This message is useful together with the peer";
1264   result += "\n                                         connection source in a further send step configured with the corresponding";
1265   result += "\n                                         response. You could also insert a delay between wait and send steps to be";
1266   result += "\n                                         more realistic (processing time simulation in a specific ADML host node).";
1267   result += "\n                                         Always, a response send step will get the needed information from the most";
1268   result += "\n                                         recent wait step finding in reverse order (note that some race conditions";
1269   result += "\n                                         could happen if your condition is not specific enough).";
1270
1271   result += "\n";
1272   result += "\n                                        Condition format:";
1273   result += "\n";
1274   result += "\n                                           [code]|[bitR]|[hopByHop]|[applicationId]|[sessionId]|[resultCode]|[msisdn]|[imsi]|[serviceContextId]";
1275   result += "\n";
1276   result += "\n                                             code: integer number";
1277   result += "\n                                             bitR: 1 (request), 0 (answer)";
1278   result += "\n                                             hopByHop: integer number or request send step reference: #<step number>";
1279   result += "\n";
1280   result += "\n                                                       Using the hash reference, you would indicate a specific wait condition";
1281   result += "\n                                                        for answers. The step number provided must correspond to any of the";
1282   result += "\n                                                        previous send commands (sendxml2e/sendxml2c) configured for a request.";
1283   result += "\n                                                       This 'hop-by-hop' variant eases the wait condition for answers in the";
1284   result += "\n                                                        safest way.";
1285   result += "\n";
1286   result += "\n                                             applicationId: integer number";
1287   result += "\n                                             sessionId: string";
1288   result += "\n                                             resultCode: integer number";
1289   result += "\n                                             msisdn: string";
1290   result += "\n                                             imsi: string";
1291   result += "\n                                             serviceContextId: string";
1292   result += "\n";
1293   result += "\n                                        Take into account these rules, useful in general:";
1294   result += "\n";
1295   result += "\n                                           - Be as much specific as possible defining conditions to avoid ambiguity sending";
1296   result += "\n                                             messages out of context due to race conditions. Although you could program several";
1297   result += "\n                                             times similar conditions, some risky practices will throw a warning trace (if you";
1298   result += "\n                                             repeat the same condition within the same test case).";
1299   result += "\n                                           - Adding a ResultCode and/or HopByHop to the condition are only valid waiting answers.";
1300   result += "\n                                           - Requests hop-by-hop values must be different for all the test case requests.";
1301   result += "\n                                             RFC says that a hop by hop must be unique for a specific connection, something that";
1302   result += "\n                                             could be difficult to manage if we have multiple available connections from client";
1303   result += "\n                                             side endpoint (entity or local server), even if we would have only one connection but";
1304   result += "\n                                             several host interfaces. It is enough to configure different hop-by-hop values within";
1305   result += "\n                                             each test case, because on reception, the Session-Id is used to identify that test case.";
1306   result += "\n";
1307   result += "\n";
1308   result += "\n";
1309   result += "\n";
1310   result += "\n                           Programming example:";
1311   result += "\n";
1312   result += "\n                              Basic Rx/Gx scenary: PCEF (Gx) - PCRF - AF (Rx)";
1313   result += "\n";
1314   result += "\n                              test|1|timeout|5000                  (step 1: whole time requirement is 5 seconds)";
1315   result += "\n                              test|1|sendxml2e|CCR-I.xml           (step 2: imagine this xml uses the Session-Id 'SGx')";
1316   result += "\n                              test|1|waitfe|272|0|||SGx|2001       (step 3: waits the CCA for the CCR-I with Result-Code = DIAMETER_SUCCESS)";
1317   result += "\n                              test|1|sendxml2e|AAR-flows.xml       (step 4: imagine this xml uses the Session-Id 'SRx')";
1318   result += "\n                              test|1|waitfe|265|0|||SRx|2001       (step 5: waits the AAA for the AAR-flows with Result-Code = DIAMETER_SUCCESS)";
1319   result += "\n                              test|1|waitfe|258|1|||SGx            (step 6: waits the RAR (install policies) from the PCRF server)";
1320   result += "\n                              test|1|sendxml2e|RAA-install.xml|6   (step 7: sends the response for the RAR)";
1321   result += "\n                              test|1|sendxml2e|CCR-T.xml           (step 8: termination of the Gx session, imagine this xml puts hop-by-hop 'H1')";
1322   result += "\n                              test|1|waitfe|272|0|H1||SGx|2001     (step 9: waits the CCA for the CCR-T with Result-Code = DIAMETER_SUCCESS and hop-by-hop 'H1')";
1323   result += "\n                              test|1|waitfe|258|1|||SGx            (step 10: waits the RAR (remove policies) from the PCRF server)";
1324   result += "\n                              test|1|sendxml2e|RAA-remove.xml|10   (step 11: sends the response for the RAR)";
1325   result += "\n";
1326   result += "\n                              Notes: We added an additional condition in step 9: the hop-by-hop. When we program the corresponding";
1327   result += "\n                                      source request (CCR-T), we configured the value 'H1' for the hop-by-hop. This is an 'application";
1328   result += "\n                                      value' because the real hop-by-hop transported through the client connection is managed by the";
1329   result += "\n                                      diameter stack. But when returned, the transaction pool resolve the original value. This feature";
1330   result += "\n                                      is necessary to ease the implementation of certain diameter agents (proxies for example). In our";
1331   result += "\n                                      case, we could format the hop-by-hop values within the request templates with total freedom to";
1332   result += "\n                                      improve the programmed conditions.";
1333   result += "\n";
1334   result += "\n                                     In the case of 'waiting for requests' is not such easy. Indeed, steps 6 and 10 will write a warning";
1335   result += "\n                                      because they are the same condition. We know that we are not going to have any problem because";
1336   result += "\n                                      such events are blocking-protected regarding logic-dependent messages (CCR-T), and race condition";
1337   result += "\n                                      is absolutely strange in this case.";
1338   result += "\n";
1339   result += "\n                                     You could speed up the test case moving forward steps like 3 & 5, understood as non-strict requirements";
1340   result += "\n                                      to continue testing. Anyway, remember that test cases should be as real as possible, and that there";
1341   result += "\n                                      are many ways to increase the load rate as we will see in next section (test cases execution).";
1342   result += "\n";
1343   result += "\n                                     Other simplifications: the steps 3, 5 and 9 can be replaced by";
1344   result += "\n";
1345   result += "\n                                        test|1|waitfe||0|#2";
1346   result += "\n                                        test|1|waitfe||0|#4";
1347   result += "\n                                        test|1|waitfe||0|#8";
1348   result += "\n";
1349   result += "\n                                        which means that hop-by-hop must be retrieved from steps 2, 4 and 8 respectively,";
1350   result += "\n                                        and the expected message shall be an answer. Normally you will add other conditions,";
1351   result += "\n                                        for example a DIAMETER_SUCCESS result (adding 2001 as Result-Code).";
1352   result += "\n";
1353   result += "\nTest cases execution:";
1354   result += "\n";
1355   result += "\n";
1356   result += "\n   test|ttps|<amount>            Starts/resume the provided number of test ticks per second (ttps). The ADML starts";
1357   result += "\n                                 with the event trigger system suspended, and this operation is neccessary to begin";
1358   result += "\n                                 those cases which need this time event (internal triggering). Some other test cases";
1359   result += "\n                                 could be started through external events (first test case event could be programmed";
1360   result += "\n                                 to wait specific message), but is not usual this external mode and neither usual to";
1361   result += "\n                                 mix triggering types. Normally, you will pause/stop new test launchs providing 0 as";
1362   result += "\n                                 ttps value, and also you could dynamically modify the load rate updating that value.";
1363   result += "\n                                 If a test case has N messages then 'ttps * N' will be the virtual number of messages";
1364   result += "\n                                 managed per second when no bottleneck exists.";
1365   result += "\n";
1366   result += "\n                                 Provide 0 in order to stop the timer triggering.";
1367   result += "\n";
1368   result += "\n                                 The timer manager resolution currently harcoded allows a maximum  of ";
1369   result += anna::functions::asString(1000/a_admlMinResolution); result += " events";
1370   result += "\n                                 per second. To reach greater rates ADML will join synchronously the needed number of";
1371   result += "\n                                 new time-triggered test cases per a single event, writting a warning-level trace to";
1372   result += "\n                                 advice about the risk of burst sendings and recommend launching multiple instances";
1373   result += "\n                                 to achieve such load with a lower rate per instance.";
1374   result += "\n";
1375   result += "\n   test|next[|<sync-amount>]     Forces the execution of the next test case(s) without waiting for test manager tick.";
1376   result += "\n                                 Provide an integer value for 'sync-amount' to send a burst synchronous amount of the";
1377   result += "\n                                 next programmed test cases (1 by default). This event works regardless the timer tick";
1378   result += "\n                                 function, but it is normally used with the test manager tick stopped.";
1379   result += "\n";
1380   result += "\n   test|ip-limit[|amount]        In-progress limit of test cases. No new test cases will be launched over this value";
1381   result += "\n                                 (test Manager tick work will be ignored). Zero-value is equivalent to stop the clock.";
1382   result += "\n                                 tick, -1 is used to specify 'no limit' which is the default. If missing amount, the";
1383   result += "\n                                 limit and current amount of in-progress test cases will be shown.";
1384   result += "\n";
1385   result += "\n   test|goto|<id>                Updates current test pointer position.";
1386   result += "\n";
1387   result += "\n   test|look[|id]                Show programmed test case for id provided, current 'in-process' test case when missing.";
1388   result += "\n                                 Test cases reports are not dumped on process context (too many information in general).";
1389   result += "\n                                 The report contains context information in every moment: this operation acts as a snapshot.";
1390   result += "\n";
1391   result += "\n   test|interact|amount|id       Makes interactive a specific test case id. The amount is the margin of execution steps";
1392   result += "\n                                 to be done. Normally, we will execute 'test|interact|0|<test case id>', which means that";
1393   result += "\n                                 the test case is selected to be interactive, but no step is executed. Then you have to";
1394   result += "\n                                 interact with positive amounts (usually 1), executing the provided number of steps if";
1395   result += "\n                                 they are ready and fulfill the needed conditions. The value of 0, implies no execution";
1396   result += "\n                                 steps margin, which could be useful to 'freeze' a test in the middle of its execution.";
1397   result += "\n                                 You could also provide -1 to make it non-interactive resuming it from the current step.";
1398   result += "\n";
1399   result += "\n   test|reset|<[soft]/hard>[|id] Reset the test case for id provided, all the tests when missing. It could be hard/soft:";
1400   result += "\n                                 - hard: you probably may need to stop the load rate before. This operation initializes";
1401   result += "\n                                         all test cases regardless their states.";
1402   result += "\n                                 - soft: only for finished cases (those with 'Success' or 'Failed' states). It does not";
1403   result += "\n                                         affect to test cases with 'InProgress' state.";
1404   result += "\n";
1405   result += "\n   test|repeats|<amount>         Restarts the whole programmed test list when finished the amount number of times (repeats";
1406   result += "\n                                 forever if value -1 is provided). This is disabled by default (amount = 0): testing trigger";
1407   result += "\n                                 system will enter suspended state until new ttps operation is received and a soft reset has";
1408   result += "\n                                 been done before. Test cases state & data will be reset (when achieved again), but general";
1409   result += "\n                                 statistics and counters will continue measuring until reset with 'collect' operation.";
1410   result += "\n";
1411   result += "\n   test|clear                    Clears all the programmed test cases and stop testing (if in progress).";
1412   result += "\n";
1413   result += "\n   test|summary                  Test manager general report (number of test cases, counts by state, global configuration,";
1414   result += "\n                                 forced in-progress limitation, reports visibility, etc.). Be careful when you have reports";
1415   result += "\n                                 enabled because the programmed test cases dumps could be heavy (anyway you could enable the";
1416   result += "\n                                 dumps separately, for any of the possible states: Initialized, InProgress, Failed, Success).";
1417   result += "\n";
1418   result += "\n   test|report|<initialized/in-progress/failed/success/[all]/none>[|[yes]|no]";
1419   result += "\n";
1420   result += "\n                                 Enables/disables report generation for a certain test case state: initialized, in-progress,";
1421   result += "\n                                 failed or success (also 'all' and 'none' reserved words could be used). This applies to report";
1422   result += "\n                                 summary (former described operation) and automatic dumps during testing where only failed or";
1423   result += "\n                                 successful states will appear: every time a test case is finished its xml representation will";
1424   result += "\n                                 be dump on a file under the execution directory (or the one configured in process command-line";
1425   result += "\n                                 'tmDir') with the name:";
1426   result += "\n";
1427   result += "\n                                    'cycle-<cycle id>.testcase-<test case id>.xml'.";
1428   result += "\n";
1429   result += "\n                                 By default, all the states are disabled to avoid IO overload. In most of cases not all the";
1430   result += "\n                                 tests are going to fail then you could enable only such failed dumps. Anyway you could set";
1431   result += "\n                                 the reports visibility to fit your needs in a given situation.";
1432   result += "\n";
1433   result += "\n   test|report-hex[|[yes]|no]    Reports could include the diameter messages in hexadecimal format. Disabled by default.";
1434   result += "\n";
1435   result += "\n";
1436   result += "\nUSING OPERATIONS INTERFACE";
1437   result += "\n--------------------------";
1438   result += "\n";
1439   result += "\n------------------------------------------------------------------------- Operations via HTTP interface";
1440   result += "\n";
1441   result += "\nAll the operations described above can be used through the optional HTTP interface. You only have";
1442   result += "\n to define the http server at the command line with something like: '--httpServer localhost:9000'.";
1443   result += "\nTo send the task, we shall build the http request body with the operation string. Some examples";
1444   result += "\n using curl client could be:";
1445   result += "\n";
1446   result += "\n   curl -m 1 --data \"diameterServerSessions|4\" localhost:9000";
1447   result += "\n   curl -m 1 --data \"code|ccr.xml\" localhost:9000";
1448   result += "\n   curl -m 1 --data \"decode|ccr.hex\" localhost:9000";
1449   result += "\n   curl -m 1 --data \"sendxml2e|ccr.xml\" localhost:9000";
1450   result += "\n   etc.";
1451   result += "\n";
1452   result += "\n------------------------------------------------------------------------- Operations via SIGUSR2 signal";
1453   result += "\n";
1454   result += "\nThe alternative using SIGUSR2 signal requires the creation of the task(s) file which will be read at";
1455   result += "\n signal event:";
1456   result += "\n   echo \"<<operation>\" > "; result += getSignalUSR2InputFile();
1457   result += "\n    then";
1458   result += "\n   kill -12 <pid>";
1459   result += "\n    or";
1460   result += "\n   kill -s SIGUSR2 <pid>";
1461   result += "\n    and then see the results:";
1462   result += "\n   cat "; result += getSignalUSR2OutputFile();
1463   result += "\n";
1464   result += "\n   (this file is ended with EOF final line, useful managing huge batch files to ensure the job completion)";
1465   result += "\n";
1466   result += "\nYou could place more than one line (task) in the input file. Output reports will be appended in that";
1467   result += "\n case over the output file. Take into account that all the content of the task file will be executed";
1468   result += "\n sinchronously by the process. If you are planning traffic load, better use the asynchronous http";
1469   result += "\n interface.";
1470   result += "\n";
1471   result += "\n";
1472
1473   return result;
1474 }
1475
1476 void Launcher::eventOperation(const std::string &operation, std::string &response_content) throw(anna::RuntimeException) {
1477   LOGMETHOD(anna::TraceMethod tm("Launcher", "eventOperation", ANNA_FILE_LOCATION));
1478   if (operation == "") return; // ignore
1479   LOGDEBUG(anna::Logger::debug(operation, ANNA_FILE_LOCATION));
1480
1481   // Default response:
1482   response_content = "Operation processed with exception: ";
1483   response_content += operation;
1484   std::string opt_response_content = ""; // aditional response content
1485   anna::DataBlock db_aux(true);
1486   anna::diameter::codec::Message codecMsg; // auxiliary codec message
1487
1488   // Singletons:
1489   CommandLine& cl(anna::CommandLine::instantiate());
1490   TestManager &testManager = TestManager::instantiate();
1491
1492
1493   ///////////////////////////////////////////////////////////////////
1494   // Simple operations without arguments:
1495
1496   // Help:
1497   if(operation == "help") {
1498     response_content = help();
1499     return;
1500   }
1501
1502   // Reset performance data:
1503   if(operation == "collect") {
1504     resetCounters();
1505     resetStatistics();
1506     response_content = "All process counters & statistic information have been reset";
1507     return;
1508   }
1509
1510   // Counters dump on demand:
1511   if(operation == "forceCountersRecord") {
1512     forceCountersRecord();
1513     response_content = "Current counters have been dump to disk";
1514     return;
1515   }
1516
1517   // OAM & statistics:
1518   if(operation == "show-oam") {
1519     anna::xml::Node root("root");
1520     response_content = anna::xml::Compiler().apply(oamAsXML(&root));
1521     return;
1522   }
1523   if(operation == "show-stats") {
1524     anna::xml::Node root("root");
1525     response_content = anna::xml::Compiler().apply(statsAsXML(&root));
1526     return;
1527   }
1528
1529   ///////////////////////////////////////////////////////////////////
1530   // Tokenize operation
1531   Tokenizer params;
1532   params.apply(operation, "|", "<null>" /* allow contiguous separators */);
1533   int numParams = params.size() - 1;
1534
1535   // Get the operation type and parameters:
1536   Tokenizer::const_iterator tok_iter = params.begin();
1537   std::string opType = Tokenizer::data(tok_iter);
1538   std::string param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11;
1539   if(numParams >= 1) { tok_iter++; param1 = Tokenizer::data(tok_iter); }
1540   if(numParams >= 2) { tok_iter++; param2 = Tokenizer::data(tok_iter); }
1541   if(numParams >= 3) { tok_iter++; param3 = Tokenizer::data(tok_iter); }
1542   // Tests conditions
1543   if(numParams >= 4) { tok_iter++; param4 = Tokenizer::data(tok_iter); }
1544   if(numParams >= 5) { tok_iter++; param5 = Tokenizer::data(tok_iter); }
1545   if(numParams >= 6) { tok_iter++; param6 = Tokenizer::data(tok_iter); }
1546   if(numParams >= 7) { tok_iter++; param7 = Tokenizer::data(tok_iter); }
1547   if(numParams >= 8) { tok_iter++; param8 = Tokenizer::data(tok_iter); }
1548   if(numParams >= 9) { tok_iter++; param9 = Tokenizer::data(tok_iter); }
1549   if(numParams >= 10) { tok_iter++; param10 = Tokenizer::data(tok_iter); }
1550   if(numParams >= 11) { tok_iter++; param11 = Tokenizer::data(tok_iter); }
1551   // Remove '<null>' artificial token to ease further checkings:
1552   if (param1 == "<null>") param1 = "";
1553   if (param2 == "<null>") param2 = "";
1554   if (param3 == "<null>") param3 = "";
1555   if (param4 == "<null>") param4 = "";
1556   if (param5 == "<null>") param5 = "";
1557   if (param6 == "<null>") param6 = "";
1558   if (param7 == "<null>") param7 = "";
1559   if (param8 == "<null>") param8 = "";
1560   if (param9 == "<null>") param9 = "";
1561   if (param10 == "<null>") param10 = "";
1562   if (param11 == "<null>") param11 = "";
1563
1564   // No operation has more than 2 arguments except 'test' ...
1565   if(opType != "test" && numParams > 2)
1566     throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
1567
1568
1569   // Check the number of parameters:
1570   bool wrongBody = false;
1571
1572   if((opType == "change-dir") && (numParams > 1)) wrongBody = true;
1573   if((opType == "node") && (numParams > 1)) wrongBody = true;
1574
1575   if((opType == "node_auto") && (numParams > 0)) wrongBody = true;
1576
1577   if(((opType == "code") || (opType == "decode")) && (numParams != 2)) wrongBody = true;
1578
1579   if(((opType == "sendxml2e") || (opType == "sendhex2e")) && (numParams != 1)) wrongBody = true;
1580
1581   if((opType == "burst") && (numParams < 1)) wrongBody = true;
1582
1583   if((opType == "test") && (numParams < 1)) wrongBody = true;
1584
1585   if(((opType == "sendxml2c") || (opType == "sendhex2c") || (opType == "loadxml") || (opType == "diameterServerSessions")) && (numParams != 1)) wrongBody = true;
1586
1587   if(wrongBody) {
1588     // Launch exception
1589     std::string msg = "Wrong body content format on HTTP Request for '";
1590     msg += opType;
1591     msg += "' operation (missing parameter/s). Use 'help' management command to see more information.";
1592     throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
1593   }
1594
1595   // Operations:
1596   if(opType == "context") {
1597     std::string contextFile = ((numParams == 1) ? param1 : anna::functions::asString("/var/tmp/anna.context.%05d", getPid()));
1598     writeContext(contextFile);
1599     response_content = anna::functions::asString("Context dumped on file '%s'", contextFile.c_str());
1600     return;
1601   }
1602
1603   // Change execution directory:
1604   if(opType == "change-dir") {
1605     if (param1 == "") param1 = a_initialWorkingDirectory;
1606     if (chdir(param1.c_str()) == 0)
1607       response_content = "New execution directory configured: ";
1608     else
1609       response_content = "Cannot assign provided execution directory: ";
1610
1611     response_content += param1;
1612     return;
1613   }
1614
1615   if(opType == "services") {
1616     std::string servicesFile = ((numParams == 1) ? param1 : "services.xml");
1617     try {
1618       loadServices(servicesFile, true /* bind entities */);
1619     }
1620     catch(anna::RuntimeException &ex) {
1621       ex.trace();
1622       response_content = anna::functions::asString("Loaded services from file '%s' with errors", servicesFile.c_str());
1623       return;
1624     }
1625     response_content = anna::functions::asString("Loaded services from file '%s'", servicesFile.c_str());
1626     return;
1627   }
1628
1629   // Host switch:
1630   if(opType == "node") {
1631     if (param1 != "") {
1632       if (setWorkingNode(param1)) response_content = anna::functions::asString("Forced node is now '%s'", param1.c_str());
1633     }
1634     else {
1635       if (a_workingNode) {
1636         response_content = "Working node is forced to be: \n\n";
1637         response_content += a_workingNode->asXMLString();
1638       }
1639       else {
1640         response_content = "Working node is automatic";
1641       }
1642     }
1643     return;
1644   }
1645   if(opType == "node_auto") {
1646     a_workingNode = NULL;
1647     response_content = "Working node has been set to automatic";
1648     return;
1649   }
1650
1651   // Operated host from possible forced-working node:
1652   a_operatedHost = a_workingNode ? a_workingNode /* priority */: NULL /* auto */;
1653   // Use later:
1654   //    If any message is managed: updateOperatedOriginHostWithMessage(codecMessage)
1655   //    To operate, use the exception-protected methods which never will return NULL:
1656   //         getOperatedHost(), getOperatedEntity(), getOperatedServer(), getOperatedEngine()
1657
1658
1659   if(opType == "code") {
1660     codecMsg.loadXML(param1);
1661     std::string hexString = anna::functions::asHexString(codecMsg.code());
1662     // write to outfile
1663     std::ofstream outfile(param2.c_str(), std::ifstream::out);
1664     outfile.write(hexString.c_str(), hexString.size());
1665     outfile.close();
1666   } else if(opType == "decode") {
1667     // Get DataBlock from file with hex content:
1668     if(!getDataBlockFromHexFile(param1, db_aux))
1669       throw anna::RuntimeException("Error reading hex file provided", ANNA_FILE_LOCATION);
1670
1671     // Decode
1672     try { codecMsg.decode(db_aux); } catch(anna::RuntimeException &ex) { ex.trace(); }
1673
1674     std::string xmlString = codecMsg.asXMLString();
1675     // write to outfile
1676     std::ofstream outfile(param2.c_str(), std::ifstream::out);
1677     outfile.write(xmlString.c_str(), xmlString.size());
1678     outfile.close();
1679   } else if((opType == "hide") || (opType == "show") || (opType == "hidden") || (opType == "shown")) {
1680
1681     if(param1 != "") {
1682       if(param2 != "") {
1683         std::string key = param1;
1684         key += "|";
1685         key += param2;
1686
1687         if(opType == "hide") getOperatedEngine()->findClientSession(key)->hide();
1688
1689         if(opType == "show") getOperatedEngine()->findClientSession(key)->show();
1690
1691         if(opType == "hidden") opt_response_content = getOperatedEngine()->findClientSession(key)->hidden() ? "true" : "false";
1692
1693         if(opType == "shown") opt_response_content = getOperatedEngine()->findClientSession(key)->shown() ? "true" : "false";
1694       } else {
1695         std::string address;
1696         int port;
1697         anna::functions::getAddressAndPortFromSocketLiteral(param1, address, port);
1698
1699         if(opType == "hide") getOperatedEngine()->findServer(address, port)->hide();
1700
1701         if(opType == "show") getOperatedEngine()->findServer(address, port)->show();
1702
1703         if(opType == "hidden") opt_response_content = getOperatedEngine()->findServer(address, port)->hidden() ? "true" : "false";
1704
1705         if(opType == "shown") opt_response_content = getOperatedEngine()->findServer(address, port)->shown() ? "true" : "false";
1706       }
1707     } else {
1708       if(opType == "hide") getOperatedEntity()->hide();
1709
1710       if(opType == "show") getOperatedEntity()->show();
1711
1712       if(opType == "hidden") opt_response_content = getOperatedEntity()->hidden() ? "true" : "false";
1713
1714       if(opType == "shown") opt_response_content = getOperatedEntity()->shown() ? "true" : "false";
1715     }
1716   } else if((opType == "sendxml2e") || (opType == "sendhex2e")) {
1717     anna::diameter::comm::Message *msg;
1718
1719     if(opType == "sendxml2e") {
1720       codecMsg.loadXML(param1);
1721       updateOperatedOriginHostWithMessage(codecMsg);
1722       msg = getOperatedHost()->createCommMessage();
1723       msg->clearBody();
1724       try { codecMsg.valid(); } catch(anna::RuntimeException &ex) { ex.trace(); }  // at least we need to see validation errors although it will continue sending (see validation mode configured in launcher)
1725       msg->setBody(codecMsg.code());
1726     } else {
1727       // Get DataBlock from file with hex content:
1728       if(!getDataBlockFromHexFile(param1, db_aux))
1729         throw anna::RuntimeException("Error reading hex file provided", ANNA_FILE_LOCATION);
1730       msg = getOperatedHost()->createCommMessage();
1731       msg->setBody(db_aux);
1732       try { if(getOperatedHost()->logEnabled()) codecMsg.decode(db_aux); } catch(anna::RuntimeException &ex) { ex.trace(); }
1733     }
1734
1735     bool success = getOperatedEntity()->send(msg, cl.exists("balance"));
1736     getOperatedHost()->releaseCommMessage(msg);
1737
1738     // Detailed log:
1739     if(getOperatedHost()->logEnabled()) {
1740       anna::diameter::comm::Server *usedServer = getOperatedEntity()->getLastUsedResource();
1741       anna::diameter::comm::ClientSession *usedClientSession = usedServer ? usedServer->getLastUsedResource() : NULL;
1742       std::string detail = usedClientSession ? usedClientSession->asString() : "<null client session>"; // shouldn't happen
1743       getOperatedHost()->writeLogFile(codecMsg, (success ? "sent2e" : "send2eError"), detail);
1744     }
1745   } else if((opType == "burst")) {
1746
1747     if (!uniqueOriginHost())
1748       throw anna::RuntimeException("Burst category operations are only allowed in single host node configuration. This is only to simplify user experience.", ANNA_FILE_LOCATION);
1749
1750     // burst|clear                     clears all loaded burst messages.
1751     // burst|load|<source_file>        loads the next diameter message into launcher burst.
1752     // burst|start|<initial load>      starts the message sending with a certain initial load.
1753     // burst|push|<load amount>        sends specific non-aynchronous load.
1754     // burst|stop                      stops the burst cycle.
1755     // burst|repeat|[[yes]|no]         restarts the burst launch when finish.
1756     // burst|send|<amount>             send messages from burst list. The main difference with
1757     //                                 start/push operations is that burst won't be awaken.
1758     //                                 Externally we could control sending time (no request
1759     //                                 will be sent for answers).
1760     // burst|goto|<order>              Updates current burst pointer position.
1761     // burst|look|<order>              Show programmed burst message for order provided, current when missing.
1762
1763     if(param1 == "clear") {
1764       opt_response_content = "removed ";
1765       opt_response_content += anna::functions::asString(getOperatedHost()->clearBurst());
1766       opt_response_content += " elements";
1767     } else if(param1 == "load") {
1768       if(param2 == "") throw anna::RuntimeException("Missing xml path file for burst load operation", ANNA_FILE_LOCATION);
1769
1770       codecMsg.loadXML(param2);
1771       if(codecMsg.isAnswer()) throw anna::RuntimeException("Cannot load diameter answers for burst feature", ANNA_FILE_LOCATION);
1772       try { codecMsg.valid(); } catch(anna::RuntimeException &ex) { ex.trace(); }  // at least we need to see validation errors although it will continue loading (see validation mode configured in launcher)
1773
1774       int position = getOperatedHost()->loadBurstMessage(codecMsg.code());
1775       opt_response_content = "loaded '";
1776       opt_response_content += param2;
1777       opt_response_content += "' file into burst list position ";
1778       opt_response_content += anna::functions::asString(position);
1779     } else if(param1 == "start") {
1780       if(param2 == "") throw anna::RuntimeException("Missing initial load for burst start operation", ANNA_FILE_LOCATION);
1781
1782       int initialLoad = atoi(param2.c_str());
1783       int processed = getOperatedHost()->startBurst(initialLoad);
1784
1785       if(processed > 0) {
1786         opt_response_content = "initial load completed for ";
1787         opt_response_content += anna::functions::entriesAsString(processed, "message");
1788       }
1789     } else if(param1 == "push") {
1790       if(param2 == "") throw anna::RuntimeException("Missing load amount for burst push operation", ANNA_FILE_LOCATION);
1791
1792       int pushed = getOperatedHost()->pushBurst(atoi(param2.c_str()));
1793
1794       if(pushed > 0) {
1795         opt_response_content = "pushed ";
1796         opt_response_content += anna::functions::entriesAsString(pushed, "message");
1797       }
1798     } else if(param1 == "pop") {
1799       if(param2 == "") throw anna::RuntimeException("Missing amount for burst pop operation", ANNA_FILE_LOCATION);
1800
1801       int releaseLoad = atoi(param2.c_str());
1802       int popped = getOperatedHost()->popBurst(releaseLoad);
1803
1804       if(popped > 0) {
1805         opt_response_content = "burst popped for ";
1806         opt_response_content += anna::functions::entriesAsString(popped, "message");
1807       }
1808     } else if(param1 == "stop") {
1809       int left = getOperatedHost()->stopBurst();
1810
1811       if(left != -1) {
1812         opt_response_content += anna::functions::entriesAsString(left, "message");
1813         opt_response_content += " left to the end of the cycle";
1814       }
1815     } else if(param1 == "repeat") {
1816       if(param2 == "") param2 = "yes";
1817
1818       bool repeat = (param2 == "yes");
1819       getOperatedHost()->repeatBurst(repeat);
1820       opt_response_content += (repeat ? "repeat enabled" : "repeat disabled");
1821     } else if(param1 == "send") {
1822       if(param2 == "") throw anna::RuntimeException("Missing amount for burst send operation", ANNA_FILE_LOCATION);
1823
1824       int sent = getOperatedHost()->sendBurst(atoi(param2.c_str()));
1825
1826       if(sent > 0) {
1827         opt_response_content = "sent ";
1828         opt_response_content += anna::functions::entriesAsString(sent, "message");
1829       }
1830     } else if(param1 == "goto") {
1831       if(param2 == "") throw anna::RuntimeException("Missing order position for burst goto operation", ANNA_FILE_LOCATION);
1832
1833       opt_response_content = getOperatedHost()->gotoBurst(atoi(param2.c_str()));
1834     } else if(param1 == "look") {
1835       int order = ((param2 != "") ? atoi(param2.c_str()) : -1);
1836       opt_response_content = "\n\n";
1837       opt_response_content += getOperatedHost()->lookBurst(order);
1838     } else {
1839       throw anna::RuntimeException("Wrong body content format on HTTP Request for 'burst' operation (unexpected action parameter). See help", ANNA_FILE_LOCATION);
1840     }
1841
1842   } else if((opType == "test")) {
1843     // test|<id>|<command>[|parameters]         Add a new step to the test case ...
1844     // test|ttps|<amount>                       Starts/resume the provided number of time ticks per second (ttps). The ADML starts ...
1845     // test|next[|<sync-amount>]                Forces the execution of the next test case(s) without waiting for test manager tick ...
1846     // test|ip-limit[|amount]                   In-progress limit of test cases. No new test cases will be launched over this value ...
1847     // test|repeats|<amount>                    Restarts the whole programmed test list when finished the amount number of times ...
1848     // test|report|<initialized/in-progress/failed/success/[all]/none>[|[yes]|no]
1849     //                                          Enables/disables report generation for a certain test case state: initialized, in-progress ...
1850     // test|report-hex[|[yes]|no]               Reports could include the diameter messages in hexadecimal format. Disabled by default.
1851     // test|goto|<id>                           Updates current test pointer position.
1852     // test|look[|id]                           Show programmed test case for id provided, current when missing ...
1853     // test|interact|amount|id                  Makes interactive a specific test case id. The amount is the margin of execution steps ...
1854     // test|reset|<[soft]/hard>[|id]            Reset the test case for id provided, all the tests when missing ...
1855     // test|clear                               Clears all the programmed test cases.
1856     // test|summary                             Test manager general report (number of test cases, counts by state ...
1857
1858
1859     if(param1 == "ttps") {
1860       if (numParams > 2)
1861         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
1862
1863       bool success = ((param2 != "") ? testManager.configureTTPS(atoi(param2.c_str())) : false);
1864       if (success) {
1865         opt_response_content = "assigned new test launch rate to ";
1866         opt_response_content += anna::functions::asString(atoi(param2.c_str()));
1867         opt_response_content += " events per second";
1868       }
1869       else {
1870         opt_response_content += "unable to configure the test rate provided";
1871       }
1872     }
1873     else if (param1 == "next") {
1874       if (numParams > 2)
1875         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
1876
1877       int sync_amount = ((param2 != "") ? atoi(param2.c_str()) : 1);
1878
1879       if (sync_amount < 1)
1880         throw anna::RuntimeException("The parameter 'sync-amount' must be a positive integer value", ANNA_FILE_LOCATION);
1881
1882       bool success = testManager.execTestCases(sync_amount);
1883
1884       opt_response_content = (success ? "" : "not completely " /* completed cycle and no repeats, rare case */);
1885       opt_response_content += "processed ";
1886       opt_response_content += anna::functions::asString(sync_amount);
1887       opt_response_content += ((sync_amount > 1) ? " test cases synchronously" : " test case");
1888     }
1889     else if(param1 == "ip-limit") {
1890       if (numParams > 2)
1891         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
1892
1893       unsigned int limit;
1894       if (param2 != "") {
1895         limit = atoi(param2.c_str());
1896         testManager.setInProgressLimit(limit);
1897         opt_response_content = "new in-progress limit: ";
1898         opt_response_content += (limit != UINT_MAX) ? anna::functions::asString(limit) : "<no limit>";
1899       }
1900       else {
1901         opt_response_content = "in-progress limit amount: ";
1902         limit = testManager.getInProgressLimit();
1903         opt_response_content += (limit != UINT_MAX) ? anna::functions::asString(limit) : "<no limit>";
1904         opt_response_content += "; currently there are ";
1905         opt_response_content += anna::functions::asString(testManager.getInProgressCount());
1906         opt_response_content += " test cases running";
1907       }
1908     }
1909     else if(param1 == "repeats") {
1910       if (numParams != 2)
1911         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
1912       int repeats = atoi(param2.c_str());
1913       if (repeats < 0) repeats = -1;
1914       testManager.setPoolRepeats(repeats);
1915       std::string nolimit = (repeats != -1) ? "":" [no limit]";
1916       opt_response_content += anna::functions::asString("Pool repeats: %d%s (current cycle: %d)", repeats, nolimit.c_str(), testManager.getPoolCycle());
1917     }
1918     else if(param1 == "report") {
1919       if (numParams > 3)
1920         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
1921
1922       if(param2 == "") param2 = "all";
1923       if(param3 == "") param3 = "yes";
1924       bool enable = (param3 == "yes");
1925
1926       if(param2 == "initialized")
1927         testManager.setDumpInitializedReports(enable);
1928       else if(param2 == "in-progress")
1929         testManager.setDumpInProgressReports(enable);
1930       else if(param2 == "failed")
1931         testManager.setDumpFailedReports(enable);
1932       else if(param2 == "success")
1933         testManager.setDumpSuccessReports(enable);
1934       else if(param2 == "all") {
1935         param2 = "any";
1936         testManager.setDumpAllReports(enable);
1937       }
1938       else if(param2 == "none") {
1939         enable = !enable;
1940         param2 = "any";
1941         testManager.setDumpAllReports(enable);
1942       }
1943       else
1944         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
1945
1946       opt_response_content += (enable ? "report enabled " : "report disabled ");
1947       opt_response_content += "for tests in '";
1948       opt_response_content += param2;
1949       opt_response_content += "' state";
1950     }
1951     else if(param1 == "report-hex") {
1952       if (numParams > 2)
1953         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
1954
1955       if(param2 == "") param2 = "yes";
1956       testManager.setDumpHex((param2 == "yes"));
1957       opt_response_content += (testManager.getDumpHex() ? "report includes hexadecimal messages" : "report excludes hexadecimal messages");
1958     }
1959     else if(param1 == "goto") {
1960       if (numParams > 2)
1961         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
1962
1963       if(param2 == "") throw anna::RuntimeException("Missing id for test goto operation", ANNA_FILE_LOCATION);
1964       int id = atoi(param2.c_str());
1965       if (testManager.gotoTestCase(id)) {
1966         opt_response_content = "position updated for id provided (";
1967       }
1968       else {
1969         opt_response_content = "cannot found test id (";
1970       }
1971       opt_response_content += anna::functions::asString(id);
1972       opt_response_content += ")";
1973     }
1974     else if(param1 == "look") {
1975       if (numParams > 2)
1976         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
1977
1978       int id = ((param2 != "") ? atoi(param2.c_str()) : -1);
1979       TestCase *testCase = testManager.findTestCase(id);
1980
1981       if (testCase) {
1982         response_content = testCase->asXMLString();
1983         return;
1984       }
1985       else {
1986         if (id == -1) {
1987           opt_response_content = "no current test case detected (testing started ?)";
1988         }
1989         else {
1990           opt_response_content = "cannot found test id (";
1991           opt_response_content += anna::functions::asString(id);
1992           opt_response_content += ")";
1993         }
1994       }
1995     }
1996     else if (param1 == "interact") {
1997       if (numParams != 3)
1998         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
1999
2000       int amount = atoi(param2.c_str());
2001       if (amount < -1)
2002         throw anna::RuntimeException("Interactive amount must be -1 (to disable interactive mode) or a positive number.", ANNA_FILE_LOCATION);
2003
2004       int id = atoi(param3.c_str());
2005       TestCase *testCase = testManager.findTestCase(id);
2006       if (testCase) {
2007         if (amount == -1) {
2008           testCase->makeInteractive(false);
2009           opt_response_content = "interactive mode disabled";
2010         }
2011         else {
2012           testCase->addInteractiveAmount(amount);
2013           opt_response_content = "added interactive amount of ";
2014           opt_response_content += anna::functions::asString(amount);
2015           opt_response_content += " units";
2016           if (amount == 0) opt_response_content += " (0: freezing a non-interactive testcase, no effect on already interactive)";
2017         }
2018         opt_response_content += " for test case id ";
2019         opt_response_content += anna::functions::asString(id);
2020       }
2021       else {
2022         opt_response_content = "cannot found test id (";
2023         opt_response_content += anna::functions::asString(id);
2024         opt_response_content += ")";
2025       }
2026     }
2027     else if(param1 == "reset") {
2028       if (numParams > 3)
2029         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
2030
2031       if(param2 == "") param2 = "soft";
2032      if (param2 != "soft" && param2 != "hard")
2033         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
2034
2035       int id = ((param3 != "") ? atoi(param3.c_str()) : -1);
2036       TestCase *testCase = ((id != -1) ? testManager.findTestCase(id) : NULL);
2037
2038       if (testCase) {
2039         bool done = testCase->reset((param2 == "hard") ? true:false);
2040         opt_response_content = "test ";
2041         opt_response_content += param2;
2042         opt_response_content += " reset for id ";
2043         opt_response_content += anna::functions::asString(id);
2044         opt_response_content += done ? ": done": ": not done";
2045       }
2046       else {
2047         if (id == -1) {
2048           bool anyReset = testManager.resetPool((param2 == "hard") ? true:false);
2049           opt_response_content = param2; opt_response_content += " reset have been sent to all programmed tests: "; opt_response_content += anyReset ? "some/all have been reset" : "nothing was reset";
2050         }
2051         else {
2052           opt_response_content = "cannot found test id (";
2053           opt_response_content += anna::functions::asString(id);
2054           opt_response_content += ")";
2055         }
2056       }
2057     }
2058     else if(param1 == "clear") {
2059       if (numParams > 1)
2060         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
2061
2062       if (testManager.clearPool()) {
2063         opt_response_content = "all the programmed test cases have been dropped";
2064       }
2065       else {
2066         opt_response_content = "there are not programmed test cases to be removed";
2067       }
2068     }
2069     else if(param1 == "summary") {
2070       response_content = testManager.asXMLString();
2071       return;
2072     }
2073     else {
2074       int id = atoi(param1.c_str());
2075       if(id < 0)
2076         throw anna::RuntimeException("Invalid test case identifier: must be a non-negative number", ANNA_FILE_LOCATION);
2077
2078       // PARAM: 1     2            3      4          5           6             7           8          9       10         11
2079       // test|<id>|<command>
2080       //             timeout|    <msecs>
2081       //             sendxml2e|  <file>[|<step number>]
2082       //             sendxml2c|  <file>[|<step number>]
2083       //             delay|      [msecs]
2084       //             wait<fe/fc>|[code]|[bitR]|[hopByHop]|[applicationId]|[sessionId]|[resultCode]|[msisdn]|[imsi]|[serviceContextId]
2085       //      wait<fe/fc>-answer|<step number>
2086       //      wait<fe/fc>-regexp|<regexp>
2087       if(param2 == "") throw anna::RuntimeException("Missing command for test id operation", ANNA_FILE_LOCATION);
2088
2089       // Commands:
2090       if (param2 == "timeout") {
2091         if (numParams > 3)
2092           throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
2093         if(param3 == "") throw anna::RuntimeException("Missing milliseconds for 'timeout' command in test id operation", ANNA_FILE_LOCATION);
2094         anna::Millisecond timeout = checkTimeMeasure("Test case timeout", param3);
2095         testManager.getTestCase(id)->addTimeout(timeout); // creates / reuses
2096       }
2097       else if ((param2 == "sendxml2e")||(param2 == "sendxml2c")) {
2098         if (numParams > 4)
2099           throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
2100         if(param3 == "") throw anna::RuntimeException(anna::functions::asString("Missing xml file for '%s' command in test id operation", param2.c_str()), ANNA_FILE_LOCATION);
2101         codecMsg.loadXML(param3);
2102         if (codecMsg.isRequest()) {
2103           if (param4 != "")
2104             throw anna::RuntimeException("Step number is provided with answers (to resolve the corresponding 'wait for request' step), but NOT with requests", ANNA_FILE_LOCATION);
2105         }
2106         else {
2107           if (param4 == "") LOGWARNING(anna::Logger::warning("Step number has not been provided. Take into account that this answer message will be sent 'as is' and sequence information could be wrong at the remote peer", ANNA_FILE_LOCATION));
2108         }
2109         updateOperatedOriginHostWithMessage(codecMsg);
2110         int stepNumber = ((param4 != "") ? atoi(param4.c_str()):-1);
2111
2112         if (param2 == "sendxml2e")
2113           testManager.getTestCase(id)->addSendxml2e(codecMsg.code(), getOperatedHost(), stepNumber); // creates / reuses
2114         else
2115           testManager.getTestCase(id)->addSendxml2c(codecMsg.code(), getOperatedHost(), stepNumber); // creates / reuses
2116       }
2117       else if (param2 == "delay") {
2118         if (numParams > 3)
2119           throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
2120         if(param3 == "") throw anna::RuntimeException("Missing milliseconds for 'delay' command in test id operation", ANNA_FILE_LOCATION);
2121         anna::Millisecond delay = ((param3 == "0" /* special case */) ? (anna::Millisecond)0 : checkTimeMeasure("Test case delay step", param3));
2122         testManager.getTestCase(id)->addDelay(delay); // creates / reuses
2123       }
2124       else if ((param2 == "waitfe")||(param2 == "waitfc")) {
2125         if (numParams > 11)
2126           throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
2127         if (param3 != "" || param4 != "" || param5 != "" || param6 != "" || param7 != "" || param8 != "" || param9 != "" || param10 != "" || param11 != "") {
2128           bool fromEntity = (param2.substr(4,2) == "fe");
2129           testManager.getTestCase(id)->addWait(fromEntity, param3, param4, param5, param6, param7, param8, param9, param10, param11);
2130         }
2131         else {
2132           throw anna::RuntimeException(anna::functions::asString("Missing condition for '%s' command in test id operation", param2.c_str()), ANNA_FILE_LOCATION);
2133         }
2134       }
2135       else if ((param2 == "waitfe-regexp")||(param2 == "waitfc-regexp")) {
2136         if (numParams > 3)
2137           throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
2138         if (param3 != "") {
2139           bool fromEntity = (param2.substr(4,2) == "fe");
2140           testManager.getTestCase(id)->addWaitRegexp(fromEntity, param3);
2141         }
2142         else {
2143           throw anna::RuntimeException(anna::functions::asString("Missing condition for '%s' command in test id operation", param2.c_str()), ANNA_FILE_LOCATION);
2144         }
2145       }
2146       else if (param2 == "sh-command") {
2147         // Allow pipes in command:
2148         //if (numParams > 4)
2149         //  throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
2150         if(param3 == "") throw anna::RuntimeException("Missing script/executable command-line for 'sh-command' in test id operation", ANNA_FILE_LOCATION);
2151         std::string token = "|sh-command|";
2152         std::string command = operation.substr(operation.find(token) + token.size());
2153         testManager.getTestCase(id)->addCommand(command); // creates / reuses
2154       }
2155       else {
2156         throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
2157       }
2158     }
2159
2160   } else if((opType == "sendxml2c") || (opType == "sendhex2c")) {
2161     anna::diameter::comm::Message *msg;
2162
2163     if(opType == "sendxml2c") {
2164       codecMsg.loadXML(param1);
2165       updateOperatedOriginHostWithMessage(codecMsg);
2166       msg = getOperatedHost()->createCommMessage();
2167       msg->clearBody();
2168       try { codecMsg.valid(); } catch(anna::RuntimeException &ex) { ex.trace(); }  // at least we need to see validation errors although it will continue sending (see validation mode configured in launcher)
2169
2170       msg->setBody(codecMsg.code());
2171     } else {
2172       // Get DataBlock from file with hex content:
2173       if(!getDataBlockFromHexFile(param1, db_aux))
2174         throw anna::RuntimeException("Error reading hex file provided", ANNA_FILE_LOCATION);
2175       msg = getOperatedHost()->createCommMessage();
2176       msg->setBody(db_aux);
2177     }
2178
2179     bool success = getOperatedServer()->send(msg);
2180     getOperatedHost()->releaseCommMessage(msg);
2181
2182     // Detailed log:
2183     if(getOperatedHost()->logEnabled()) {
2184       anna::diameter::comm::ServerSession *usedServerSession = getOperatedServer()->getLastUsedResource();
2185       std::string detail = usedServerSession ? usedServerSession->asString() : "<null server session>"; // shouldn't happen
2186       getOperatedHost()->writeLogFile(codecMsg, (success ? "sent2c" : "send2cError"), detail);
2187     }
2188   } else if(opType == "loadxml") {
2189     codecMsg.loadXML(param1);
2190     response_content = codecMsg.asXMLString();
2191     return;
2192   } else if(opType == "diameterServerSessions") {
2193     int diameterServerSessions = atoi(param1.c_str());
2194     getOperatedServer()->setMaxConnections(diameterServerSessions);
2195
2196   } else if(opType == "answerxml2c") {
2197     if(param1 == "") { // programmed answers FIFO's to stdout
2198       response_content = getOperatedServer()->getReactingAnswers()->asString("ANSWERS TO CLIENT");
2199       return;
2200     } else if (param1 == "rotate") {
2201       getOperatedServer()->getReactingAnswers()->rotate(true);
2202     } else if (param1 == "exhaust") {
2203       getOperatedServer()->getReactingAnswers()->rotate(false);
2204     } else if (param1 == "clear") {
2205       getOperatedServer()->getReactingAnswers()->clear();
2206     } else if (param1 == "dump") {
2207       getOperatedServer()->getReactingAnswers()->dump();
2208     } else {
2209       codecMsg.loadXML(param1);
2210       updateOperatedOriginHostWithMessage(codecMsg);
2211       anna::diameter::codec::Message *message = getOperatedHost()->getCodecEngine()->createMessage(param1); // loads xml again, lesser of two evils
2212       LOGDEBUG(anna::Logger::debug(message->asXMLString(), ANNA_FILE_LOCATION));
2213
2214       if(message->isRequest())
2215         throw anna::RuntimeException("Cannot program diameter requests. Answer type must be provided", ANNA_FILE_LOCATION);
2216
2217       int code = message->getId().first;
2218       LOGDEBUG(anna::Logger::debug("Adding a new programed 'answer to client' to the FIFO queue corresponding to its message code ...", ANNA_FILE_LOCATION));
2219       getOperatedServer()->getReactingAnswers()->addMessage(code, message);
2220     }
2221   } else if(opType == "answerxml2e") {
2222
2223     if(param1 == "") { // programmed answers FIFO's to stdout
2224       response_content = getOperatedEntity()->getReactingAnswers()->asString("ANSWERS TO ENTITY");
2225       return;
2226     } else if (param1 == "rotate") {
2227       getOperatedEntity()->getReactingAnswers()->rotate(true);
2228     } else if (param1 == "exhaust") {
2229       getOperatedEntity()->getReactingAnswers()->rotate(false);
2230     } else if (param1 == "clear") {
2231       getOperatedEntity()->getReactingAnswers()->clear();
2232     } else if (param1 == "dump") {
2233       getOperatedEntity()->getReactingAnswers()->dump();
2234     } else {
2235       codecMsg.loadXML(param1);
2236       updateOperatedOriginHostWithMessage(codecMsg);
2237       anna::diameter::codec::Message *message = getOperatedHost()->getCodecEngine()->createMessage(param1); // loads xml again, lesser of two evils
2238       LOGDEBUG(anna::Logger::debug(message->asXMLString(), ANNA_FILE_LOCATION));
2239
2240       if(message->isRequest())
2241         throw anna::RuntimeException("Cannot program diameter requests. Answer type must be provided", ANNA_FILE_LOCATION);
2242
2243       int code = message->getId().first;
2244       LOGDEBUG(anna::Logger::debug("Adding a new programed 'answer to entity' to the FIFO queue corresponding to its message code ...", ANNA_FILE_LOCATION));
2245       getOperatedEntity()->getReactingAnswers()->addMessage(code, message);
2246     }
2247   } else {
2248     throw anna::RuntimeException("Wrong body content format on HTTP Request. Use 'help' management command to see more information.", ANNA_FILE_LOCATION);
2249   }
2250
2251   // HTTP response
2252   response_content = "Operation correctly processed: "; response_content += operation;
2253   if (opt_response_content != "") {
2254     response_content += " => ";
2255     response_content += opt_response_content;
2256   }
2257 }
2258
2259 anna::xml::Node* Launcher::asXML(anna::xml::Node* parent) const
2260 throw() {
2261   anna::xml::Node* result = parent->createChild("launcher");
2262   anna::comm::Application::asXML(result);
2263   // Timming:
2264   result->createAttribute("StartTime", a_start_time.asString());
2265   result->createAttribute("InitialWorkingDirectory", a_initialWorkingDirectory);
2266   result->createAttribute("SecondsLifeTime", anna::time::functions::lapsedMilliseconds() / 1000);
2267   // Diameter:
2268   for (origin_hosts_it it = a_originHosts.begin(); it != a_originHosts.end(); it++) {
2269     it->second->asXML(result);
2270   }
2271
2272   // Registered codec engines:
2273   anna::diameter::codec::EngineManager &em = anna::diameter::codec::EngineManager::instantiate();
2274   em.asXML(result);
2275
2276   // OAM & statistics:
2277   oamAsXML(result);
2278   statsAsXML(result);
2279
2280   // Testing: could be heavy if test case reports are enabled
2281   TestManager::instantiate().asXML(result);
2282
2283   return result;
2284 }
2285
2286 anna::xml::Node* Launcher::oamAsXML(anna::xml::Node* parent) const
2287 throw() {
2288   anna::xml::Node* result = parent->createChild("Oam");
2289
2290   // OAM:
2291   anna::diameter::comm::OamModule::instantiate().asXML(result);
2292   anna::diameter::comm::ApplicationMessageOamModule::instantiate().asXML(result);
2293   anna::diameter::codec::OamModule::instantiate().asXML(result);
2294
2295   return result;
2296 }
2297
2298 anna::xml::Node* Launcher::statsAsXML(anna::xml::Node* parent) const
2299 throw() {
2300   anna::xml::Node* result = parent->createChild("Statistics");
2301
2302   // Statistics:
2303   anna::statistics::Engine::instantiate().asXML(result);
2304
2305   return result;
2306 }