yodaUtility/YodaProfiler/YodaProfiler.cpp


#include <log4cxx/logger.h>
#include <log4cxx/basicconfigurator.h>
#include <log4cxx/fileappender.h>
#include <log4cxx/patternlayout.h>
#include <log4cxx/propertyconfigurator.h>

#include <TSQLServer.h>
#include <TSQLResult.h>
#include <YSQLConnection.h>
#include <PamelaDBOperations.h>
#include <YException.h>

#include <cstdlib>
#include <iostream>
#include <errno.h>

extern "C" {
#include <dirent.h>
}

using namespace log4cxx;
using namespace std;
using namespace yngn::YException;
using namespace pamela;

static LoggerPtr logger = Logger::getLogger(_T("YodaProfiler"));

/*
NOTE!!!
This program assume that on the '.' directory is present a structure having a

- filesFromYoda folder containing the unpacked data
*/

int main(int argc, char* argv[]) {

/*
    if (argc < 2){
    printf("You have to insert at least the file to analyze \n");
    printf("Try '--help' for more information. \n");
    exit(1);
  }  

  if (!strcmp(argv[1], "--help")){
        printf( "Usage: -exec[operation] [OPTIONS] \n");
        printf( "\t --help                 Print this help and exit \n");
        printf( "\t OPTIONS: \n");
        
        printf( "\t -sqlParams[path]       Path to the configuration file to connect to the Database server \n");
        printf( "\t The configuration file (remember to chmod it to '500') have to be in the format \n");
        printf( "\t #HOST=hostname \n");
        printf( "\t #USER=username \n");
        printf( "\t #PSW=password \n");
        printf( "\t #DB=databaseName \n");
        
        printf( "\t -host[name]            The name of the host where the database is installed\n");
        printf( "\t -user[name]            The name of the user accessing to the database\n");
        printf( "\t -psw[name]             The password of the user accessing to the database\n");
        
        printf( "\t Notice that by default [-host -name -password -database] overload the [-sqlParams] param \n");
        
        printf( "\t -exec[nameOperation]   Execute the required operation");
        printf( "\t -rawPath[path]         Path to the raw file \n");
        printf( "\t -rawFile[name]         Name of the raw file \n");
        
        printf( "\n \t Operations list: \n");
        printf( "\t insertPamelaRawFile -rawPath[path] -rawFile[name]); \n");
        exit(1);
  }

  for (int i = 2; i < argc; i++){
    if (!strcmp(argv[i], "-outDir")){
        if (++i >= argc){
            printf( "-outDir needs arguments. \n");
            printf( "Try '--help' for more information. \n");
            exit(1);
        } else {
            outDir = argv[i];
        }
    }

    if (!strcmp(argv[i], "-xslPath")) 
        if (++i >= argc){
            printf( "-xslPath needs arguments. \n");
            printf( "Try '--help' for more information. \n");
            exit(1);
        } else {
                xslPath = argv[i];
                continue;
        }
    }
        
  */  
    
    
    stringstream oss;
   
    TSQLServer *sqlServer   = 0;
    char  *rawPathName      = argv[1];
    char  *rawFileName      = argv[2];
    char  *symbolicName     = "";

    char  *result = NULL;
    char   buffer[999];
    char  *host = argv[3];
    char  *user = argv[4];
    char  *password = argv[5];
    char  *rootPathName      = argv[6];
    char  *rootFileName      = argv[7];
    

    //Here I have to put some check for the arguments......
    /*
    ifstream config(argv[4]);
    if (! config.is_open())
      { cout << "Error opening file"; exit (1); }
    while (! config.eof() )
      {
        config.getline (buffer,255);
        
        if (strstr(buffer, "=") != NULL){
          result = strtok( buffer, "=" );
          while( result != NULL ) {
            //The fisrt strok skip the "user" or "password" keys
            result = strtok( NULL, delims );
            user = strtok( NULL, delims );
          }     
        }
      }*/
  try{
    oss.str("");
    sqlServer = yngn::sql::YSQLConnection::getConnection(host, user, password);    
  } catch (YException exc) {
    cout << exc.print();
    exit(1);
  }

      //Insert a Raw file in GL_RAW
//-------------------------------------------------------------------------------------------
   try {
     PamelaDBOperations::insertPamelaRawFile(sqlServer, rawPathName, rawFileName);
    } catch (YException exc) {
        cout << "Eccezione! " << exc.print() << "\n" ;
    }
//-------------------------------------------------------------------------------------------

      //Insert single unpack ROOTs files in GL_ROOT
//-------------------------------------------------------------------------------------------
   try {
     PamelaDBOperations::insertPamelaRootFiles(sqlServer, rootPathName, rootFileName, rawPathName, rawFileName);
    } catch (YException exc) {
        cout << "Eccezione! " << exc.print() << "\n" ;
    }
//-------------------------------------------------------------------------------------------

   
//Update a single GL_RAW record with its BOOT_NUMBER
//-------------------------------------------------------------------------------------------
   try {
     PamelaDBOperations::assignBOOT_NUMBER(sqlServer, rawPathName, rawFileName);
   } catch (YException exc) {
     cout << "Eccezione! " << exc.print() << "\n" ;
   }
//-------------------------------------------------------------------------------------------
      
      //Insert a record in GL_TIMESYNC with data relative to a single unpack
//-------------------------------------------------------------------------------------------
   try {
     PamelaDBOperations::insertPamelaGL_TIMESYNC(sqlServer, rawPathName, rawFileName);
   } catch (YException exc) {
     cout << "Eccezione! " << exc.print() << "\n" ;
   }

 
//-------------------------------------------------------------------------------------------
      //Generate the Registry files for a single unpack
//-------------------------------------------------------------------------------------------
    try {
        PamelaDBOperations::createPamelaRegistry(sqlServer, rawPathName, rawFileName, true);
    } catch (YException exc) {
      cout << "Eccezione! " << exc.print() << "\n" ;
    }
//-------------------------------------------------------------------------------------------

      //Insert in GL_RUN runs information records relative to a single unpack
//-------------------------------------------------------------------------------------------
    try {
        PamelaDBOperations::insertPamelaRUN(sqlServer, rawPathName, rawFileName);
    } catch (YException exc) {
      cout << "Eccezione! " << exc.print() << "\n" ;
    }
    
//-------------------------------------------------------------------------------------------

      //Insert in GL_CALO_CALIB calibration information records relative to a single unpack
//-------------------------------------------------------------------------------------------
    try {
        PamelaDBOperations::insertNEW_CALO_CALIB(sqlServer, rawPathName, rawFileName);
    } catch (YException exc) {
      cout << "Eccezione! " << exc.print() << "\n" ;
    }
//-------------------------------------------------------------------------------------------


      //Insert in GL_S4_CALIB calibration information records relative to a single unpack
//-------------------------------------------------------------------------------------------
    try {
        PamelaDBOperations::insertNEW_S4_CALIB(sqlServer, rawPathName, rawFileName);
     } catch (YException exc) {
      cout << "Eccezione! " << exc.print() << "\n" ;
    }
//-------------------------------------------------------------------------------------------

      //Insert in GL_TRK_CALIB calibration information records relative to a single unpack
//-------------------------------------------------------------------------------------------
    try {
       PamelaDBOperations::insertNEW_TRK_CALIB(sqlServer, rawPathName, rawFileName);
     } catch (YException exc) {
      cout << "Eccezione! " << exc.print() << "\n" ;
    }
//---------------------------------------------------------------------------------------
  sqlServer->Close();
  logger->info("<-------------------------------END UNPACKING------------------------------->\n");
  //return 1;
}
1
2	#include <log4cxx/logger.h>
3	#include <log4cxx/basicconfigurator.h>
4	#include <log4cxx/fileappender.h>
5	#include <log4cxx/patternlayout.h>
6	#include <log4cxx/propertyconfigurator.h>
7
8	#include <TSQLServer.h>
9	#include <TSQLResult.h>
10	#include <YSQLConnection.h>
11	#include <PamelaDBOperations.h>
12	#include <YException.h>
13
14	#include <cstdlib>
15	#include <iostream>
16	#include <errno.h>
17
18	extern "C" {
19	#include <dirent.h>
20	}
21
22	using namespace log4cxx;
23	using namespace std;
24	using namespace yngn::YException;
25	using namespace pamela;
26
27	static LoggerPtr logger = Logger::getLogger(_T("YodaProfiler"));
28
29	/*
30	NOTE!!!
31	This program assume that on the '.' directory is present a structure having a
32
33	- filesFromYoda folder containing the unpacked data
34	*/
35
36	int main(int argc, char* argv[]) {
37
38	/*
39	if (argc < 2){
40	printf("You have to insert at least the file to analyze \n");
41	printf("Try '--help' for more information. \n");
42	exit(1);
43	}
44
45	if (!strcmp(argv[1], "--help")){
46	printf( "Usage: -exec[operation] [OPTIONS] \n");
47	printf( "\t --help Print this help and exit \n");
48	printf( "\t OPTIONS: \n");
49
50	printf( "\t -sqlParams[path] Path to the configuration file to connect to the Database server \n");
51	printf( "\t The configuration file (remember to chmod it to '500') have to be in the format \n");
52	printf( "\t #HOST=hostname \n");
53	printf( "\t #USER=username \n");
54	printf( "\t #PSW=password \n");
55	printf( "\t #DB=databaseName \n");
56
57	printf( "\t -host[name] The name of the host where the database is installed\n");
58	printf( "\t -user[name] The name of the user accessing to the database\n");
59	printf( "\t -psw[name] The password of the user accessing to the database\n");
60
61	printf( "\t Notice that by default [-host -name -password -database] overload the [-sqlParams] param \n");
62
63	printf( "\t -exec[nameOperation] Execute the required operation");
64	printf( "\t -rawPath[path] Path to the raw file \n");
65	printf( "\t -rawFile[name] Name of the raw file \n");
66
67	printf( "\n \t Operations list: \n");
68	printf( "\t insertPamelaRawFile -rawPath[path] -rawFile[name]); \n");
69	exit(1);
70	}
71
72	for (int i = 2; i < argc; i++){
73	if (!strcmp(argv[i], "-outDir")){
74	if (++i >= argc){
75	printf( "-outDir needs arguments. \n");
76	printf( "Try '--help' for more information. \n");
77	exit(1);
78	} else {
79	outDir = argv[i];
80	}
81	}
82
83	if (!strcmp(argv[i], "-xslPath"))
84	if (++i >= argc){
85	printf( "-xslPath needs arguments. \n");
86	printf( "Try '--help' for more information. \n");
87	exit(1);
88	} else {
89	xslPath = argv[i];
90	continue;
91	}
92	}
93
94	*/
95
96
97	stringstream oss;
98
99	TSQLServer *sqlServer = 0;
100	char *rawPathName = argv[1];
101	char *rawFileName = argv[2];
102	char *symbolicName = "";
103
104	char *result = NULL;
105	char buffer[999];
106	char *host = argv[3];
107	char *user = argv[4];
108	char *password = argv[5];
109	char *rootPathName = argv[6];
110	char *rootFileName = argv[7];
111
112
113	//Here I have to put some check for the arguments......
114	/*
115	ifstream config(argv[4]);
116	if (! config.is_open())
117	{ cout << "Error opening file"; exit (1); }
118	while (! config.eof() )
119	{
120	config.getline (buffer,255);
121
122	if (strstr(buffer, "=") != NULL){
123	result = strtok( buffer, "=" );
124	while( result != NULL ) {
125	//The fisrt strok skip the "user" or "password" keys
126	result = strtok( NULL, delims );
127	user = strtok( NULL, delims );
128	}
129	}
130	}*/
131	try{
132	oss.str("");
133	sqlServer = yngn::sql::YSQLConnection::getConnection(host, user, password);
134	} catch (YException exc) {
135	cout << exc.print();
136	exit(1);
137	}
138
139	//Insert a Raw file in GL_RAW
140	//-------------------------------------------------------------------------------------------
141	try {
142	PamelaDBOperations::insertPamelaRawFile(sqlServer, rawPathName, rawFileName);
143	} catch (YException exc) {
144	cout << "Eccezione! " << exc.print() << "\n" ;
145	}
146	//-------------------------------------------------------------------------------------------
147
148	//Insert single unpack ROOTs files in GL_ROOT
149	//-------------------------------------------------------------------------------------------
150	try {
151	PamelaDBOperations::insertPamelaRootFiles(sqlServer, rootPathName, rootFileName, rawPathName, rawFileName);
152	} catch (YException exc) {
153	cout << "Eccezione! " << exc.print() << "\n" ;
154	}
155	//-------------------------------------------------------------------------------------------
156
157
158	//Update a single GL_RAW record with its BOOT_NUMBER
159	//-------------------------------------------------------------------------------------------
160	try {
161	PamelaDBOperations::assignBOOT_NUMBER(sqlServer, rawPathName, rawFileName);
162	} catch (YException exc) {
163	cout << "Eccezione! " << exc.print() << "\n" ;
164	}
165	//-------------------------------------------------------------------------------------------
166
167	//Insert a record in GL_TIMESYNC with data relative to a single unpack
168	//-------------------------------------------------------------------------------------------
169	try {
170	PamelaDBOperations::insertPamelaGL_TIMESYNC(sqlServer, rawPathName, rawFileName);
171	} catch (YException exc) {
172	cout << "Eccezione! " << exc.print() << "\n" ;
173	}
174
175
176	//-------------------------------------------------------------------------------------------
177	//Generate the Registry files for a single unpack
178	//-------------------------------------------------------------------------------------------
179	try {
180	PamelaDBOperations::createPamelaRegistry(sqlServer, rawPathName, rawFileName, true);
181	} catch (YException exc) {
182	cout << "Eccezione! " << exc.print() << "\n" ;
183	}
184	//-------------------------------------------------------------------------------------------
185
186	//Insert in GL_RUN runs information records relative to a single unpack
187	//-------------------------------------------------------------------------------------------
188	try {
189	PamelaDBOperations::insertPamelaRUN(sqlServer, rawPathName, rawFileName);
190	} catch (YException exc) {
191	cout << "Eccezione! " << exc.print() << "\n" ;
192	}
193
194	//-------------------------------------------------------------------------------------------
195
196	//Insert in GL_CALO_CALIB calibration information records relative to a single unpack
197	//-------------------------------------------------------------------------------------------
198	try {
199	PamelaDBOperations::insertNEW_CALO_CALIB(sqlServer, rawPathName, rawFileName);
200	} catch (YException exc) {
201	cout << "Eccezione! " << exc.print() << "\n" ;
202	}
203	//-------------------------------------------------------------------------------------------
204
205
206	//Insert in GL_S4_CALIB calibration information records relative to a single unpack
207	//-------------------------------------------------------------------------------------------
208	try {
209	PamelaDBOperations::insertNEW_S4_CALIB(sqlServer, rawPathName, rawFileName);
210	} catch (YException exc) {
211	cout << "Eccezione! " << exc.print() << "\n" ;
212	}
213	//-------------------------------------------------------------------------------------------
214
215	//Insert in GL_TRK_CALIB calibration information records relative to a single unpack
216	//-------------------------------------------------------------------------------------------
217	try {
218	PamelaDBOperations::insertNEW_TRK_CALIB(sqlServer, rawPathName, rawFileName);
219	} catch (YException exc) {
220	cout << "Eccezione! " << exc.print() << "\n" ;
221	}
222	//---------------------------------------------------------------------------------------
223	sqlServer->Close();
224	logger->info("<-------------------------------END UNPACKING------------------------------->\n");
225	//return 1;
226	}