adf/Macros/Deprecated/Utilities.C

Go to the documentation of this file.

#include <iostream>
#include <fstream>
#include <string>

#include "TSystem.h"
#include "TRegexp.h"
#include "TList.h"
#include "TSystemDirectory.h"
#include "TNamed.h"
#include "TDirectory.h"
#include "TString.h"
#include "TSocket.h"


void MakeRootAFPConfFile( const char * directory, const char * pat = "*.adf", Option_t * opt ="" );

void GetListOfBadDirFromOption( TList *, std::string );
void GetListOfBadDirPatternFromOption( TList *, std::string );
void GetListOfBadFilePatternFromOption( TList *, std::string );
bool IsAGoodDir( TList * listBadDir, TList * listBadPattern, const char * );
bool IsAGoodFile( TList * listOfBadPattern, const char * );

const char * currentdir = "zCurrentNarvalDataDir";

void MakeRootAFPConfFile( const char * directory, const char * pat, Option_t * opt )
{
    TString soption = opt;
    TList * listofBaddir = new TList;
    TList * listofBadPatternf = new TList;
    TList * listofBadPatternd = new TList;
    std::string ssoption = soption.Data();
        
    GetListOfBadDirFromOption(listofBaddir, ssoption );
    GetListOfBadDirPatternFromOption( listofBadPatternd, ssoption );
    GetListOfBadFilePatternFromOption( listofBadPatternf, ssoption );
        
    TString presentDir = gSystem->pwd();
    TList * listofsubdir = new TList;
    TList * listofFile = new TList;
    TList * listOfGoodFile = new TList;
    TString patname = pat;
    
    // pattern expression
    Bool_t wildcard = false;
    if ( patname.Contains("*") )
        wildcard = true;    
    TRegexp all("*",kTRUE), pattern(patname.Data(),wildcard);
    
    if ( pattern.Status() != TRegexp::kOK )
    {
        if ( gDebug > 0 )
            std::cerr << "pattern [*] intead of " << patname << std::endl;
        pattern = all;
    }
    else
    {
        if ( gDebug > 0 ) std::cerr << "pattern " << patname << std::endl ;
    }
    TSystemDirectory dir;
    dir.SetDirectory(directory);
    TList *list = dir.GetListOfFiles();
    TIter iter(list);
    TObject *entry;
        
    while ( (entry = iter()) )
    {
        if ( entry->InheritsFrom("TSystemDirectory") &&
                        strncmp(entry->GetName(),".",1) &&
                        strcmp(entry->GetName(),currentdir) &&
                        IsAGoodDir( listofBaddir, listofBadPatternd, entry->GetName()) )
        {
            TString pathname = gSystem->pwd();
            pathname += "/";
            pathname += entry->GetName();
            listofsubdir->Add(new TNamed(entry->GetName(),pathname.Data()));
        }
        else if ( entry->InheritsFrom("TSystemFile") &&
                                 strncmp(entry->GetName(),".",1) &&
                                 IsAGoodFile( listofBadPatternf, entry->GetName() ) )
        {
            TString pathname = gSystem->pwd();
            listofFile->Add(new TNamed(entry->GetName(),pathname.Data()));
        }
    }
        
        
    if ( soption.Contains("r") )
    {
        while ( listofsubdir->GetSize() != 0 )
        {
            dir.SetDirectory(listofsubdir->At(0)->GetTitle());
            list = dir.GetListOfFiles();
            TIter iter2(list);
            while ( (entry = iter2()) )
            {
                if ( entry->InheritsFrom("TSystemDirectory") &&
                                        strncmp(entry->GetName(),".",1) &&
                                        strcmp(entry->GetName(),currentdir) &&
                                        IsAGoodDir( listofBaddir, listofBadPatternd, entry->GetName()) )
                {
                    TString pathname = gSystem->pwd();
                    pathname += "/";
                    pathname += entry->GetName();
                    listofsubdir->Add(new TNamed(entry->GetName(),pathname.Data()));
                }
                else if ( entry->InheritsFrom("TSystemFile") &&
                                                 strncmp(entry->GetName(),".",1) &&
                                                 IsAGoodFile( listofBadPatternf, entry->GetName()) )
                {
                    TString pathname = gSystem->pwd();
                    listofFile->Add(new TNamed(entry->GetName(),pathname.Data()));
                }
            }
            TNamed * tmp;
            tmp = (TNamed*)listofsubdir->At(0);
            listofsubdir->Remove( listofsubdir->At(0) );
            delete tmp;
        }
    }
        
    for ( Int_t i = 0; i < listofFile->GetSize(); i++ )
    {
        TString testname = listofFile->At(i)->GetName();
        if ( testname.Contains(pattern) )
            listOfGoodFile->Add( listofFile->At(i) );
    }
        
    std::clog << listOfGoodFile->GetSize() << " file was found " << std::endl;
        
    gSystem->cd(presentDir);
        
    std::ofstream outputfile("./RootAFP.conf");
    std::clog << "file is created : " << presentDir << "/RootAFP.conf" << std::endl;
    for ( Int_t i = 0; i < listOfGoodFile->GetSize(); i++ )
    {
        outputfile << "l "      << listOfGoodFile->At(i)->GetTitle() << "/"
                                                        << listOfGoodFile->At(i)->GetName() << std::endl;
    }
    outputfile.close();
        
    listOfGoodFile->Clear();
    listofFile->Clear();
    list->Clear();
}

void GetListOfBadDirFromOption( TList * l, std::string s )
{
    for ( size_t i = 2; i < s.size(); i++ )
    {
        if ( s[i-2] == '-' && s[i-1] == 'd' && s[i] == '=' )
        {
            std::string newtmp;
            newtmp.clear();
            for ( size_t j = i+1; j < s.size() && s[j]!='-';j++ )
                newtmp.push_back(s[j]);
            l->Add(new TNamed(newtmp.c_str(),newtmp.c_str()));
        }
                
    }
}
void GetListOfBadDirPatternFromOption( TList * l, std::string s)
{
    for ( size_t i = 3; i < s.size(); i++ )
    {
        if ( s[i-3] == '-' && s[i-2] == 'p' && s[i-1] == 'd' && s[i] == '=' )
        {
            std::string newtmp;
            newtmp.clear();
            for ( size_t j = i+1; j < s.size() && s[j]!='-';j++ )
                newtmp.push_back(s[j]);
            l->Add(new TNamed(newtmp.c_str(),newtmp.c_str()));
        }
                
    }
}
void GetListOfBadFilePatternFromOption( TList * l, std::string s)
{
    for ( size_t i = 3; i < s.size(); i++ )
    {
        if ( s[i-3] == '-' && s[i-2] == 'p' && s[i-1] == 'f' && s[i] == '=' )
        {
            std::string newtmp;
            newtmp.clear();
            for ( size_t j = i+1; j < s.size() && s[j]!='-';j++ )
                newtmp.push_back(s[j]);
            l->Add(new TNamed(newtmp.c_str(),newtmp.c_str()));
        }
                
    }
}
bool IsAGoodDir( TList * listBadDir, TList * listBadPattern, const char * name )
{
    for ( Int_t i = 0; i < listBadDir->GetSize(); i++ )
        if ( !strcmp( name, listBadDir->At(i)->GetName()) ) return( false );
    TString sname = name;
    for ( Int_t i = 0; i < listBadPattern->GetSize(); i++ )
    {
        TString tmp(listBadPattern->At(i)->GetName());
        Bool_t wildcard = false;
        if ( tmp.Contains("*") )
            wildcard = true;
        TRegexp pattern(listBadPattern->At(i)->GetName(),wildcard);
        if ( sname.Contains(pattern) )
            return( false );
    }
    return( true );
}
bool IsAGoodFile( TList * listOfBadPattern, const char * name )
{
    TString sname = name;
    for ( Int_t i = 0; i < listOfBadPattern->GetSize(); i++ )
    {
        TString tmp(listBadPattern->At(i)->GetName());
        Bool_t wildcard = false;
        if ( tmp.Contains("*") )
            wildcard = true;
        TRegexp pattern(listOfBadPattern->At(i)->GetName(),wildcard);
        if ( sname.Contains(pattern) )
            return( false );
    }
    return( true );
}


namespace  { TList PingNames; char buffer[4*1024*1024]; }

/*
*/
void LoadPing( const char * filename, Option_t * opt = "+" )
{
        TString option = opt;
        std::ifstream inputfile(filename);
        TList listName_tmp;
        std::string machineName;
        std::string portName;
        bool test_is;
        TNamed * tmp_name = NULL;
        while(1){
                machineName.clear();
                portName.clear();
                inputfile >> machineName >> portName;
                if( inputfile.eof() ) break;
                std::cerr << machineName << " " << portName << std::endl;
                listName_tmp.Add(new TNamed( machineName.c_str(),
                                                                        portName.c_str() ) );
                
        };
        std::cerr << listName_tmp.GetSize() << std::endl;
        if( PingNames.GetSize() == 0 && option.Contains("+") ){
                for( Int_t i = 0; i < listName_tmp.GetSize(); i++)
                        PingNames.Add( listName_tmp.At(i) );
                listName_tmp.Clear("nodelete");
        }
        else if( option.Contains("+") ){
                for( Int_t i = 0; i<listName_tmp.GetSize(); i++){
                        test_is = false;
                        for( Int_t j = 0; j<PingNames.GetSize(); j++){
                                if(std::string(PingNames.At(j)->GetName()) == 
                                   std::string(listName_tmp.At(i)->GetName()) &&
                                   std::string(PingNames.At(j)->GetTitle()) == 
                                   std::string(listName_tmp.At(i)->GetTitle()) ) test_is = true;
                        }
                        if( test_is == false ) PingNames.Add(listName_tmp.At(i));
                }
                listName_tmp.Clear("nodelete");
        }
        
        if( option.Contains("-") ){
                for( Int_t i = 0; i<listName_tmp.GetSize(); i++ ){
                        test_is = false;
                        for( Int_t j = 0; j<PingNames.GetSize(); j++){
                                if(std::string(PingNames.At(j)->GetName()) == 
                                   std::string(listName_tmp.At(i)->GetName()) &&
                                   std::string(PingNames.At(j)->GetTitle()) == 
                                   std::string(listName_tmp.At(i)->GetTitle()) ){
                                        test_is = true;
                                        tmp_name = (TNamed*)PingNames.At(j);
                                }
                        }
                        if( test_is == true ){
                                PingNames.Remove(tmp_name);
                                delete tmp_name;
                        }
                }
                listName_tmp.Clear("delete");
        }
        
        PingNames.Print();
        for( Int_t ii = 0; ii < PingNames.GetSize(); ii++ ){
                std::cerr << PingNames.At(ii)->GetName() << " " << PingNames.At(ii)->GetTitle() << std::endl;}
}

/*
 */
void Ping( UInt_t nbtimes = 5, bool dodump = false)
{
        TIter next(&PingNames);
        TObject * obj;
        while ( (obj = next()) ) {
                
                TString option = obj->GetTitle(), ifdump;               
                cout << "Ping on : " << obj->GetName() << " with Port # " << obj->GetTitle() << endl;
                
                TSocket *fSocket = new TSocket(obj->GetName(),option.Atoi());
                if ( fSocket ) {
                        if ( fSocket->IsValid() ) {
                                Int_t bsize, ret; 
                                cout << "Select with 1 millisecond " << endl;
                                for (UInt_t i = 0u; i < nbtimes; i++) {
                                        cout << " - try # " << i << endl;
                                        ifdump = Form("%s_%s_%d",obj->GetName(),obj->GetTitle(),i);

                                        switch ( fSocket->Select(TSocket::kRead,1000) ) 
                                        {
                                                case 0:
                                                        cout << "--> timeout " << endl;
                                                        break;
                                                case -1:
                                                        cout << "--> Error " << endl;
                                                        break;
                                                default:
                                                        fSocket->RecvRaw(&bsize, sizeof(Int_t));
                                                        cout << " Size expected " << bsize << endl;
                                                        ret = fSocket->RecvRaw(buffer, bsize);
                                                        cout << " Size received " <<  ret << endl;
                                                        if ( dodump ) {
                                                                ofstream file(ifdump.Data(),ios_base::app);
                                                                file << bsize;
                                                                file.write(buffer,bsize);
                                                        }
                                                        break;
                                        }
                                }
                        }
                        else cout << "  *** Invalid connection *** " << endl;
                }
                else cout << "  *** Invalid connection *** " << endl;
                delete fSocket;
        }
}

void Ping(const char *machine, UInt_t port, UInt_t nbtimes = 5, Option_t *opt = "")
{
        TString option = opt, sport = Form("%d",port);
        bool test_is;
        TNamed * tmp_name = NULL;
        // add or removed from the list
        if ( option.Contains("+") ) {
                test_is = false;
                for( Int_t i = 0; i < PingNames.GetSize(); i++ )
                        if( std::string(PingNames.At(i)->GetName()) == std::string(machine) &&
                            std::string(PingNames.At(i)->GetTitle()) == std::string(sport) ) test_is = true;
                if( test_is == false )
                        PingNames.Add ( new TNamed(machine,sport.Data()) );
        }
        if ( option.Contains("-") ){
                test_is = false;
                for( Int_t i = 0; i < PingNames.GetSize(); i++ )
                        if( std::string(PingNames.At(i)->GetName()) == std::string(machine) &&
                           std::string(PingNames.At(i)->GetTitle()) == std::string(sport) ) {
                                test_is = true;
                                tmp_name = (TNamed*)PingNames.At(i);
                        }
                if ( test_is == true ) { 
                        PingNames.Remove(tmp_name);
                        delete tmp_name;
                }
        }
        
        Ping(nbtimes);
}

/*
 */
void SSHPing( UInt_t nbtimes = 1, bool dodump = false)
{
//      TIter next(&PingNames);
//      TObject * obj;
//      while ( (obj = next()) ) {
                
        TNamed *obj = new TNamed("localhost","10001");

                TString option = obj->GetTitle(), ifdump;               
                cout << "Ping on : " << obj->GetName() << " with Port # " << obj->GetTitle() << endl;
                
        
                TSocket *fSocket = new TSocket(obj->GetName(),option.Atoi());
                if ( fSocket ) {
                        if ( fSocket->IsValid() ) {
                                Int_t bsize, ret; 
                                cout << "Select with 1 millisecond " << endl;
                                for (UInt_t i = 0u; i < nbtimes; i++) {
                                        cout << " - try # " << i << endl;
                                        ifdump = Form("%s_%s_%d",obj->GetName(),obj->GetTitle(),i);
                                        
                                        switch ( fSocket->Select(TSocket::kRead,1000) ) 
                                        {
                                                case 0:
                                                        cout << "--> timeout " << endl;
                                                        break;
                                                case -1:
                                                        cout << "--> Error " << endl;
                                                        break;
                                                default:
                                                        fSocket->RecvRaw(&bsize, sizeof(Int_t));
                                                        cout << " Size expected " << bsize << endl;
                                                        ret = fSocket->RecvRaw(buffer, bsize);
                                                        cout << " Size received " <<  ret << endl;
                                                        if ( dodump ) {
                                                                ofstream file(ifdump.Data(),ios_base::app);
                                                                file << bsize;
                                                                file.write(buffer,bsize);
                                                        }
                                                        break;
                                        }
                                }
                        }
                        else cout << "  *** Invalid connection *** " << endl;
                }
                else cout << "  *** Invalid connection *** " << endl;
                delete fSocket;
        
        delete obj;
//      }
}



void CleanWatchers()
{
        gSystem->Exec("rm -rf DefaultWatchers/*_C.so DefaultWatchers/*_C.d DefaultWatchers/*.o ./*_C.so ./*_C.d ./*.o");
        gSystem->Exec("rm -rf MyWatchers/*_C.so MyWatchers/*_C.d MyWatchers/*.o ./*_C.so ./*_C.d ./*.o");
        
}