chewbacca/PamOffLineSW/PacketUser.cpp_02

//============================================================================
// $Id: PacketUser.cpp,v 1.66 2008-06-13 12:26:34 messineo Exp $ 
// Description : 
//============================================================================
#include "PacketUser.h"
#include <sys/time.h>

namespace PamOffLineSW
{
extern LogUtil* mainLogUtil;
extern short compression ;
extern  char *outDir;
extern TSQLServer *sqlServer;
extern bool multiFile;
extern char* fni;
extern char * nome_output;
extern bool is_new_route;
extern unsigned int download;

extern unsigned int  mmm_number;
extern unsigned int orbit_number;       
extern unsigned long int time_Offset;
extern bool tryMerge;
//marco_new_01
extern bool single_connection;

//don't perform check about continuity: it means don't use DB.
extern bool do_cont_check;

//marco_new_31:
extern char*  db_user;
extern char*  db_pwd;
extern char* connection;        

PacketUser PacketUser::instance;
        
int PacketUser::numDiscontinity=0;
int PacketUser::numPKT=0;
int PacketUser::numPKTSaved=0;

PacketUser& PacketUser::getInstance()
{
        return instance;
}

PacketUser::PacketUser()
{       
        gROOT->SetBatch(kTRUE);         
        numDiscontinity=0;
        numPKTSaved=0;
        numPKT=0;       
        pkt_number_init=0;
        obt_init=0;
        pkt_number_last=0;
        obt_last=0;
        //boot_number=0;
        obt_time_sync=0;
        last_time_sync_info=0;
        real_time_init=0;
        real_time_last=0;
        bad_pkt=0;
        bad_pkt_EventReader=0;
        bad_pkt_CalibReader=0;
        reader= NULL; 
        pRun=NULL;
        reader=new pamela::techmodel::EventReader();
        Table_ROOT_Good="ROOT_TABLE";
        Table_ROOT_Bad="ROOT_TABLE_BAD";
        Table_GL_RESURS_OFFSET="GL_RESURS_OFFSET";
        Table_ROOT_Merging="ROOT_TABLE_MERGING";        
//      good_pkt_Calib=0;
        my_id=0;
        boot_number=0;
}

PacketUser::~PacketUser()
{       
        if(reader){delete reader; reader = NULL;}
        numDiscontinity=0;
        numPKTSaved=0;
        numPKT=0;
        pkt_number_init=0;
        obt_init=0;
        pkt_number_last=0;
        obt_last=0;
        obt_time_sync = 0;
        last_time_sync_info = 0;
        real_time_init=0;
        real_time_last=0;
        bad_pkt=0;
        bad_pkt_EventReader=0;
        bad_pkt_CalibReader=0;
//      good_pkt_Calib=0;
        my_id=0;        
        boot_number=0;
}

//Put the packet in a root file. Create a new ROOT file for each group of packets 
void PacketUser::usePKT(char*& headerPkt, char*& pamPkt, long int length, bool isCons, bool isPKTGood, const PacketType* type, 
                unsigned long int counter, unsigned long int obt)
{                       
        //If the packet type was not recognised before
        if(!type){return;}
          
        //in order to start ...
        if(numPKT==0)
        {               
                //marco_new_31: metto qui se voglio avere come in origine apertura Connessione all'inizio e chiusura alla fine 
                //marco_new_01  
                if(single_connection){
                        OpenDBConnection(NULL);
                }

                setInit(counter,obt);                           
                StartGroup();
        }
                
        //here we know if the incoming packet can be considered consecutive to the previuos     one             
        if((!isCons)&&(numPKT!=0))
        {                       
                setReal_Time();                         
                //closing the  group in file rootfilename 
                FinishGroup(rootfilename);              
                
                //the current pkt will be placed in a new group: rootfilename 
                numDiscontinity++;      
                setInit(counter,obt);                   
                StartGroup();
        }
        
        //add current packet to the group and calculate bad_pkt_EventReader and bad_pkt_CalibReader
        int ret=
        reader->PKT_RunEvent(headerPkt, pamPkt, length, type);
        /*
          ret
            0    packet good
            1    exception but used    //never happen
            2    CRC exception but used
            3    CALIBRATION PACKET with error but used
           -1    CRC exception  packet DISCARDED
           -2    FATAL exception packet DISCARDED //never happen
           -3    No way to read events of this type. packet DISCARDED( es OLD CalibCal)
        ret = 10 if the packet is good but comes from a cadre with VRL problems
        */
        
        //here we know if the packet comes from one or more corrupted cadres
        //if(!isPKTGood){bad_pkt++;}
        if((!isPKTGood)&&(!ret)){ret=10;}       
        
        switch (ret) 
        {
                case 0: {numPKTSaved++; break;}
                case 1: {bad_pkt_EventReader++; numPKTSaved++; break;}
                case 2: {bad_pkt_EventReader++;numPKTSaved++;  break;}
                case 3: {bad_pkt_CalibReader++; numPKTSaved++; break;}
                case 10: {bad_pkt++; numPKTSaved++; break;}
                default:{ 
                        stringstream oss;
                        oss.str()="";
                        oss<<"Packet DISCARDED, reason = "<<ret;
                        string msg = oss.str();
                        mainLogUtil->logAll(msg);
                        break;
                }
        }
/*      
        if ((ret==0)&&((type==PacketType::CalibTrk1)||(type==PacketType::CalibTrk2)|| (type==PacketType::CalibCalPed)))
        {                               
                good_pkt_Calib++;//maybe I will remove this in future
        }
*/      
        
        if(ret>=0)// only the packet not discarded of course
                setLast(counter,obt);
        
//TODO: decide what kind of packet I can use here
//      if((ret==0)||(ret==10))//I want to use only good packet 
        if(ret>=0)//I want to use only accepted packet
        {       
                setTimeSync(pamPkt, length, type);//marco_new here I retrieve also the boot_number if packet type is vardump
        }
        //just to be sure ...
        if(pamPkt){delete[] pamPkt; pamPkt = NULL;}     
        //just to be sure ...
        if(headerPkt){delete[] headerPkt; headerPkt = NULL;}

        numPKT++;               
}

//set the value of the counter and obt of the first packet of the group 
void PacketUser::setInit(unsigned long int counter, unsigned long int obt)
{                               
        sprintf(nnnn_mmm_ppp,"%05d_%03d_%03d", orbit_number, mmm_number, download);     
        //marco_new: controlla se � possibile aggiungere qui .root
        sprintf(rootfilename,"%s_%s_%d", nome_output, nnnn_mmm_ppp, numDiscontinity);
        pkt_number_init=counter;
        obt_init=obt;
        pkt_number_last=0;
        obt_last=0;
        real_time_init=0;
        real_time_last=0;
        bad_pkt=0;      
        numPKTSaved=0;
        bad_pkt_EventReader=0; bad_pkt_CalibReader=0;
        //good_pkt_Calib=0;
        boot_number=0;
}

//starts a new root file
void PacketUser::StartGroup()
{       
        //marco_new: Check qui se posso gia avere estensione .root
        pRun = new PamelaRun(rootfilename, outDir , multiFile, compression);
        //marco_new: aggiunta estensione .root
        strcat(rootfilename,".root");
        reader->Init(pRun);                     
        stringstream oss;
        oss.str()="";
        oss<<"######################### Start a new group in file: "<< rootfilename <<" ############################";
        string msg = oss.str();
        mainLogUtil->logInfo(msg);
}

//set the value of the counter and obt of the last packet of the group 
void PacketUser::setLast(unsigned long int counter, unsigned long int obt)
{
        pkt_number_last=counter;
        obt_last=obt;
}

//Boot Number
void PacketUser::setBootNumber(char* packet, long int pktLength, const PacketType* type)
{
//      cout<<"setBootNumber ## INIT: boot_number= "<<boot_number<<" b_offset= NN "<<" pktLength= "<<pktLength<<endl;

        //se gia calcolato esco 
        if(boot_number) return;

        if(PacketType::VarDump)
        {       
                long int  dataLength = pktLength - 2; //the block of data
//todo: controlla se algo giusto: preso da VarDumpReader.cpp    
                int b_offset = 4;
                while (b_offset < dataLength){
                 boot_number  = (((UINT32)packet[1+b_offset]<<24)&0xFF000000) + (((UINT32)packet[2+b_offset]<<16)&0x00FF0000) +  (((UINT32)packet[3+b_offset]<<8)&0x0000FF00) + (((UINT32)packet[4+b_offset])&0x000000FF);
//               cout<<"setBootNumber ## WHILE: boot_number= "<<boot_number<<" b_offset= "<<b_offset <<" dataLength= "<<dataLength<<endl;               
                 b_offset = b_offset + 5;
                }
                 cout<<"setBootNumber ## boot_number= "<<boot_number<<endl;             
                return;
        }
        else
        {       
                return;
        }               

}

//retrieve obt_time_sync and last_time_sync_info from packet if type has special values 
void PacketUser::setTimeSync(char* packet, long int pktLength, const PacketType* type)
{
    //do nothing 
        if(!do_cont_check) {
                if(is_new_route)
                        is_new_route=false;
                return; 
        }
        
//TODO: usare anche MCMD ... NOTA: questo da sempre errore ret != 0 
//In RunHeader e RunTrailer sono in secondi(?), controllare se aggiungo altri tipi di paccheti se invece sono in secondi
        
        //When I found a new download I need to reset all values
        if(is_new_route)
        {   
          //reset
          obt_time_sync=0; last_time_sync_info=0; is_new_route=false;
          boot_number=0;//marco_new check this
          if(time_Offset)
             timeOffset=time_Offset;
          else          
            timeOffset=retrieveTimeOffset(Table_GL_RESURS_OFFSET);
        }
        
        //retrieve boot number if possible
        setBootNumber(packet,pktLength,type);

        //Retrieve if possible obt_time_sync and last_time_sync_info
        int offset=0;
        if(type==PacketType::RunHeader)
        {               
                offset=0;
        }
        else if(type==PacketType::RunTrailer)
        {       
                offset=3;
        }
        else if(type==PacketType::Mcmd)
        {       
//              mainLogUtil->logAll("TODO: Packet Mcmd now is not used to retrieve Absolute time. This may cause problems somewhere.");
                return;
        }
        else
        {       
                return;
        }               
        
        //I don't need to retrieve them again if they are good
        if((obt_time_sync)||(last_time_sync_info)) return;

        obt_time_sync = (((UINT32)packet[5+offset]<<24)&0xFF000000) + (((UINT32)packet[6+offset]<<16)&0x00FF0000) + (((UINT32)packet[7+offset]<<8)&0x0000FF00) + (((UINT32)packet[8+offset])&0x000000FF); 
        last_time_sync_info = (((UINT32)packet[9+offset]<<24)&0xFF000000) + (((UINT32)packet[10+offset]<<16)&0x00FF0000) + (((UINT32)packet[11+offset]<<8)&0x0000FF00) + (((UINT32)packet[12+offset])&0x000000FF);              

        stringstream oss;
        oss.str()="";
        oss<<"In download: "<<download<<" timeOffset: "<<timeOffset<<" obt_time_sync: "<<obt_time_sync<<" last_time_sync_info: "<<last_time_sync_info<<" using Packet Type: "<<type->GetName().c_str();
        string msg = oss.str();
        mainLogUtil->logAll(msg);
}

//set the real time of the first packet and the last packet oif a group of packet if possible
void PacketUser::setReal_Time()
{
        if((obt_time_sync)||(last_time_sync_info))
        {               
                real_time_init=(obt_init/1000-obt_time_sync)+last_time_sync_info;
                real_time_last=(obt_last/1000-obt_time_sync)+last_time_sync_info;       
                real_time_init+=timeOffset;
                real_time_last+=timeOffset;             
        }       
}

//timeOffset
//retrieve from table Table_GL_RESURS_OFFSET timeOffset  
unsigned long int PacketUser::retrieveTimeOffset(char * table)
{       
        //TODO check here ... marco               
        if(!do_cont_check) return 0;
        
        //if(!table){table=Table_GL_RESURS_OFFSET}

        //marco_new_31:metto qui se voglio aprire e chiudere Connessione solo quando serve
        //marco_new_01  
        if(!single_connection){
                OpenDBConnection(table);//Nota qui ho deciso di lockare solo questa tabella e non tutte
        }

        UInt_t t0 = 0;  //toffset               
                        
        stringstream oss;
        oss.str("");
        oss << "SELECT YEAR(OFFSET_DATE),MONTH(OFFSET_DATE),DAY(OFFSET_DATE),HOUR(OFFSET_DATE),MINUTE(OFFSET_DATE),SECOND(OFFSET_DATE),ID FROM "<<      table <<" WHERE SPECIAL_FILE='" 
              << nnnn_mmm_ppp << "';";

        string msg = oss.str();
        mainLogUtil->logAll(msg);       

        TSQLResult* res=NULL;                            
        TSQLRow* row=NULL;      
        res= sqlServer->Query(oss.str().c_str());                         
        if(!res)
        {       
        cout<<"DBError UNABLE to: "<<oss.str().c_str()<<endl;
                return 0;
        }

    row=res->Next();
    if (!row )
    {
        if(res){delete res; res = NULL;}

        oss.str("");
        oss << "SELECT YEAR(OFFSET_DATE),MONTH(OFFSET_DATE),DAY(OFFSET_DATE),HOUR(OFFSET_DATE),MINUTE(OFFSET_DATE),SECOND(OFFSET_DATE),ID FROM "<<      table <<" WHERE FROM_ORBIT < " 
        << orbit_number << " order by FROM_ORBIT desc limit 1;";
        res= sqlServer->Query(oss.str().c_str());                       
        if(!res)
        {               
                cout<<"DBError UNABLE to: "<<oss.str().c_str()<<endl;
                return 0;
        }
        row=res->Next();
        if (!row) 
        {
                cout<<"DBError UNABLE to: "<<oss.str().c_str()<<endl;
                return 0;
        }
                 
     }
     
      TTimeStamp tu = TTimeStamp((UInt_t)atoi(row->GetField(0)),(UInt_t)atoi(row->GetField(1)),(UInt_t)atoi(row->GetField(2)),(UInt_t)atoi(row->GetField(3)),(UInt_t)atoi(row->GetField(4)),(UInt_t)atoi(row->GetField(5)),0,true,0);
      t0 = (UInt_t)tu.GetSec();
      
        if(res){delete res; res = NULL;}
        if(row){delete row; row = NULL;}        

        //marco_new_31:metto qui se voglio aprire e chiudere Connessione solo quando serve
        //marco_new_01  
        if(!single_connection){
                CloseDBConnection();            
        }
 return t0;
}

//this is public and can be called from the main at the end of the game
void PacketUser::FinishLastGroup()
{       
        mainLogUtil->logAll("######################### Closing the last group ############################");   
        setReal_Time();
        FinishGroup(rootfilename);
        mainLogUtil->logAll("######################### Closed the last group ############################");
        
        //marco_new_31:metto qui se voglio avere come in origine apertura Connessione all'inizio e chiusura alla fine 
        //marco_new_01  
        if(single_connection){
                CloseDBConnection();            
        }
}

//Finish the old root file
void PacketUser::FinishGroup(char * filename)
{
        if(pRun)
        {
                pRun->WriteFiles();                             
                delete pRun; pRun = NULL;               
                stringstream close;
                close.str()="";
                string msg;

                close<<"######################### Close group in file: "<< rootfilename <<" ############################";
                msg = close.str();
                mainLogUtil->logInfo(msg);

                //TODO:  ... se non faccio proprio controlli su continuita' neanche salvo su DB
                if(!do_cont_check) return;
        
                stringstream oss;
                oss.str()="";
                
                //TODO: check when I don't want to log in DB informations

                // se non ho salvato nessun pacchetto
                if(numPKTSaved==0){                     
                        stringstream err;
                        err.str()="";
                        err<<"NO PACKET SAVED in file: "<< rootfilename <<" The group is empty: you can remove this file.";
                        msg = err.str();
                        mainLogUtil->logError(msg);
                        return;
                }
                        
                //se non ho salvato nessun pacchetto buono
                if((numPKTSaved-bad_pkt_EventReader-bad_pkt_CalibReader-bad_pkt)==0){                   
                        stringstream err;
                        err.str()="";
                        err<<"NO GOOD PACKET SAVED in file: "<< rootfilename <<" The group is BAD: you may want to remove this file.";
                        msg = err.str();
                        mainLogUtil->logInfo(msg);
//                      mainLogUtil->logError(msg);
//                      return; //TODO: decidi se nn vuoi affatto usarlo o addirittura salvarlo tra i BAD???
                }

                //marco_new_31:metto qui se voglio aprire e chiudere Connessione solo quando serve
                //marco_new_01  
                if(!single_connection){
                        OpenDBConnection(NULL);//Nota qui ho deciso di lockare tutte le tabelle
                }
                
                //don't save in Table_ROOT_Good and don't search for ROOT files in the same temporal range
                if((!real_time_init)&&(!real_time_last))
                { 
                        //saved in another table for future study         Record_Time() 
                        if(saveROOT_DB(Table_ROOT_Bad, outDir,
                                                                filename, 
                                                           pkt_number_init, pkt_number_last,
                                                           obt_init, obt_last,
                                                           obt_time_sync, last_time_sync_info,     
                                                           real_time_init, real_time_last,
                                                           boot_number,
                                                           timeOffset,
                                                           bad_pkt, bad_pkt_EventReader, bad_pkt_CalibReader, numPKTSaved,
                                                           fni)==true)
                                {
                                        oss.str()="";
                                        oss<<"Saved information regarding file: "<<filename<<" in table "<<Table_ROOT_Bad;
                                        msg = oss.str();
                                        mainLogUtil->logInfo(msg);      
                                }
                                else
                                {       
                                        oss.str()="";
                                        oss<<"Problem storing information in DB regarding file: "<<filename;
                                        msg = oss.str();
                                        mainLogUtil->logError(msg);             
                                }                       
                
                        //marco_new_31:metto qui se voglio apriree chiudere Connessione solo quando serve
                                //marco_new_01  
                        if(!single_connection){
                                CloseDBConnection();            
                        }

                return;
                }
                                        
                //saves info in DB in table Table_ROOT_Good
                if(saveROOT_DB(Table_ROOT_Good, outDir,
                                        filename, 
                                   pkt_number_init, pkt_number_last,
                                   obt_init, obt_last,
                                   obt_time_sync, last_time_sync_info,     
                                   real_time_init, real_time_last,
                                   boot_number,
                                   timeOffset,
                                   bad_pkt, bad_pkt_EventReader, bad_pkt_CalibReader, numPKTSaved,
                                   fni)==true)
                {                                               
                        oss<<"Saved information regarding file: "<<filename<<" in table "<<Table_ROOT_Good<< "id= "<<my_id;
                        msg = oss.str();
                        mainLogUtil->logInfo(msg);      
                        
                        //TODO : work on this ....                      
                        if(tryMerge){                           
                            merge_ROOTfiles();
                        }
                }
                else
                {
                        oss<<"Problem storing information in DB regarding file: "<<filename;
                        msg = oss.str();
                        mainLogUtil->logError(msg);     
                }                               

                //marco_new_31:metto qui se voglio apriree chiudere Connessione solo quando serve
                        //marco_new_01  
                if(!single_connection){
                        CloseDBConnection();            
                }

        }//pRun
}


//save in Table_ROOT_Good or in Table_ROOT_Bad
bool PacketUser::saveROOT_DB(char* table_name, char* folder_name, char* file_name, 
                unsigned long int pkt_number_in, unsigned long int pkt_number_fin,
                unsigned long int obt_in, unsigned long int obt_fin,
                unsigned long int  oT_sync, unsigned long int lT_sync_info,        
                unsigned long int mtime_init,   unsigned long int mtime_last, 
                unsigned long int mboot_num,
                unsigned long int time_offset,  
                int bad_pkt, int bad_pkt_read, int bad_pkt_CalRead, int num_PKT_Saved,          
                char* nome_input){                      
        //TODO: forse far ritornare ID della cosa appena inserita se e' andatato tutto ok invece che true false?        
        stringstream oss;
        oss.str("");    
        oss << "INSERT INTO "<< table_name <<" (ID_N, FOLDER_NAME, FILE_NAME, PKT_NUMBER_INIT, PKT_NUMBER_FINAL, PKT_OBT_INIT, PKT_OBT_FINAL, OBT_TIME_SYNC, LAST_TIME_SYNC_INFO, REAL_TIME_INIT, REAL_TIME_LAST, BOOT_NUMBER, TIME_OFFSET,BAD_PKT,BAD_PKT_READ,BAD_PKT_CALREAD,NUM_PKT_SAVED,INPUT_NAME,INSERT_TIME)"
    << " VALUES ('"<<0<< "','" <<folder_name<<"','" <<file_name<< "','" << pkt_number_in <<"','"<< pkt_number_fin << "','"<< obt_in <<"','"<< obt_fin<< "','" 
    << oT_sync << "','" << lT_sync_info << "','"
    << mtime_init << "','" << mtime_last << "','"
        << mboot_num << "','"
    << time_offset << "','"
    << bad_pkt <<"','" << bad_pkt_read <<"','"<< bad_pkt_CalRead <<"','"<< numPKTSaved<<"','"
    << nome_input <<"',"
    <<"NULL"<<      
    ")";            
        string msg = oss.str();
        mainLogUtil->logAll(msg);       
        
        stringstream oss1;
        oss1.str()="";
        string msg1;
   
   TSQLResult* res=NULL;        
   res= sqlServer->Query(oss.str().c_str());
   if(!res)
   {    
           oss1<<"DBError UNABLE to: "<<oss.str().c_str()<<endl;   
           msg1=oss1.str();
           mainLogUtil->logError(msg1);   
           return false;
   }

   //marco_new: si pu� ottimizzare ...
   //the ID of the current ROOT file in table Table_ROOT_Good
         my_id = select_maxIDN_DB(table_name);
        cout<<"DBG: my_id = "<<my_id<<endl;
   if(res){delete res; res = NULL;}
   return true;
}

/**********************************************************************************************/
/*###########################################################################################################*/
/**********************************         MERGING          *************************************************/
/*###########################################################################################################*/
//      Merge ROOT files: found other ROOT files in the same temporal ranges
//    it finds ROOT files that covers particular temporal range of interest and save this info in DB
/**********************************************************************************************/

bool PacketUser::merge_ROOTfiles()
{
        mainLogUtil->logInfo("merge_ROOTfiles ...");

  //marco_new: controlla
  double percentage=(double)(bad_pkt+bad_pkt_EventReader+bad_pkt_CalibReader)/numPKTSaved;
  cout<<"DBG: percentage: "<< percentage<<endl;
        
  TSQLResult* res=NULL;  
  TSQLRow* row =NULL;

  //marco_new: non considero mai caso di continuit�(mio finale=DB iniz o viceversa), non mi interessa
  //marco_new: after e before contengono anche smaller ma con un bordo comune
  for(int relaz=AFTER; relaz<=BIGGER; relaz++)
  {             
        //marco_new: controlla tutto
        //marco_new: esci se sono arrivato a zero
        if(real_time_last==real_time_init){     
                mainLogUtil->logInfo("FINE MERGING lenght=0 ...");                              
                if(res){delete res; res = NULL;}
                if(row){delete row; row = NULL;}
                return true;                            
        }

        res = Select_merging(Table_ROOT_Merging, real_time_init, real_time_last, (type_Rel_ROOT)relaz);
        cout<<"MMMMM valori usati: real_time_init= "<< real_time_init<< " real_time_last= "<<real_time_last;
        unsigned int num_rows=0;
         if (!res) 
         {
                 mainLogUtil->logError("Query problem");
                 return false;
         }

         num_rows=res->GetRowCount();
         cout<<"MMMMM trovati num_rows "<< num_rows<< " per relaz= "<<relaz;

         if(num_rows>0)
         {                      
                 for(unsigned int i=0; i<num_rows; i++)
                 {
                         row=res->Next();
                         if (!row) 
                         {
                                //oss1<<"DBError UNABLE to: "<<query.str().c_str()<<endl;   
                                 //msg1=oss1.str();
                                mainLogUtil->logError("ROW=null");
                                if(res){delete res; res = NULL;}
                                return false;
                         }
                         

                        //TODO ricavare tutte le info che servono
                        unsigned int idN = 0;      
                        idN=atoi(row->GetField(0));
                
                        double perc =0;                 
                        //marco_new: atof .. controllare
                        perc=atof(row->GetField(9));
                        //unsigned long int M_pkt_number_in, M_pkt_number_fin, M_obt_in, M_obt_fin, M_mtime_init, M_mtime_last; 
                        if(perc>percentage){
                                mainLogUtil->logInfo("current meglio ...");                     
                                //moodifica DB
                                updateMergeROOT_DB(Table_ROOT_Merging,
                                        atoi(row->GetField(1)), atoi(row->GetField(2)),
                                        atoi(row->GetField(3)), atoi(row->GetField(4)),
                                        atoi(row->GetField(5)), atoi(row->GetField(6)),
                                        atoi(row->GetField(7)), atoi(row->GetField(8)), 
                                        perc,
                                        idN,(type_Rel_ROOT)relaz);
                        }
                        else{
                                mainLogUtil->logInfo("DB meglio o uguale...");
                                if(relaz == AFTER){
                                        mainLogUtil->logInfo("AFTER: modifico i miei INIT ...");                
                                        pkt_number_init= atoi(row->GetField(3));
                                        obt_init= atoi(row->GetField(5));
                                        real_time_init= atoi(row->GetField(7));                                 
                                }
                                else if(relaz == BEFORE){
                                        mainLogUtil->logInfo("BEFORE: modifico i miei LAST ...");               
                                        pkt_number_last= atoi(row->GetField(2));
                                        obt_last= atoi(row->GetField(4));
                                        real_time_last= atoi(row->GetField(6));
                                }
                                else if(relaz == SMALLER)
                                {
                                        //non devo proprio salvarlo ed esco ...
                                        //nothing to merge
                                        mainLogUtil->logInfo("Smaller: Fine Merging ESCO ...");                 

                                        if(res){delete res; res = NULL;}
                                        if(row){delete row; row = NULL;}
                                        return true;//marco_new: check ... non devo salvare niente ...
                                }
                                else if(relaz == BIGGER)//spezzettamento
                                {       

                                        mainLogUtil->logInfo("BIGGER SALVO LA prima parte del MIO CURRENT MODIFICATO ...");                     
                                        saveMergeROOT_DB(Table_ROOT_Merging, my_id,
                                                pkt_number_init, atoi(row->GetField(2)),
                                                obt_init, atoi(row->GetField(4)),
                                                real_time_init, atoi(row->GetField(6)),
                                                boot_number,
                                                percentage);
                                        
                                        mainLogUtil->logInfo("BIGGER: modifico i miei INIT per la seconda parte...");           
                
                                        pkt_number_init= atoi(row->GetField(3));
                                        obt_init= atoi(row->GetField(5));
                                        real_time_init= atoi(row->GetField(7));
                                }
                        }
                }//for num_rows    
          }
        else{
                //marco_new: niente da fare rimuovi questa linea sotto
                mainLogUtil->logInfo("TROVATI 0 ...");
        }

        //marco_new:??? 
        if(res){delete res; res = NULL;}
        if(row){delete row; row = NULL;}        
}//for

        mainLogUtil->logInfo("MMMM SALVO IL MIO CURRENT MODIFICATO ...");               
        saveMergeROOT_DB(Table_ROOT_Merging, my_id,
                         pkt_number_init, pkt_number_last,
                         obt_init, obt_last,
                         real_time_init, real_time_last,
                         boot_number,
                         percentage);


  mainLogUtil->logInfo("Fine Merging ");        
  return true;
}

//unsigned int root_id,  percentage non le devo modificare
bool PacketUser::updateMergeROOT_DB(char* table_name,
                        unsigned  int root_id,
                        unsigned long int pkt_number_in, unsigned long int pkt_number_fin,
                        unsigned long int obt_in, unsigned long int obt_fin,
                unsigned long int mtime_init,   unsigned long int mtime_last,
                        unsigned long int mboot_num,
                        double bad_perc,
                        unsigned int ID_record, type_Rel_ROOT type_rel){
        stringstream oss;
        oss.str("");    
        
        if(type_rel == AFTER){
                //marco_new:tolti tutti gli apici che qui non devono essere
                oss << "UPDATE "<< table_name 
                << " SET PKT_NUMBER_FINAL ="<< pkt_number_init  
                        <<", PKT_OBT_FINAL ="<< obt_init
                    <<", REAL_TIME_LAST ="<< real_time_init<<" WHERE ID_N ="<< ID_record <<";";
        }
        else if(type_rel == BEFORE){            
                //marco_new:ok
                oss << "UPDATE "<< table_name 
                << " SET PKT_NUMBER_INIT ="<< pkt_number_last   
                        <<", PKT_OBT_INIT ="<< obt_last
                    <<", REAL_TIME_INIT ="<< real_time_last<<" WHERE ID_N ="<< ID_record<<";";
        }
        else if(type_rel == SMALLER){           
                //spezzettamentento
                mainLogUtil->logInfo("SMALLER perparo UPDATE PER PRIMA PARTE SU DB, MODIFICO final VALUES..."); 
                oss << "UPDATE "<< table_name 
                        << " SET PKT_NUMBER_FINAL="<< pkt_number_init   
                        <<", PKT_OBT_FINAL ="<< obt_init
                            <<", REAL_TIME_LAST ="<< real_time_init<<" WHERE ID_N ="<< ID_record<<";";

                        mainLogUtil->logError("MMMM SMALLER SALVO LA seconda parte di quello sul DB MODIFICATO ...");                   
                        saveMergeROOT_DB(table_name, root_id,
                         pkt_number_last, pkt_number_fin,
                         obt_last, obt_fin,
                         real_time_last, mtime_last,
                         mboot_num,
                         bad_perc);
        }
        else if(type_rel == BIGGER){
        //marco_new: ok anche se coincidenti etc
          oss << "DELETE FROM "<< table_name <<" WHERE ID_N ="<< ID_record<<";";
                mainLogUtil->logInfo("Rimosso record in Tabella merging");      
        }
        else 
                return false;


        cout<<"$$$$$ DBG: UPDATE MERGE "<<oss.str().c_str()<<endl;

        string msg = oss.str();
        mainLogUtil->logAll(msg);       
        
        stringstream oss1;
        oss1.str()="";
        string msg1;
   
   TSQLResult* res=NULL;        
   res= sqlServer->Query(oss.str().c_str());
   if(!res)
   {    
           oss1<<"DBError UNABLE to: "<<oss.str().c_str()<<endl;   
           msg1=oss1.str();
           mainLogUtil->logError(msg1);   
           return false;
   }
   if(res){delete res; res = NULL;}
   return true;
}

//marco_new: check here
TSQLResult* PacketUser::Select_merging(char* table_name, unsigned long int mtime_init, unsigned long int mtime_last, type_Rel_ROOT type_rel)
{

//      unsigned  int idN=0;
        TSQLResult* res=NULL;
        stringstream query;
        query.str("");

        //marco_new bordi: messo in after a before casi in cui smaller con un bordo in comune
        //marco_new bordi: messo in bigger casi con bordi in comune; tra questi anche caso particolare di coincidente
        //marco_new bordi: smaller resta solo caso in cui DB � piu largo sia a dx che a sx
        if(type_rel == AFTER)
          query<<"select * from "<<table_name<<" where REAL_TIME_LAST > "<< mtime_init <<" and REAL_TIME_LAST <= "<< mtime_last <<" and REAL_TIME_INIT < "<< mtime_init;
        else if(type_rel == BEFORE)
          query<<"select * from "<<table_name<<" where REAL_TIME_INIT >= "<< mtime_init <<" and REAL_TIME_INIT < "<< mtime_last <<" and REAL_TIME_LAST > "<< mtime_last;
        else if(type_rel == SMALLER) 
          query<<"select * from "<<table_name<<" where REAL_TIME_INIT < "<< mtime_init <<" and REAL_TIME_LAST > "<< mtime_last;
        else if(type_rel == BIGGER) 
                query<<"select * from "<<table_name<<" where REAL_TIME_INIT >= "<< mtime_init <<" and REAL_TIME_LAST <= "<< mtime_last;
        else 
                return 0;
        
        query<< " order by REAL_TIME_INIT ASC";//marco_new: inutile
        //      query<<" and NUM_PKT_SAVED - BAD_PKT_CALREAD - BAD_PKT_READ - BAD_PKT >= 2" ;
        cout<<"$$$$$ DBG: "<<query.str().c_str()<<endl;
  
        res= sqlServer->Query(query.str().c_str());
         
        stringstream oss1;
         oss1.str()="";
         string msg1;
  
         if (!res) 
         {
                 oss1<<"DBError UNABLE to: "<<query.str().c_str()<<endl;   
                 msg1=oss1.str();
                 mainLogUtil->logError(msg1);   
         }      

        return res;
}

bool PacketUser::saveMergeROOT_DB(char* table_name,  unsigned int root_id,
                        unsigned long int pkt_number_in, unsigned long int pkt_number_fin,
                        unsigned long int obt_in, unsigned long int obt_fin,
                unsigned long int mtime_init,   unsigned long int mtime_last, 
                        unsigned long int mboot_num,
                        double percentage)
{

        stringstream oss;
        oss.str("");    
        oss << "INSERT INTO "<< table_name <<" (ID_N, ROOT_ID_N, PKT_NUMBER_INIT, PKT_NUMBER_FINAL, PKT_OBT_INIT, PKT_OBT_FINAL, REAL_TIME_INIT, REAL_TIME_LAST, BOOT_NUMBER, BAD_PKT_PERCENTAGE, INSERT_TIME)"
    << " VALUES ('"<<0<< "','" <<root_id<<"','"<< pkt_number_in <<"','"<< pkt_number_fin << "','"<< obt_in <<"','"<< obt_fin<< "','" 
    << mtime_init << "','" << mtime_last << "','"
        << mboot_num <<"','"
        << percentage <<"',"      
    <<"NULL"<<      
    ")";

        string msg = oss.str();
        mainLogUtil->logAll(msg);       

        //marco_new: controlla
        //marco_new: esci se sono arrivato a zero
//      if(real_time_last==real_time_init){     
        if(mtime_init==mtime_last){     
                mainLogUtil->logInfo("Nulla da salvare lenght = 0 ... non effettuo INSERT");                    
//              if(res){delete res; res = NULL;}
//              if(row){delete row; row = NULL;}
                return true;                            
        }


        stringstream oss1;
        oss1.str()="";
        string msg1;
 
   TSQLResult* res=NULL;        
   res= sqlServer->Query(oss.str().c_str());
   if(!res)
   {    
           oss1<<"DBError UNABLE to: "<<oss.str().c_str()<<endl;   
           msg1=oss1.str();
           mainLogUtil->logError(msg1);   
           return false;
   }
   if(res){delete res; res = NULL;}
   return true;
}

//Utility: return max(IDN) 
unsigned  int PacketUser::select_maxIDN_DB(char* table_name)
{

if (!strcmp(table_name,Table_ROOT_Bad)) 
{
        cout<<"DBG: my_id ok unused table: "<<Table_ROOT_Bad<<endl;
        return 0;       
}
        unsigned  int idN=0;
        TSQLResult* res=NULL;
        stringstream oss;
    oss.str("");
    oss<<"select max(ID_N) from "<<table_name;
    res= sqlServer->Query(oss.str().c_str());
                
        stringstream oss1;
        oss1.str()="";
        string msg1;
        
        if(!res)
        {       
           oss1<<"DBError UNABLE to: "<<oss.str().c_str()<<endl;   
                msg1=oss1.str();
                mainLogUtil->logError(msg1);   
                return 0;
        }
           
        TSQLRow* row=NULL;      
        row=res->Next();
    if (!row ) 
    {
           oss1<<"DBError UNABLE to: "<<oss.str().c_str()<<endl;   
                msg1=oss1.str();
                mainLogUtil->logError(msg1);   
                return 0;
        }

        idN=atoi(row->GetField(0));
        if(row){delete row; row = NULL;}
        if(res){delete res; res = NULL;}
        return idN;
}

/**
 * Lock par=table, if par=null lock all tables
 */
int PacketUser::LockTables(char* tableTobeLocked)
{  
        //se non ho il DB  :)
        if(!do_cont_check) return 999;

        TSQLResult* res=NULL;
        stringstream oss;
    oss.str("");
        if(!tableTobeLocked)
                oss << "lock table "<<Table_ROOT_Good<<" write, "<<Table_ROOT_Bad<<" write, "<<Table_GL_RESURS_OFFSET<<" write, "<<Table_ROOT_Merging<<" write;";
        else
                oss << "lock table "<<tableTobeLocked<<" write; ";
        res= sqlServer->Query(oss.str().c_str());
                
        stringstream oss1;
        oss1.str()="";
        string msg1;
        
        if(!res)
        {       
           oss1<<"DBError UNABLE to: "<<oss.str().c_str()<<endl;   
                msg1=oss1.str();
                mainLogUtil->logError(msg1);   
                return 1;
        }
           
        if(res){delete res; res = NULL;}        
        mainLogUtil->logAll("######################### TABLES LOCKED ############################");                    
        return 0;       
}


/**
 * UNLock tables
 */
int PacketUser::UnLockTables(){  
        //se non ho il DB  :)  
        if(!do_cont_check) return 999;

        TSQLResult* res=NULL;
        stringstream oss;
    oss.str("");
        oss << "unlock tables;";
    res= sqlServer->Query(oss.str().c_str());
                
        stringstream oss1;
        oss1.str()="";
        string msg1;
        
        if(!res)
        {       
           oss1<<"DBError UNABLE to: "<<oss.str().c_str()<<endl;   
                msg1=oss1.str();
                mainLogUtil->logError(msg1);   
                return 1;
        }
                
        if(res){delete res; res = NULL;}        
        mainLogUtil->logAll("######################### TABLES UNLOCKED ############################");  

        return 0;       
}

/*********************************************************/
//marco_new_31
void PacketUser::OpenDBConnection(char* tableTobeLocked){ 
        mainLogUtil->logAll("######################### OpenDBConnection ############################"); 
        if(do_cont_check){
                //controllo che non sia gi� aperta
                if(!sqlServer){
                        sqlServer = TSQLServer::Connect(connection,db_user,db_pwd);
                        if ((!sqlServer)||(!(sqlServer->IsConnected()))){cout<<"Can not connect with MYSQL sever"<<endl;}       

                        //marco_new: blocca tutte le tabelle
                        LockTables(tableTobeLocked);
                        mainLogUtil->logAll("######################### OpenDBConnection OK ############################");      
                }
        }

}

//marco_new_31
void PacketUser::CloseDBConnection(){ 
        mainLogUtil->logAll("######################### CloseDBConnection ############################");        
        if(do_cont_check){                                      
                //controllo che ce ne sia una aperta
                if(sqlServer && sqlServer->IsConnected()){
                        //marco_new: sblocca tutte le tabelle
                        UnLockTables();         
                        sqlServer->Close();

                        //marco_new_01: ??
                        delete sqlServer;
                        
                        sqlServer=NULL;
                        mainLogUtil->logAll("######################### CloseDBConnection OK ############################");     
                } 
        }
}


/***********************************************************************************************************************/
/*#################################################### HIC SUNT LEONES ################################################*/
/***********************************************************************************************************************/
//UNUSED: dbg functions...

//Return the system time in ms
unsigned long long PacketUser::Record_Time(){
        timeval tv;
        gettimeofday(&tv,NULL);
        unsigned long long timems =  (unsigned long long)tv.tv_sec * (unsigned long long)1000 + tv.tv_usec / 1000; 
        return timems;  
}

//dbg_functions:

//UNUSED. save a packet in a file
void PacketUser::savePKT_file(char* headerPkt, 
                                                         char* pamPkt, 
                                                         long int length, 
                                                         bool append,
                                                         char* nomefile)
{
        char fno[80]="";
        ofstream fout;
        sprintf(fno,"%s/pkt%d_of_%s.pkt", outDir, numPKTSaved, nomefile);

        if(append==true)
                fout.open(fno, ios::binary | ios::app);
        else
                fout.open(fno, ios::binary);                    
                
        if (!fout) {cout<<"can not open output file "<<fno<<endl; return;}                  
        fout.write(headerPkt,LENGTH_HEADER_PKT);
        fout.write(pamPkt,length);
        fout.close();    
}

//UNUSED
void PacketUser::saveALL_PKT(char* headerPkt, char* pamPkt, long int length, bool append)
{
        char fno[80]="";
        ofstream fout;
        if(append==true)
        {               
                sprintf(fno,"%s/packets.pkt", outDir);
                fout.open(fno, ios::binary | ios::app);
        }
        else{
                sprintf(fno,"%s/packet%d.pkt", outDir, numPKT );
                fout.open(fno, ios::binary);                    
        }
                
        if (!fout) {cout<<"can not open output file "<<fno<<endl; return;}                  
        fout.write(headerPkt,LENGTH_HEADER_PKT);
        fout.write(pamPkt,length);
        fout.close();    
}


}