/**
* \brief The listJobs function gets a list of all submitted jobs
* \param sessionKey : The session key
* \param listOfJobs : The constructed object list of jobs
* \param options : Additional options for jobs listing
* \return int : an error code
*/
int
vishnu::listJobs(const std::string& sessionKey,
TMS_Data::ListJobs& listOfJobs,
const TMS_Data::ListJobsOptions& options)
throw (UMSVishnuException, TMSVishnuException, UserException, SystemException) {
checkEmptyString(sessionKey, "The session key");
UMS_Data::Machine_ptr machine = new UMS_Data::Machine();
const std::string machineId = ALL_KEYWORD;
// Here the list of machine should contain only a single machine
machine->setMachineId(machineId);
listOfJobs.setNbJobs(0);
listOfJobs.setNbRunningJobs(0);
listOfJobs.setNbWaitingJobs(0);
std::string serviceName = (boost::format("%1%") % SERVICES_TMS[GETLISTOFJOBS_ALL]).str();
SessionProxy sessionProxy(sessionKey);
checkJobStatus(options.getStatus()); // check the job status options
checkJobPriority(options.getPriority()); //check the job priority options
QueryProxy<TMS_Data::ListJobsOptions, TMS_Data::ListJobs>
query(options, sessionProxy, serviceName, machine->getMachineId());
TMS_Data::ListJobs* listJobs_ptr = NULL;
try {
listJobs_ptr = query.list();
} catch(...) {
throw ;
}
if (listJobs_ptr != NULL) {
TMS_Data::TMS_DataFactory_ptr ecoreFactory = TMS_Data::TMS_DataFactory::_instance();
for (unsigned int j = 0; j < listJobs_ptr->getJobs().size(); j++) {
TMS_Data::Job_ptr job = ecoreFactory->createJob();
//copy the content and not the pointer
*job = *listJobs_ptr->getJobs().get(j);
listOfJobs.getJobs().push_back(job);
}
listOfJobs.setNbJobs(listOfJobs.getNbJobs()+listJobs_ptr->getJobs().size());
listOfJobs.setNbRunningJobs(listOfJobs.getNbRunningJobs()+listJobs_ptr->getNbRunningJobs());
listOfJobs.setNbWaitingJobs(listOfJobs.getNbWaitingJobs()+listJobs_ptr->getNbWaitingJobs());
delete listJobs_ptr;
}
return 0;
}
int
main (int argc, char* argv[]) {
/******* Parsed value containers ****************/
std::string configFile;
std::string sessionKey;
std::string stateStr = "";
int state;
std::string fromDate;
std::string toDate;
int retCode = 0;
/********** EMF data ************/
TMS_Data::ListJobsOptions jobOp;
/******** Callback functions ******************/
boost::function1<void,string> setMachineIdFct(boost::bind(&TMS_Data::ListJobsOptions::setMachineId,boost::ref(jobOp),_1));
boost::function1<void,string> setJobIdFct(boost::bind(&TMS_Data::ListJobsOptions::setJobId,boost::ref(jobOp),_1));
boost::function1<void,int> setNbCpuFct(boost::bind(&TMS_Data::ListJobsOptions::setNbCpu,boost::ref(jobOp),_1));
boost::function1<void,string> setOwnerFct(boost::bind(&TMS_Data::ListJobsOptions::setOwner,boost::ref(jobOp),_1));
boost::function1<void,TMS_Data::JobPriority> setPriorityFct(boost::bind(&TMS_Data::ListJobsOptions::setPriority,boost::ref(jobOp),_1));
boost::function1<void,string> setQueueFct(boost::bind(&TMS_Data::ListJobsOptions::setQueue,boost::ref(jobOp),_1));
boost::function1<void,string> setMultipleStatusesFct(boost::bind(&TMS_Data::ListJobsOptions::setMultipleStatus,boost::ref(jobOp),_1));
boost::function1<void,long long> setWorkIdFct(boost::bind(&TMS_Data::ListJobsOptions::setWorkId,boost::ref(jobOp),_1));
/*********** Out parameters *********************/
TMS_Data::ListJobs jobs;
/**************** Describe options *************/
boost::shared_ptr<Options> opt = makeListJobOp(argv[0],
setMachineIdFct,
setJobIdFct,
setNbCpuFct,
fromDate,
toDate,
setOwnerFct,
stateStr,
setPriorityFct,
setQueueFct,
setMultipleStatusesFct,
setWorkIdFct,
sessionKey,
configFile);
opt->add("isListAll,l",
"allows to list all information",
CONFIG);
// pre-process options
bool isEmpty;
GenericCli().processListOpt(opt, isEmpty, argc, argv);
// Process command
try {
if (stateStr.size()!=0) {
size_t pos = stateStr.find_first_not_of("0123456789");
if (pos!=std::string::npos) {
if (stateStr.size() == 1) {
switch(stateStr[0]) {
case 'S' :
state = vishnu::STATE_SUBMITTED;
break;
case 'Q' :
state = vishnu::STATE_QUEUED;
break;
case 'W' :
state = vishnu::STATE_WAITING;
break;
case 'R' :
state = vishnu::STATE_RUNNING;
break;
case 'T' :
state = vishnu::STATE_COMPLETED;
break;
case 'C' :
state = vishnu::STATE_CANCELLED;
break;
case 'D' :
state = vishnu::STATE_DOWNLOADED;
break;
case 'F' :
state = vishnu::STATE_FAILED;
break;
default:
state = vishnu::STATE_UNDEFINED;
break;
}
}
if (stateStr.size() > 1 || state < 0) {
std::cerr << (boost::format("Unknown job state: %1%")%stateStr).str();
return CLI_ERROR_INVALID_PARAMETER;
}
} else {
state = convertToInt(stateStr);
}
jobOp.setStatus(state);
}
//convert the date in long format
if (opt->count("fromSubmitDate")) {
jobOp.setFromSubmitDate(string_to_time_t(fromDate));
}
if (opt->count("toSubmitDate")) {
jobOp.setToSubmitDate(string_to_time_t(toDate));
}
if (opt->count("isListAll")) {
jobOp.setListAll(true);
}
if (vishnuInitialize(const_cast<char*>(configFile.c_str()), argc, argv)) {
errorUsage(argv[0],communicationErrorMsg,EXECERROR);
return CLI_ERROR_COMMUNICATION ;
}
// Process list job
// get the sessionKey
if(sessionKey.empty()){
sessionKey=getLastSessionKey(getppid());
}
// vishnu call: submit
if(! sessionKey.empty()){
listJobs(sessionKey, jobs, jobOp);
}
if (jobOp.getJobId().empty()
&& jobOp.getNbCpu() <= 0
&& jobOp.getFromSubmitDate() <= 0
&& jobOp.getToSubmitDate() <= 0
&& !jobOp.isListAll())
{
std::cout << jobs << "\n";
} else {
displayListJobs(jobs);
}
} catch(VishnuException& e) {// catch all Vishnu runtime error
std::string msg = e.getMsg();
if (e.getMsgComp().compare("Bus initialization failure")==0){
msg += " ["+e.getMsgComp()+", machineId may be invalid]";
} else {
msg += " ["+e.getMsgComp()+"]";
}
errorUsage(argv[0], msg,EXECERROR);
//check the bad session key
if (checkBadSessionKeyError(e)) {
removeBadSessionKeyFromFile(getppid());
}
retCode = e.getMsgI();
} catch(std::exception& e) {// catch all std runtime error
errorUsage(argv[0],e.what());
retCode = CLI_ERROR_RUNTIME;
}
return retCode;
}
int main (int argc, char* argv[]){
int ret; // Return value
/******* Parsed value containers ****************/
string dietConfig;
string sessionKey;
string machineId;
string statusStr = "";
int status;
std::string fromDate;
std::string toDate;
/********** EMF data ************/
TMS_Data::ListJobsOptions jobOp;
/******** Callback functions ******************/
boost::function1<void,string> fjid(boost::bind(&TMS_Data::ListJobsOptions::setJobId,boost::ref(jobOp),_1));
boost::function1<void,int> fnbCpu(boost::bind(&TMS_Data::ListJobsOptions::setNbCpu,boost::ref(jobOp),_1));
boost::function1<void,string> fown(boost::bind(&TMS_Data::ListJobsOptions::setOwner,boost::ref(jobOp),_1));
boost::function1<void,JobPriority> fpriority(boost::bind(&TMS_Data::ListJobsOptions::setPriority,boost::ref(jobOp),_1));
boost::function1<void,string> fqueue(boost::bind(&TMS_Data::ListJobsOptions::setQueue,boost::ref(jobOp),_1));
boost::function1<void,string> fmutlStatus(boost::bind(&TMS_Data::ListJobsOptions::setMultipleStatus,boost::ref(jobOp),_1));
boost::function1<void,long long> fworkId(boost::bind(&TMS_Data::ListJobsOptions::setWorkId,boost::ref(jobOp),_1));
/*********** Out parameters *********************/
TMS_Data::ListJobs job;
/**************** Describe options *************/
boost::shared_ptr<Options> opt=makeListJobOp(argv[0],
fjid,
fnbCpu,
fromDate,
toDate,
fown,
statusStr,
fpriority,
fqueue,
fmutlStatus,
fworkId,
dietConfig);
opt->add("isBatchJob,b",
"allows to select all jobs submitted through the underlying"
" batch scheduler (jobs submitted through vishnu and out of vishnu)",
CONFIG);
opt->add("isListAll,l",
"allows to list all information",
CONFIG);
opt->add("machineId,m",
"represents the id of the machine",
HIDDEN,
machineId,1);
opt->setPosition("machineId",1);
CLICmd cmd = CLICmd (argc, argv, opt);
// Process command
try {
// Parse the cli and setting the options found
ret = cmd.parse(env_name_mapper());
if (ret != CLI_SUCCESS){
helpUsage(*opt,"[options] machineId");
return ret;
}
// PreProcess (adapt some parameters if necessary)
checkVishnuConfig(*opt);
if ( opt->count("help")){
helpUsage(*opt,"[options] machineId");
return 0;
}
if(statusStr.size()!=0) {
size_t pos = statusStr.find_first_not_of("0123456789");
if(pos!=std::string::npos) {
if(statusStr.size()==1) {
switch(statusStr[0]) {
case 'S' :
status = 1;
break;
case 'Q' :
status = 2;
break;
case 'W' :
status = 3;
break;
case 'R' :
status = 4;
break;
case 'T' :
status = 5;
break;
case 'C' :
status = 6;
break;
case 'D' :
status = 7;
break;
default:
status = -1;
break;
}
}
if ((statusStr.size() > 1) || (status == -1)) {
std::cerr << "Unknown job status " << statusStr << std::endl;
return 0;
}
} else {
status = convertToInt(statusStr);
}
jobOp.setStatus(status);
}
//convert the date in long format
if(opt->count("fromSubmitDate")){
jobOp.setFromSubmitDate(convertLocaltimeINUTCtime(string_to_time_t(fromDate)));
}
if(opt->count("toSubmitDate")){
jobOp.setToSubmitDate(convertLocaltimeINUTCtime(string_to_time_t(toDate)));
}
if(opt->count("isBatchJob")) {
jobOp.setBatchJob(true);
}
if (opt->count("isListAll")) {
jobOp.setListAll(true);
}
// initializing DIET
if (vishnuInitialize(const_cast<char*>(dietConfig.c_str()), argc, argv)) {
errorUsage(argv[0],dietErrorMsg,EXECERROR);
return CLI_ERROR_DIET ;
}
// get the sessionKey
sessionKey=getLastSessionKey(getppid());
// DIET call : submit
if(false==sessionKey.empty()){
printSessionKeyMessage();
listJobs(sessionKey, machineId, job, jobOp);
}
if(jobOp.getOwner().size()==0 && jobOp.getJobId().size()==0 && jobOp.getNbCpu() <= 0
&& jobOp.getFromSubmitDate() <= 0 && jobOp.getToSubmitDate() <= 0 && !jobOp.isListAll()) {
std::cout << job << std::endl;
} else {
displayListJobs(job);
}
printSuccessMessage();
} catch(VishnuException& e){// catch all Vishnu runtime error
std::string msg = e.getMsg()+" ["+e.getMsgComp()+"]";
errorUsage(argv[0], msg,EXECERROR);
//check the bad session key
if (checkBadSessionKeyError(e)){
removeBadSessionKeyFromFile(getppid());
}
return e.getMsgI() ;
} catch(std::exception& e){// catch all std runtime error
errorUsage(argv[0],e.what());
return CLI_ERROR_RUNTIME;
}
return 0;
}