Add automation for ADML HTTP image creation
[anna.git] / example / diameter / batchConverter / main.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 #include <iostream>
10 #include <fstream>
11
12 // STL
13 #include <string>
14 #include <map>
15
16 #include <anna/core/DataBlock.hpp>
17 #include <anna/core/util/Tokenizer.hpp>
18 #include <anna/core/functions.hpp>
19 #include <anna/core/tracing/Logger.hpp>
20 #include <anna/core/tracing/TraceWriter.hpp>
21 #include <anna/core/RuntimeException.hpp>
22 #include <anna/io/Directory.hpp>
23 #include <anna/xml/xml.hpp>
24 #include <anna/diameter/stack/Engine.hpp>
25 #include <anna/diameter/codec/Engine.hpp>
26 #include <anna/diameter/codec/EngineManager.hpp>
27 #include <anna/diameter/codec/Message.hpp>
28 //#include <anna/diameter/codec/functions.hpp> // ApplicationId anna::diameter::codec::functions::getApplicationId(const anna::DataBlock &) throw(anna::RuntimeException);
29
30
31 using namespace anna;
32 using namespace anna::diameter;
33
34 anna::diameter::codec::Message G_codecMsg;
35
36 bool getDataBlockFromHexFile(const std::string &pathfile, anna::DataBlock &db) throw() {
37   // Get hex string
38   static char buffer[8192];
39   std::ifstream infile(pathfile.c_str(), std::ifstream::in);
40
41   if(infile.is_open()) {
42     infile >> buffer;
43     std::string hexString(buffer, strlen(buffer));
44     // Allow colon separator in hex string: we have to remove them before processing with 'fromHexString':
45     hexString.erase(std::remove(hexString.begin(), hexString.end(), ':'), hexString.end());
46     LOGDEBUG(
47       std::string msg = "Hex string (remove colons if exists): ";
48       msg += hexString;
49       anna::Logger::debug(msg, ANNA_FILE_LOCATION);
50     );
51     anna::functions::fromHexString(hexString, db);
52     // Close file
53     infile.close();
54     return true;
55   }
56
57   return false;
58 }
59
60
61 void _exit(const std::string &message, int resultCode = 1) {
62   if(resultCode)
63     std::cerr << message << std::endl << std::endl;
64   else
65     std::cout << message << std::endl << std::endl;
66
67   exit(resultCode);
68 }
69
70 // Decodes a diameter message coming from a datablock
71 bool decodeDataBlock(const anna::DataBlock &db/*, unsigned int & detectedApplicationId*/) throw() {
72   try {
73     G_codecMsg.clear();
74     G_codecMsg.decode(db);
75   } catch(RuntimeException &ex) {
76     std::cerr << ex.asString() << std::endl << std::endl;
77     //_exit(ex.asString());
78     return false;
79   }
80
81   return true;
82 }
83
84 //-------------------------------------------------------------------
85 int main(int argc, char **argv) {
86   std::string exec = argv[0];
87   std::string execBN = exec.substr(exec.find_last_of("/") + 1);
88   std::string filetrace = execBN + ".trace";
89   std::cout << std::endl;
90
91   //check command line arguments
92   if(argc < 3) {
93     std::string msg = "Usage: "; msg += exec;
94     msg += " <stacks> <working directory> [--hex-only] [--xml-only] [--no-validation] [--ignore-flags] [--debug]\n\n";
95     msg += "       stacks:                  <appid1,dictionary1#appid2,dictionary2#...#appidN,dictionaryN>\n";
96     msg += "                                This is a list of #-separated stacks defined by a comma-separated pair <application-id,xml dictionary pathfile>\n";
97     msg += "                                If only one stack is provided, application-id could be omitted and then, all the messages will be decoded with the\n";
98     msg += "                                dictionary regardless the value of the application-id (the stack will be registered with id=0).\n";
99     msg += "       Working directory:       Contains 'xml files' (ANNA-Diameter message format) and/or 'hex files' (hexadecimal content, colons allowed).\n";
100     msg += "       --hex-only:              Only hex files are converted.\n";
101     msg += "       --xml-only:              Only xml files are converted.\n";
102     msg += "       --no-validation:         no validation is performed.\n";
103     msg += "       --ignore-flags:          wrong flags regarding dictionary are ignored in xml representation.\n";
104     msg += "       --debug:                 activates debug level traces (warning by default).\n";
105     msg += "\n";
106     msg += "       The batch process will translate '.xml' files into '.xml.as.hex', and '.hex' files into '.hex.as.xml'\n";
107     msg += "       Take care not to include the dictionary files (which have '.xml' extension) in the working directory, or there will be an exception.\n";
108     _exit(msg);
109   }
110
111   // Command-line parameters:
112   std::string stacks = argv[1];
113   std::string wkDir = argv[2];
114   std::string optionals;
115   int indx = 3;
116   while(indx < argc) { optionals += " "; optionals += argv[indx]; indx++; }
117
118   bool no_validation = (optionals.find("--no-validation") != std::string::npos);
119   bool ignore_flags = (optionals.find("--ignore-flags") != std::string::npos);
120   bool debug = (optionals.find("--debug") != std::string::npos);
121   bool hexOnly = (optionals.find("--hex-only") != std::string::npos);
122   bool xmlOnly = (optionals.find("--xml-only") != std::string::npos);
123   if (hexOnly && xmlOnly) _exit("Cannot provide both '--hex-only' and '--xml-only' !!");
124   bool processXml = hexOnly ? false:true;
125   bool processHex = xmlOnly ? false:true;
126   Logger::setLevel(debug ? Logger::Debug:Logger::Warning);
127   Logger::initialize(execBN.c_str(), new TraceWriter(filetrace.c_str(), 2048000));
128   anna::diameter::stack::Engine &stackEngine = anna::diameter::stack::Engine::instantiate();
129   anna::diameter::codec::EngineManager &em = anna::diameter::codec::EngineManager::instantiate();
130   anna::diameter::codec::Engine *ce;
131   unsigned int appid = 0;
132
133
134   // Register stacks:
135   try {
136     anna::Tokenizer stacksTok;
137     stacksTok.apply(stacks, "#");
138     anna::Tokenizer::const_iterator stacks_it, stack_it;
139
140     for(stacks_it = stacksTok.begin(); stacks_it != stacksTok.end(); stacks_it++) {
141       std::string stack = anna::Tokenizer::data(stacks_it);
142       anna::Tokenizer stackTok;
143       stackTok.apply(stack, ",");
144
145       if(stackTok.size() == 1) {
146         if(stacksTok.size() != 1)
147           throw anna::RuntimeException("Application Id value is mandatory when more than one stack is going to be configured", ANNA_FILE_LOCATION);
148         anna::diameter::stack::Dictionary *d = stackEngine.createDictionary(appid, stack); // the stack is the dictionary
149         ce = new anna::diameter::codec::Engine("CodecEngineForUniqueStackId_0", d);
150         em.registerCodecEngine(0, ce);
151         break;
152       }
153
154       if(stackTok.size() != 2)
155         throw anna::RuntimeException("Each stack must be in the form '<application-id>,<xml dictionary pathfile>'", ANNA_FILE_LOCATION);
156
157       stack_it = stackTok.begin();
158       unsigned int stackId = atoll(anna::Tokenizer::data(stack_it));
159       stack_it++;
160       std::string file = anna::Tokenizer::data(stack_it);
161       anna::diameter::stack::Dictionary *d = stackEngine.createDictionary(stackId, file);
162       std::string codecEngineName = anna::functions::asString("CodecEngineForStackId_%llu", stackId);
163       ce = new anna::diameter::codec::Engine(codecEngineName.c_str(), d);
164       em.registerCodecEngine(stackId, ce);
165     }
166
167     std::cout << "Stacks provided:          " << std::endl;
168     std::cout << anna::functions::tab(stackEngine.asString(false /* light */));
169     std::cout << std::endl;
170     std::cout << "Working directory:        " << wkDir << std::endl;
171     std::cout << "Validation:               " << (!no_validation ? "yes" : "no") << std::endl;
172     std::cout << "Ignore Flags:             " << (ignore_flags ? "yes" : "no") << std::endl;
173     std::cout << std::endl;
174   } catch(anna::RuntimeException &ex) {
175     _exit(ex.asString());
176   }
177
178   // Validation kindness
179   for (anna::diameter::codec::appid_codec_engines_it it = em.begin(); it != em.end(); it++) {
180     ce = it->second;
181     ce->setFixMode(anna::diameter::codec::EngineImpl::FixMode::Never); // we will encode "as is" (because --no-validation is assumed as user desire)
182     ce->setValidationDepth(anna::diameter::codec::EngineImpl::ValidationDepth::Complete); // complete validation for better reports
183     if(no_validation) ce->setValidationMode(anna::diameter::codec::EngineImpl::ValidationMode::Never);
184     if(ignore_flags) ce->ignoreFlagsOnValidation(true);
185   }
186
187   // Auxiliary variables:
188   anna::DataBlock db_aux(true);
189   anna::io::Directory directoryHex, directoryXml; // we separate (although it wouldn't be neccessary using setPattern each time), because we don't
190                                                   // want to process the resulting xml files from hex conversion, only the xml files present at the
191                                                   // beginning in the directory
192   // Analyze FS:
193   directoryHex.setPattern(".hex$");
194   directoryHex.read(wkDir.c_str(), anna::io::Directory::Mode::FullPath);
195   directoryXml.setPattern(".xml$");
196   directoryXml.read(wkDir.c_str(), anna::io::Directory::Mode::FullPath);
197
198   // Processing .hex files:
199   bool anyHexConverted = false;
200   if (processHex) {
201     for (anna::io::Directory::const_iterator it = directoryHex.begin(); it != directoryHex.end(); it++) {
202       const std::string& entry = anna::io::Directory::data (it);
203       LOGDEBUG(anna::Logger::debug(entry + " is being converted to xml", ANNA_FILE_LOCATION));
204
205       if(!getDataBlockFromHexFile(entry, db_aux))
206         _exit("Error reading hex file provided");
207
208       // Decode datablock:
209       if (decodeDataBlock(db_aux)) {
210
211         // Write conversion:
212         std::string outputFile = entry + ".as.xml";
213         std::ofstream out(outputFile.c_str(), std::ifstream::out);
214         out << G_codecMsg.asXMLString();
215         out.close();
216
217         anyHexConverted = true;
218       }
219     }
220   }
221
222   // Processing .xml files:
223   bool anyXmlConverted = false;
224   if (processXml) {
225     for (anna::io::Directory::const_iterator it = directoryXml.begin(); it != directoryXml.end(); it++) {
226       const std::string& entry = anna::io::Directory::data (it);
227       LOGDEBUG(anna::Logger::debug(entry + " is being converted to hex", ANNA_FILE_LOCATION));
228
229       // Load file:
230       G_codecMsg.loadXMLFile(entry);
231
232       // Write conversion:
233       std::string hexString = anna::functions::asHexString(G_codecMsg.code());
234       std::string outputFile = entry + ".as.hex";
235       std::ofstream out(outputFile.c_str(), std::ifstream::out);
236       out.write(hexString.c_str(), hexString.size());
237       out.close();
238
239       anyXmlConverted = true;
240     }
241   }
242
243
244   std::string msg = "Open '"; msg += filetrace; msg += "' in order to see process traces.\n";
245   if (anyHexConverted) msg += "Open '*.hex.as.xml' files to see decoding results.\n";
246   if (anyXmlConverted) msg += "Open '*.xml.as.hex' files to see encoding results.\n";
247   _exit(msg, 0);
248 }
249