phoenix_program_call.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <iostream>
 
#include "phoenix_color.h"
#include "phoenix_system.h"
#include "convertToString.h"
#include "phoenix_vector_split.h"
 
#include "lauchParallelThread.h"
#include "PMultiThreadProgress.h"
 
#include "phoenix_program_call.h"
 


void phoenix_program_call(ProgramCall & call){
        PString command(call.getCommand());
        if(call.getWorkingDirectory() != ""){
                command = "cd " + PString(call.getWorkingDirectory()) + ";" + command;
        }
        if(call.getLogFile() != ""){
                PString logContent("");
                call.setExitStatus(phoenix_popen(logContent, command));
                call.getLogFile().saveFileContent(logContent);
        }else{
                std::cout << termCyan() << "Call command '"<<command<<"'" << termDefault() << std::endl;
                call.setExitStatus(system(command.c_str()));
        }
}


void phoenix_program_callVec(VecProgramCall & vecCall){
        for(VecProgramCall::iterator it(vecCall.begin()); it != vecCall.end(); ++it){
                phoenix_program_call(*it);
        }
}


void phoenix_program_callParallel(VecProgramCall & vecCall, size_t nbThread){
        if(vecCall.size() == 0lu){return;}
        lauchParallelThread(vecCall, nbThread, phoenix_program_callVec);
}


void phoenix_program_callVecProgress(PMultiThreadProgress & progress, VecProgramCall & vecCall, size_t threadIndex){
        size_t indexProgressBar = progress.addProgressBar("Progress of thread " + valueToString(threadIndex), vecCall.size());
        for(VecProgramCall::iterator it(vecCall.begin()); it != vecCall.end(); ++it){
                phoenix_program_call(*it);
                progress.incrementProgress(indexProgressBar);          //Update the progress bar
        }
}


void phoenix_program_callParallelProgressBar(VecVecProgramCall & vecVecProgramCall){
        size_t nbThread = vecVecProgramCall.size();     //In case we need less thread than required
        PMultiThreadProgress progress(nbThread);
        std::vector<std::thread> vecThread;
        vecThread.resize(nbThread);
        std::thread threadProgress(phoenix_print_parallel_progress, std::ref(progress), 1);
        for(size_t i(0lu); i < nbThread; ++i){
                vecThread[i] = std::thread(phoenix_program_callVecProgress, std::ref(progress), std::ref(vecVecProgramCall[i]), i);
        }
        threadProgress.join();
        for(size_t i(0lu); i < nbThread; ++i){
                vecThread[i].join();
        }
        size_t nbSuccess(phoenix_program_getNbSuccessCall(vecVecProgramCall));
        size_t nbFail(phoenix_program_getNbCall(vecVecProgramCall) - nbSuccess);
        std::cout << "VecProgramCall : summary : " << nbSuccess << " success, " << nbFail << " fail" << std::endl;
}


void phoenix_program_callParallelProgressBar(VecProgramCall & vecCall, size_t nbThread){
        if(vecCall.size() == 0lu){return;}
        VecVecProgramCall vecVecProgramCall;
        phoenix_vector_split(vecVecProgramCall, vecCall, nbThread);
        phoenix_program_callParallelProgressBar(vecVecProgramCall);
}


void phoenix_program_addcall(VecProgramCall & vecCall, const PString & name, const PString & command,
                        const PPath & workingDirectory, const PPath & logFile)
{
        ProgramCall call;
        call.setName(name);
        call.setCommand(command);
        call.setWorkingDirectory(workingDirectory);
        call.setLogFile(logFile);
        call.setExitStatus(0);
        vecCall.push_back(call);
}


size_t phoenix_program_getNbCallExitStatusType(const VecProgramCall & vecCall, int result){
        size_t nbSuccessCall(0lu);
        for(VecProgramCall::const_iterator it(vecCall.begin()); it != vecCall.end(); ++it){
                nbSuccessCall += it->getExitStatus() == result;
        }
        return nbSuccessCall;
}


size_t phoenix_program_getNbCallExitStatusType(const VecVecProgramCall & vecCall, int result){
        size_t nbSuccessCall(0lu);
        for(VecVecProgramCall::const_iterator it(vecCall.begin()); it != vecCall.end(); ++it){
                nbSuccessCall += phoenix_program_getNbCallExitStatusType(*it, result);
        }
        return nbSuccessCall;
}


size_t phoenix_program_getNbSuccessCall(const VecProgramCall & vecCall){
        return phoenix_program_getNbCallExitStatusType(vecCall, 0);
}


size_t phoenix_program_getNbSuccessCall(const VecVecProgramCall & vecCall){
        return phoenix_program_getNbCallExitStatusType(vecCall, 0);
}


size_t phoenix_program_getNbCall(const VecVecProgramCall & vecCall){
        size_t nbCall(0lu);
        for(VecVecProgramCall::const_iterator it(vecCall.begin()); it != vecCall.end(); ++it){
                nbCall += it->size();
        }
        return nbCall;
}