int LSFParser::convertWallTimeToTime(const std::string& date, const std::string& compErrMsg) { int wallTime; int minute = -1; std::string errMsg = "illegal time option value "+date+":"; std::vector<std::string> tokens = getTimeToKens(date); if (tokens.empty()) { errMsg += " Empty time value. At least one fields must be specified."; throw UMSVishnuException(ERRCODE_INVALID_PARAM, errMsg+" "+compErrMsg); } for(std::vector<std::string>::iterator iter = tokens.begin(); iter!=tokens.end(); ++iter) { if (!isNumerical(*iter)) { errMsg += " The fields values must be intergers."; throw UMSVishnuException(ERRCODE_INVALID_PARAM, errMsg+" "+compErrMsg); } } //hour minute = vishnu::convertToInt(tokens[0]); wallTime = minute; //day if (tokens.size() >= 2) { int hour = vishnu::convertToInt(tokens[1]); wallTime += hour*60; } return wallTime; }
void verifyQuotaCharacter(const std::string& str, const char& quote) { std::string quoteStr; quoteStr.push_back(quote); std::string errorMsg = "Error: invalid value option in option "+str; errorMsg +=". A text started by the quote character "+quoteStr+" must be closed by the quote character "+quoteStr; //First character quote size_t pos = str.find(quote); if (pos!=std::string::npos) { //Second character quote pos = str.find(quote, pos+1); if (pos==std::string::npos) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errorMsg); } //First character quote pos = str.find(quote, pos+1); while(pos!=std::string::npos) { if (pos!=std::string::npos) { //Second character quote pos = str.find(quote, pos+1); if (pos==std::string::npos) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errorMsg); } } //First character quote pos = str.find(quote, pos+1); } } }
/** * \brief Function to treat the listSessionServer options * \param userServer the object which encapsulates user information * \param options the object which contains the ListSessionServer options values * \param sqlRequest the sql data base request * \return raises an exception on error */ void processOptions(UserServer userServer, const UMS_Data::ListSessionOptions_ptr& options, std::string& query) { boost::posix_time::ptime pt; bool listAll = options->isAdminListOption(); if (! userServer.isAdmin() && (! options->getUserId().empty() || listAll)) { throw UMSVishnuException (ERRCODE_NO_ADMIN); } if(! options->getMachineId().empty()) { addOptionRequest("clmachine.name", options->getMachineId(), query); } if(! options->getUserId().empty()) { addOptionRequest("users.userid", options->getUserId(), query); } else { if (! listAll) { addOptionRequest("users.userid", userServer.getData().getUserId(), query); } } int status = options->getStatus(); if (status == vishnu::STATUS_UNDEFINED) { status = vishnu::STATUS_ACTIVE; } addIntegerOptionRequest("state", status, query); if (options->getSessionClosePolicy()) { addIntegerOptionRequest("closepolicy", options->getSessionClosePolicy(), query); } if (options->getSessionInactivityDelay() < 0) { throw UMSVishnuException(ERRCODE_INCORRECT_TIMEOUT); } if (options->getSessionInactivityDelay()) { addIntegerOptionRequest("timeout", options->getSessionInactivityDelay(), query); } if (! options->getSessionId().empty()) { addOptionRequest("vsessionid", options->getSessionId(), query); } time_t startDate = static_cast<time_t>(options->getStartDateOption()); if (startDate > 0) { addTimeRequest("creation", vishnu::timeToTimestamp(startDate), query, ">="); } time_t endDate = static_cast<time_t>(options->getEndDateOption()); if (endDate > 0) { addTimeRequest("closure", vishnu::timeToTimestamp(endDate), query, "<="); } }
/** * \brief Function to update a VISHNU machine * \return raises an exception on error */ int MachineServer::update() { std::string sqlCommand = ""; UserServer userServer = UserServer(msessionServer); userServer.init(); //if the user exists if (! userServer.exist()) { throw UMSVishnuException (ERRCODE_UNKNOWN_USER); } if (! userServer.isAdmin()) { throw UMSVishnuException (ERRCODE_NO_ADMIN); } //if the machine to update exists std::string numMachineId = getEntryAttribute(mmachine->getMachineId(), "nummachineid"); if (numMachineId.empty()) { throw UMSVishnuException (ERRCODE_UNKNOWN_MACHINE); } if (! mmachine->getAddress().empty()) { std::string query = boost::str(boost::format("UPDATE machine SET address='%1%'" " WHERE nummachineid='%2%';") % mdatabase->escapeData(mmachine->getAddress()) % numMachineId); sqlCommand.append(query); } if (mmachine->getStatus() != vishnu::STATUS_UNDEFINED) { std::string query = boost::str( boost::format("UPDATE machine SET status='%1%'" " WHERE nummachineid='%2%';") % mmachine->getStatus() % numMachineId); sqlCommand.append(query); } if (! mmachine->getDescription().empty()) { std::string query = boost::str( boost::format("UPDATE machine SET description='%1%'" " WHERE machine_nummachineid='%2%';") % mdatabase->escapeData(mmachine->getDescription()) % numMachineId); sqlCommand.append(query); } if (! sqlCommand.empty()) { mdatabase->process(sqlCommand); } return 0; }
/** * \brief Function to check the machineId * \return raises an exception */ void MachineServer::checkMachine() { std::string result = getEntryAttribute(mmachine->getMachineId(), "status"); if (result.empty()) { throw UMSVishnuException(ERRCODE_UNKNOWN_MACHINE, boost::str(boost::format("No machine with this id (%1%)") % mmachine->getMachineId())); } if (vishnu::convertToInt(result) == vishnu::STATUS_LOCKED) { throw UMSVishnuException(ERRCODE_MACHINE_LOCKED); } }
/** * \brief The getCompletedJobsOutput() function gets standard output and error output files * of completed jobs (applies only once for each job) * \param sessionKey : The session key * \param machineId : The id of the machine * \param listOfResults : Is the list of jobs results * \param outDir : The output directory where the files will be stored (default is current directory) * \return int : an error code */ int vishnu::getCompletedJobsOutput(const std::string& sessionKey, const std::string& machineId, ListJobResults& listOfResults, const std::string& outDir) throw (UMSVishnuException, TMSVishnuException, UserException, SystemException) { checkEmptyString(sessionKey, "The session key"); checkEmptyString(machineId, "The machine id"); if((outDir.size()!=0)&&(!boost::filesystem::exists(outDir))) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, "The directory "+outDir+" does not exist"); } SessionProxy sessionProxy(sessionKey); JobOutputProxy jobOutputProxy(sessionProxy, machineId, outDir); TMS_Data::ListJobResults_ptr listJobResults_ptr = jobOutputProxy.getCompletedJobsOutput(); if(listJobResults_ptr != NULL) { TMS_Data::TMS_DataFactory_ptr ecoreFactory = TMS_Data::TMS_DataFactory::_instance(); for(unsigned int i = 0; i < listJobResults_ptr->getResults().size(); i++) { TMS_Data::JobResult_ptr jobResult = ecoreFactory->createJobResult(); //To copy the content and not the pointer *jobResult = *listJobResults_ptr->getResults().get(i); listOfResults.getResults().push_back(jobResult); } listOfResults.setNbJobs(listJobResults_ptr->getNbJobs()); delete listJobResults_ptr; } return 0; }
/** * \brief The getJobOutput function gets outputPath and errorPath of a job from its id * \param sessionKey : The session key * \param jobId : The Id of the job * \param outputInfo : The Job object containing the job output information (e.g: outputPath and errorPath) of the job to submit * \param options : Object containing the user-provided options (e.g: it contains a possible output directory set by the user) * \return 0 on success, or raises exception on error */ int vishnu::getJobOutput(const std::string& sessionKey, const std::string& jobId, TMS_Data::JobResult& outputInfo, const TMS_Data::JobOutputOptions& options) throw (UMSVishnuException, TMSVishnuException, UserException, SystemException) { checkEmptyString(sessionKey, "The session key"); std::string outputDir = options.getOutputDir(); if (! outputDir.empty() && ! boost::filesystem::exists(outputDir)) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, "The output directory does not exist: "+ outputDir); } // If no machine id provided, find where the job has been submitted std::string machineId = options.getMachineId(); if (machineId.empty()) { TMS_Data::Job jobInfo; getJobInfo(sessionKey, jobId, machineId, jobInfo); machineId = jobInfo.getMachine(); } // Now process the request SessionProxy sessionProxy(sessionKey); JobOutputProxy jobOutputProxy(sessionProxy, machineId); outputInfo = jobOutputProxy.getJobOutPut(jobId, options); return 0; }
/** * \brief Function to get a certain user account property * \param machineId The machine identifier of machine on which the user have a account * \param property The property name * \return the user account login */ std::string UserServer::getUserAccountProperty(const std::string& machineId, const std::string& property) { init(); std::string userId = getData().getUserId(); UMS_Data::LocalAccount_ptr account = new UMS_Data::LocalAccount(); account->setMachineId(machineId); account->setUserId(userId); LocalAccountServer localAccount(account, *msessionServer); UMS_Data::Machine_ptr machine = new UMS_Data::Machine(); machine->setMachineId(machineId); MachineServer machineServer(machine); //To get the database number id of the machine std::string numMachine = machineServer.getAttribut("where machineid='"+localAccount.getData()->getMachineId()+"'"); //To get the database number id of the user std::string numUser = getAttribut("where userid='"+localAccount.getData()->getUserId()+"'"); std::string value; if ((numMachine.size() > 0) && (numUser.size() > 0)) { value = localAccount.getAttribut("where machine_nummachineid="+numMachine+" and users_numuserid="+numUser, property); } if(value.size()==0) { delete account; delete machine; throw UMSVishnuException(ERRCODE_UNKNOWN_LOCAL_ACCOUNT, "You have not a local account on this machine"); } delete account; delete machine; return value; }
/** * \brief Function to change user password * \param oldPassword the old password of the user * \param newPassword the new password of the user * \return raises an exception on error */ int UserProxy::changePassword(const std::string& password, const std::string& newPassword) { std::string errorInfo; std::string msg = "call of function diet_string_set is rejected "; std::string versionToString; UMS_Data::Version_ptr versionObj = vishnu::parseVersion(VISHNU_VERSION); if (versionObj == NULL) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, "The format of the VISHNU VERSION is incorrect"); } else { // SERIALIZE DATA MODEL ::ecorecpp::serializer::serializer _ser; //To serialize the version object in to versionToString versionToString = _ser.serialize_str(versionObj); } diet_profile_t* profile = diet_profile_alloc(SERVICES_UMS[USERPASSWORDCHANGE], 4); diet_string_set(profile,0, muser.getUserId()); diet_string_set(profile,1, password); diet_string_set(profile,2, newPassword); diet_string_set(profile,3, versionToString); if (diet_call(profile)) { raiseCommunicationMsgException("RPC call failed"); } raiseExceptionOnErrorResult(profile); diet_profile_free(profile); delete versionObj; return 0; }
/** * \brief Function to treat the ListUsersServer options * \param userServer the object which encapsulates user information * \param options The object which encapsulates the information of ListUsersServer options * \param sqlRequest the sql data base request * \return raises an exception on error */ void processOptions(UserServer userServer, const UMS_Data::ListUsersOptions_ptr& options, std::string& sqlRequest) { if(! userServer.isAdmin()) { throw UMSVishnuException (ERRCODE_NO_ADMIN); } std::string userId = options->getUserId(); if(userId.size()!=0) { //To check if the user id is correct checkUserId(options->getUserId()); addOptionRequest("userid", userId, sqlRequest); } std::string authSystemId = options->getAuthSystemId(); if(authSystemId.size()!=0) { //To check if the authSystem identifier is correct checkAuthSystemId(authSystemId); //addOptionRequest("authsystemid", authSystemId, sqlRequest); std::string luserCmd = boost::str(boost::format("SELECT userid " " FROM authsystem, users, authaccount " " WHERE authaccount.authsystem_authsystemid=authsystem.numauthsystemid" " AND authaccount.users_numuserid=users.numuserid" " AND authsystemid='%1%'" " AND authsystem.status!=%2%" " AND users.status!=%2%" " AND authaccount.status!=%2%" ) % mdatabaseInstance->escapeData(authSystemId) % vishnu::STATUS_DELETED); sqlRequest.append(" AND userid IN ("+mdatabaseInstance->escapeData(luserCmd)+")"); } }
/** * \brief Function to change user password * \fn int changePassword(const std::string& password, const std::string& newPassword) * \param oldPassword the old password of the user * \param newPassword the new password of the user * \return raises an exception on error */ int UserProxy::changePassword(const std::string& password, const std::string& newPassword) { diet_profile_t* profile = NULL; char* errorInfo; std::string msg = "call of function diet_string_set is rejected "; std::string versionToString; UMS_Data::Version_ptr versionObj = vishnu::parseVersion(VISHNU_VERSION); if (versionObj == NULL) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, "The format of the VISHNU VERSION is incorrect"); } else { // SERIALIZE DATA MODEL ::ecorecpp::serializer::serializer _ser; //To serialize the version object in to versionToString versionToString = _ser.serialize_str(versionObj); } profile = diet_profile_alloc("userPasswordChange", 3, 3, 4); //IN Parameters if(diet_string_set(diet_parameter(profile,0), strdup((muser.getUserId()).c_str()), DIET_VOLATILE)) { msg += "with sessionKey parameter "+msessionProxy->getSessionKey(); raiseDietMsgException(msg); } if(diet_string_set(diet_parameter(profile,1), strdup(password.c_str()), DIET_VOLATILE)) { msg += "with password parameter "+password; raiseDietMsgException(msg); } if(diet_string_set(diet_parameter(profile,2), strdup(newPassword.c_str()), DIET_VOLATILE)) { msg += "with newPassword parameter "+newPassword; raiseDietMsgException(msg); } if(diet_string_set(diet_parameter(profile,3), strdup(versionToString.c_str()), DIET_VOLATILE)) { msg += "with version parameter "+versionToString; raiseDietMsgException(msg); } //OUT Parameters diet_string_set(diet_parameter(profile,4), NULL, DIET_VOLATILE); if(!diet_call(profile)) { if(diet_string_get(diet_parameter(profile,4), &errorInfo, NULL)){ msg += "by receiving errorInfo message"; raiseDietMsgException(msg); } } else { raiseDietMsgException("DIET call failure"); } /*To raise a vishnu exception if the receiving message is not empty*/ raiseExceptionIfNotEmptyMsg(errorInfo); diet_profile_free(profile); delete versionObj; return 0; }
/** * \brief Function to treat the ListLocalAccountsServer options * \param userServer the object which encapsulates user information * \param options the object which contains the ListLocalAccountsServer options * \param sqlRequest the sql data base request * \return raises an exception on error */ void processOptions(UserServer userServer, const UMS_Data::ListLocalAccOptions_ptr& options, std::string& sqlRequest) { if (! userServer.isAdmin() && (! options->getUserId().empty() || options->isAdminListOption())) { throw UMSVishnuException(ERRCODE_NO_ADMIN); } if(! options->isAdminListOption()) { addOptionRequest("userid", userServer.getData().getUserId(), sqlRequest); } //The admin option if (! options->getUserId().empty()) { addOptionRequest("users.userid", options->getUserId(), sqlRequest); } if (! options->getMachineId().empty()) { addOptionRequest("machine.machineid", options->getMachineId(), sqlRequest); if (! options->isAdminListOption() && options->getUserId().empty()) { addOptionRequest("users.userid", userServer.getData().getUserId(), sqlRequest); } } }
/** * @brief checkPrivilege: Check if a privilege is valid * @param privilege : the privilege value */ void checkPrivilege(int privilege) { if (privilege != vishnu::PRIVILEGE_USER && privilege != vishnu::PRIVILEGE_ADMIN) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, "Invalid Privilege value: valid options are 0 or 1"); } }
/** * @brief Function to check the vaidity of a component status * @param state The value * \return raises an exception on error */ void checkEntityStatus(int state) { if (state != vishnu::STATUS_LOCKED && state != vishnu::STATUS_ACTIVE) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, "Invalid state: valid options are 0 or 1"); } }
/** * \brief Function to check if a text is empty * \param text The text to check * \param comMsg The complementary message to print * \param exceptionType The type of exception to raise * \return raises an exception on error */ void checkIfTextIsEmpty(const std::string& text, const std::string& compMsg, const int& exceptionType) { if (text.empty()) { throw UMSVishnuException(exceptionType, compMsg); } }
/** * \brief Function to check if a given user identifier exists * \param userId the user identifier * \return raises an exception on error */ void FileTransferServer::checkUserId(std::string userId) { std::string sqlUserRequest = "SELECT userid from users where userid='"+FileTransferServer::getDatabaseInstance()->escapeData(userId)+"'"; boost::scoped_ptr<DatabaseResult> user(FileTransferServer::getDatabaseInstance()->getResult(sqlUserRequest.c_str())); if (user->getNbTuples() == 0) { throw UMSVishnuException(ERRCODE_UNKNOWN_USERID); } }
/** * \brief Function to add a new VISHNU machine * \return raises an exception on error */ int MachineServer::add(void) { UserServer userServer = UserServer(msessionServer); userServer.init(); if (! userServer.exist()) { throw UMSVishnuException (ERRCODE_UNKNOWN_USER); } if (! userServer.isAdmin()) { throw UMSVishnuException (ERRCODE_NO_ADMIN); } dbSave(); return 0; }
/** * \brief Function to check if an email is valid * \param mail The email to check * \return raises an exception on error */ void checkEmail(const std::string& mail) { // Regex taken from http://www.regular-expressions.info/email.html boost::regex reg("^[[:alnum:]._%+-]+@[[:alnum:]-]+(?:\\.[[:alnum:]]+)*"); if (!boost::regex_match(mail, reg)) { throw UMSVishnuException(ERRCODE_INVALID_MAIL_ADRESS); } }
/** * \brief Function to list sessions information * \return The pointer to the UMS_Data::ListSessions containing sessions information * \return raises an exception on error */ UMS_Data::ListSessions* list(UMS_Data::ListSessionOptions_ptr option) { std::string query = (boost::format("SELECT DISTINCT vsessionid, userid, sessionkey, state, closepolicy, " " timeout, lastconnect, creation, closure, authid " " FROM vsession, users, clmachine" " WHERE vsession.state = %1%" " AND users.status = %1%" " AND vsession.users_numuserid = users.numuserid" " AND vsession.clmachine_numclmachineid=clmachine.numclmachineid") % vishnu::STATUS_ACTIVE).str(); std::vector<std::string>::iterator dbResultIter; std::vector<std::string> dbResults; UMS_Data::UMS_DataFactory_ptr ecoreFactory = UMS_Data::UMS_DataFactory::_instance(); mlistObject = ecoreFactory->createListSessions(); //Creation of the object user UserServer userServer = UserServer(msessionServer); userServer.init(); if (! userServer.exist()) { throw UMSVishnuException (ERRCODE_UNKNOWN_USER); } processOptions(userServer, option, query); query.append(" order by creation"); //To get the list of sessions from the database boost::scoped_ptr<DatabaseResult> ListOfSessions (mdatabase->getResult(query)); if (ListOfSessions->getNbTuples() != 0){ for (size_t i = 0; i < ListOfSessions->getNbTuples(); ++i) { dbResults.clear(); dbResults = ListOfSessions->get(i); dbResultIter = dbResults.begin(); UMS_Data::Session_ptr session = ecoreFactory->createSession(); session->setSessionId(*(dbResultIter)); session->setUserId(*(++dbResultIter)); session->setSessionKey(*(++dbResultIter)); session->setStatus(vishnu::convertToInt(*(++dbResultIter))); session->setClosePolicy(vishnu::convertToInt(*(++dbResultIter))); session->setTimeout(vishnu::convertToInt(*(++dbResultIter))); session->setDateLastConnect(convertToTimeType(*(++dbResultIter))); session->setDateCreation(convertToTimeType(*(++dbResultIter))); session->setDateClosure(convertToTimeType(*(++dbResultIter))); session->setAuthenId(*(++dbResultIter)); mlistObject->getSessions().push_back(session); } } return mlistObject; }
/** * \brief Function to update machine description * \fn int update() * \return raises an exception on error */ int MachineProxy::update() { diet_profile_t* updateProfile = NULL; std::string sessionKey; std::string machineToString; char* errorInfo; std::string msg = "call of function diet_string_set is rejected "; updateProfile = diet_profile_alloc("machineUpdate", 1, 1, 2); sessionKey = msessionProxy.getSessionKey(); ::ecorecpp::serializer::serializer _ser; //To serialize the mmachine object in to machineToString machineToString = _ser.serialize_str(const_cast<UMS_Data::Machine_ptr>(&mmachine)); std::string sshKeyFilePath = mmachine.getSshPublicKey(); if(sshKeyFilePath.find("\"")!=std::string::npos) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, " The machine SshPublicKey contains special character double quote \""); } //IN Parameters if(diet_string_set(diet_parameter(updateProfile,0), strdup(sessionKey.c_str()), DIET_VOLATILE)) { msg += "with sessionKey parameter "+sessionKey; raiseDietMsgException(msg); } if(diet_string_set(diet_parameter(updateProfile,1), strdup(machineToString.c_str()), DIET_VOLATILE)) { msg += "with machineToString parameter "+machineToString; raiseDietMsgException(msg); } //OUT Parameters diet_string_set(diet_parameter(updateProfile,2), NULL, DIET_VOLATILE); if(!diet_call(updateProfile)) { if(diet_string_get(diet_parameter(updateProfile,2), &errorInfo, NULL)){ msg += "by receiving errorInfo message"; raiseDietMsgException(msg); } } else { raiseDietMsgException("DIET call failure"); } /*To raise a vishnu exception if the receiving message is not empty*/ raiseExceptionIfNotEmptyMsg(errorInfo); diet_profile_free(updateProfile); return 0; }
/** * \brief Function to list locoal accounts information * \return The pointer to the UMS_Data::ListLocalAccounts containing local accounts information * \return raises an exception on error */ UMS_Data::ListLocalAccounts* list(UMS_Data::ListLocalAccOptions_ptr option) { std::string query = boost::str(boost::format("SELECT DISTINCT machineid, userid, aclogin, home" " FROM account, machine, users" " WHERE account.status = %1%" " AND machine.status = %1%" " AND users.status = %1%" " AND account.machine_nummachineid = machine.nummachineid" " AND account.users_numuserid = users.numuserid" ) % vishnu::STATUS_ACTIVE); std::vector<std::string>::iterator dbResultIter; std::vector<std::string> dbResults; UMS_Data::UMS_DataFactory_ptr ecoreFactory = UMS_Data::UMS_DataFactory::_instance(); mlistObject = ecoreFactory->createListLocalAccounts(); //Creation of the object user UserServer userServer = UserServer(msessionServer); userServer.init(); if (! userServer.exist()) { throw UMSVishnuException (ERRCODE_UNKNOWN_USER); } //To process options processOptions(userServer, option, query); boost::scoped_ptr<DatabaseResult> resultAccount(mdatabase->getResult(query)); if (resultAccount->getNbTuples() != 0){ for (size_t i = 0; i < resultAccount->getNbTuples(); ++i) { dbResults.clear(); dbResults = resultAccount->get(i); dbResultIter = dbResults.begin(); UMS_Data::LocalAccount_ptr localAccount = ecoreFactory->createLocalAccount(); localAccount->setMachineId(*dbResultIter); localAccount->setUserId(*(++dbResultIter)); localAccount->setAcLogin(*(++dbResultIter)); localAccount->setHomeDirectory(*(++dbResultIter)); mlistObject->getAccounts().push_back(localAccount); } } return mlistObject; }
void SysInfoServer::setSysInfo(IMS_Data::SystemInfo_ptr sys) { bool added = false; if (!msession.isAdmin()){ throw UMSVishnuException(ERRCODE_NO_ADMIN, "set system info is an admin function. A user cannot call it"); } // No update needed if (sys->getMemory()==0 && sys->getDiskSpace()==0) { return; } if (sys->getMachineId().compare("")==0) { throw UserException(ERRCODE_INVALID_PARAM, "Error missing the machine id. "); } string reqnmid = "SELECT nummachineid from machine where machineid ='"+sys->getMachineId()+"'"; boost::scoped_ptr<DatabaseResult> result(mdatabase->getResult(reqnmid.c_str())); if(result->getNbTuples() == 0) { throw IMSVishnuException(ERRCODE_INVPROCESS, "Unknown machine id"); } string request = "update machine set "; if (sys->getDiskSpace() < 0 || sys->getMemory() < 0) { throw UserException(ERRCODE_INVALID_PARAM, "Invalid negative value"); } if (sys->getDiskSpace()>0) { request += " diskspace ="+convertToString(sys->getDiskSpace()); added = true; } if (sys->getMemory()>0) { if (added) { request += ","; } request += " memory ="+convertToString(sys->getMemory()); } request += " where machineid ='"+sys->getMachineId()+"'"; request += " AND vishnu_vishnuid="; request += convertToString(mvishnuId); try{ mdatabase->process(request.c_str()); }catch(SystemException& e){ e.appendMsgComp(" Error inserting new system states "); throw(e); } }
/** * \brief Gets standard output files of all completed jobs (applies only once for each job) * \param sessionKey : The session key * \param options: object containing options * \param listOfResults : Is the list of jobs results * \param options: Object containing options * \return int : an error code */ int vishnu::getCompletedJobsOutput(const std::string& sessionKey, TMS_Data::ListJobResults& listOfResults, const TMS_Data::JobOutputOptions& options) throw (UMSVishnuException, TMSVishnuException, UserException, SystemException) { checkEmptyString(sessionKey, "The session key"); std::string outputDir = options.getOutputDir(); if (! outputDir.empty() && ! boost::filesystem::exists(outputDir)) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, "The ouput directory does not exist: "+outputDir); } UMS_Data::ListMachines machines; if (options.getMachineId().empty()) { vishnu::listMachinesWithUserLocalAccount(sessionKey, machines); } else { UMS_Data::Machine_ptr machine = new UMS_Data::Machine(); // delete by EMF machine->setMachineId(options.getMachineId()); machines.getMachines().push_back(machine); } int machineCount = machines.getMachines().size(); for (int index = 0; index < machineCount; ++index) { SessionProxy sessionProxy(sessionKey); JobOutputProxy jobOutputProxy(sessionProxy, machines.getMachines().get(index)->getMachineId()); TMS_Data::ListJobResults_ptr listJobResults_ptr = jobOutputProxy.getCompletedJobsOutput(options); if (listJobResults_ptr != NULL) { TMS_Data::TMS_DataFactory_ptr ecoreFactory = TMS_Data::TMS_DataFactory::_instance(); for(unsigned int i = 0; i < listJobResults_ptr->getResults().size(); i++) { TMS_Data::JobResult_ptr jobResult = ecoreFactory->createJobResult(); //To copy the content and not the pointer *jobResult = *listJobResults_ptr->getResults().get(i); listOfResults.getResults().push_back(jobResult); } listOfResults.setNbJobs(listJobResults_ptr->getNbJobs()); delete listJobResults_ptr; } } return 0; }
/** * \brief Function to treat the ListMachinesServer options * \param userServer the object which encapsulates user information * \param options the object which contains the ListMachinesServer options values * \param sqlRequest the sql data base request * \return raises an exception on error */ void processOptions(UserServer userServer, const UMS_Data::ListMachineOptions_ptr& options, std::string& sqlRequest) { std::string sqlJoinLstMachines = boost::str(boost::format("SELECT DISTINCT machineid, address, machine.status, description, userid " " FROM machine, account, users" " WHERE account.machine_nummachineid = machine.nummachineid " " AND account.users_numuserid = users.numuserid " " AND machine.status != %1%" " AND account.status != %1%" " AND users.status != %1%" ) % vishnu::STATUS_DELETED); std::string sqlListofMachinesIntial = sqlRequest; bool isListAll = options->isListAllMachine(); if (! userServer.isAdmin() && ! options->getUserId().empty()) { throw UMSVishnuException (ERRCODE_NO_ADMIN); } if(! isListAll) { sqlRequest = sqlJoinLstMachines; addOptionRequest("userid", userServer.getData().getUserId(), sqlRequest); } //The admin option if (! options->getUserId().empty()) { sqlRequest = sqlJoinLstMachines; addOptionRequest("users.numuserid", getNumUser(options->getUserId()), sqlRequest); } if (! options->getMachineId().empty()) { getNumMachine( options->getMachineId() ); if(! isListAll && options->getUserId().empty()) { sqlRequest = sqlListofMachinesIntial; } addOptionRequest("machineid", options->getMachineId(), sqlRequest); } }
/** * \brief Function to treat the ListCommandsServer options * \param userServer the object which encapsulates user information * \param options the object which contains the ListCommandsServer options values * \param sqlRequest the sql data base request * \return raises an exception on error */ void processOptions(UserServer userServer, const UMS_Data::ListCmdOptions_ptr& options, std::string& sqlRequest) { boost::posix_time::ptime pt; bool listAll = options->isAdminListOption(); if (! userServer.isAdmin() && (! options->getUserId().empty() || listAll)) { throw UMSVishnuException (ERRCODE_NO_ADMIN); } if(! options->getUserId().empty()) { addOptionRequest("users.numuserid", getNumUser(options->getUserId()), sqlRequest); } else { if(! listAll) { addOptionRequest("userid", userServer.getData().getUserId(), sqlRequest); } } if (! options->getSessionId().empty()) { checkSessionId(options->getSessionId()); addOptionRequest("vsessionid", options->getSessionId(), sqlRequest); } time_t startDate = static_cast<time_t>(options->getStartDateOption()); if (startDate != -1) { pt = boost::posix_time::from_time_t(startDate); std::string startDateStr = boost::posix_time::to_iso_string(pt); addTimeRequest("starttime", startDateStr, sqlRequest, ">="); } time_t endDate = static_cast<time_t>(options->getEndDateOption()); if(endDate!=-1) { pt = boost::posix_time::from_time_t(endDate); std::string endDateStr = boost::posix_time::to_iso_string(pt); addTimeRequest("endtime", endDateStr, sqlRequest, "<="); } }
/** * \brief The getJobOutput function gets outputPath and errorPath of a job from its id * \param sessionKey : The session key * \param machineId : The Id of the machine * \param jobId : The Id of the job * \param outputInfo : The Job object containing the job output information (ex: outputPath and errorPath) of the job to submit * \param outDir : The output directory where the files will be stored (default is current directory) * \return int : an error code */ int vishnu::getJobOutput(const std::string& sessionKey, const std::string& machineId, const std::string& jobId, JobResult& outputInfo, const std::string& outDir) throw (UMSVishnuException, TMSVishnuException, UserException, SystemException) { checkEmptyString(sessionKey, "The session key"); checkEmptyString(machineId, "The machine id"); if((outDir.size()!=0)&&(!boost::filesystem::exists(outDir))) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, "The directory "+outDir+" does not exist"); } SessionProxy sessionProxy(sessionKey); JobOutputProxy jobOutputProxy(sessionProxy, machineId, outDir); outputInfo = jobOutputProxy.getJobOutPut(jobId); return 0; }
/** * \brief Function to treat the listSessionServer options * \param userServer the object which encapsulates user information * \param options the object which contains the ListSessionServer options values * \param sqlRequest the sql data base request * \return raises an exception on error */ void processOptions(UserServer userServer, const UMS_Data::ListSessionOptions_ptr& options, std::string& sqlRequest) { boost::posix_time::ptime pt; size_t userIdSize = options->getUserId().size(); bool listAll = options->isAdminListOption(); if ((!userServer.isAdmin()) && (userIdSize!=0 || listAll)) { UMSVishnuException e (ERRCODE_NO_ADMIN); throw e; } if(options->getMachineId().size()!=0) { //To check if the name of the machine is correct checkClientMachineName(options->getMachineId()); sqlRequest = "SELECT vsessionid, userid, sessionkey, state, closepolicy, timeout, lastconnect," "creation, closure, authid from vsession, users, clmachine where vsession.users_numuserid=users.numuserid" " and vsession.clmachine_numclmachineid=clmachine.numclmachineid"; addOptionRequest("name", options->getMachineId(), sqlRequest); } if(userIdSize!=0) { //To check if the user id is correct checkUserId(options->getUserId()); addOptionRequest("userid", options->getUserId(), sqlRequest); } else { if(!listAll) { addOptionRequest("userid", userServer.getData().getUserId(), sqlRequest); } } int status = options->getStatus(); if (status == vishnu::STATUS_UNDEFINED) { status = vishnu::STATUS_ACTIVE; } //To check the status value checkStatus(status); addIntegerOptionRequest("state", status, sqlRequest); int closePolicy = options->getSessionClosePolicy(); //To check the closePolicy value checkClosePolicy(closePolicy); if(closePolicy) { addIntegerOptionRequest("closepolicy", closePolicy, sqlRequest); } int timeOut = options->getSessionInactivityDelay(); if(timeOut < 0) { throw UMSVishnuException(ERRCODE_INCORRECT_TIMEOUT); } if(timeOut) { addIntegerOptionRequest("timeout", timeOut, sqlRequest); } if(options->getSessionId().size()!=0) { //To check if the session id is correct checkSessionId(options->getSessionId()); addOptionRequest("vsessionid", options->getSessionId(), sqlRequest); } time_t startDate = static_cast<time_t>(options->getStartDateOption()); if(startDate!=-1) { pt = boost::posix_time::from_time_t(startDate); std::string startDateStr = boost::posix_time::to_iso_string(pt); addTimeRequest("creation", startDateStr, sqlRequest, ">="); } time_t endDate = static_cast<time_t>(options->getEndDateOption()); if(endDate!=-1) { pt = boost::posix_time::from_time_t(endDate); std::string endDateStr = boost::posix_time::to_iso_string(pt); addTimeRequest("closure", endDateStr, sqlRequest, "<="); } }
int LSFParser::parse_file(const char* pathTofile, struct submit* req) { std::vector<std::string> tokensArgs=convertScriptIntoArgv(pathTofile); int argc = tokensArgs.size()+1; char* argv[argc]; argv[0] = (char*) "vishnu_submit_job"; for(int i=0; i < tokensArgs.size(); ++i) { argv[i+1] = strdup(tokensArgs[i].c_str()); } #define GETOPT_ARGS "J:q:m:n:i:o:e:xNBG:k:rw:R:E:L:P:u:U:KW:g:Hc:F:p:M:D:S:v:T:b:t:f:Q:s:" int option_index = 0; optind=0; int c; std::string host_list; std::vector<std::string> host_tokens; std::string procsStr; std::istringstream stream_procs; std::string min_proc_str; std::string max_proc_str; int min_proc; int max_proc; char separator=','; std::string chkpnt; std::vector<std::string> chkpnt_tokens; std::string timeStr; std::string wHostSpec; struct xFile *tmpXfile; std::string xFileStr; std::vector<std::string> xFile_tokens; int oldNxf; std::string errHead = "Error in your script: "; //set default values for jobName and job output and error path req->options |=SUB_JOB_NAME; req->jobName = (char*) "NoName"; req->options |=SUB_OUT_FILE; req->outFile = (char*) "lsf-%J.out"; req->options |=SUB_ERR_FILE; req->errFile = (char*) "lsf-%J.err"; //Parse options in script file while ((c = getopt_long_only(argc, argv, GETOPT_ARGS, long_options, &option_index)) != -1) { switch (c) { case 'J': req->options |=SUB_JOB_NAME; req->jobName = strdup(optarg); break; case 'q': req->options |=SUB_QUEUE; req->queue = strdup(optarg); break; case 'm': req->options |=SUB_HOST; host_list = strdup(optarg); host_tokens=getStreamTokens(host_list); req->numAskedHosts = host_tokens.size(); req->askedHosts = new char*[host_tokens.size()]; for(int i=0; i < host_tokens.size(); i++) { req->askedHosts[i] = strdup(host_tokens[i].c_str()); } break; case 'n': procsStr = strdup(optarg); if (procsStr.find(',')!=std::string::npos) { stream_procs.str(procsStr); stream_procs >> min_proc_str; min_proc_str = procsStr.substr(0,procsStr.find(separator)); if (procsStr.find(separator)+1!=std::string::npos) { max_proc_str = procsStr.substr(procsStr.find(separator)+1); } if (!isNumerical(min_proc_str) || !isNumerical(max_proc_str)) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+std::string(optarg)+"is an invalid" " value for -n option. Correct format is -n min_processors[,max_processors]"); } min_proc = vishnu::convertToInt(min_proc_str); max_proc = vishnu::convertToInt(max_proc_str); } else { if (isNumerical(procsStr)) { min_proc = vishnu::convertToInt(procsStr); max_proc = min_proc; } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+std::string(optarg)+" is an invalid" " value for -n option. Correct format is -n min_processors[,max_processors]"); } } req->numProcessors=min_proc; req->maxNumProcessors=max_proc; break; case 'i': if ((req->options2 & SUB2_IN_FILE_SPOOL)==SUB2_IN_FILE_SPOOL) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+" is|i options are exclusive"); } req->options |=SUB_IN_FILE; req->inFile = strdup(optarg); break; case 'o': req->options |=SUB_OUT_FILE; req->outFile = strdup(optarg); break; case 'e': req->options |=SUB_ERR_FILE; req->errFile = strdup(optarg); break; case 'x': req->options |=SUB_EXCLUSIVE; break; case 'N': req->options |=SUB_NOTIFY_END; break; case 'B': req->options |=SUB_NOTIFY_BEGIN; break; case 'G': req->options |=SUB_USER_GROUP; req->userGroup = strdup(optarg); break; case 'k': req->options |=SUB_CHKPNT_DIR; chkpnt = strdup(optarg); chkpnt_tokens=getStreamTokens(chkpnt); req->chkpntDir = strdup(chkpnt_tokens[0].c_str()); if (chkpnt_tokens.size() >=2) { if (boost::algorithm::starts_with(chkpnt_tokens[1], "init=")) { chkpnt_tokens[1] = chkpnt_tokens[1].substr(std::string("init=").size()); if (isNumerical(chkpnt_tokens[1])) { req->initChkpntPeriod = vishnu::convertToInt(chkpnt_tokens[1]); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+chkpnt_tokens[1]+" is an invalid" " initial checkpoint period value for -k option."); } } else { if (isNumerical(chkpnt_tokens[1])) { req->chkpntPeriod= vishnu::convertToInt(chkpnt_tokens[1]); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+chkpnt_tokens[1]+" is an invalid" " checkpoint period value for -k option."); } } } if (chkpnt_tokens.size() >=3) { if (!boost::algorithm::starts_with(chkpnt_tokens[2], "method=")) { req->options |=SUB_CHKPNT_PERIOD; if (isNumerical(chkpnt_tokens[2])) { req->chkpntPeriod= vishnu::convertToInt(chkpnt_tokens[2]); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+chkpnt_tokens[2]+" is an invalid" " checkpoint period value for -k option."); } } } break; case 'r': req->options |=SUB_RERUNNABLE; if ((req->options3 & SUB3_NOT_RERUNNABLE)==SUB3_NOT_RERUNNABLE) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+" You cannot set a job to be rerunnable" "and not-rerunnable at the same time"); } break; case 'w': req->options |=SUB_DEPEND_COND; req->dependCond = strdup(optarg); break; case 'R': req->options |=SUB_RES_REQ; req->resReq = strdup(optarg); break; case 'E': req->options |=SUB_PRE_EXEC; req->preExecCmd = strdup(optarg); break; case 'L': req->options |=SUB_LOGIN_SHELL; req->loginShell = strdup(optarg); break; case 'P': req->options |=SUB_PROJECT_NAME; req->projectName = strdup(optarg); break; case 'u': req->options |=SUB_MAIL_USER; req->mailUser = strdup(optarg); break; case 'U': req->options2 |=SUB2_USE_RSV; req->rsvId = strdup(optarg); break; case 'K': throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+" option -K is " " not treated by VISHNU."); break; case 'W': //-W run_limit[/host_spec] timeStr = std::string(strdup(optarg)); if (timeStr.find("/")!=std::string::npos) { if ((timeStr.find("/")+1)!=std::string::npos) { req->options |= SUB_HOST_SPEC; req->rLimits[LSF_RLIMIT_RUN] = convertWallTimeToTime(timeStr.substr(0, timeStr.find("/"))); wHostSpec = timeStr.substr(timeStr.find("/")+1); req->hostSpec = strdup(wHostSpec.c_str()); } } else { req->rLimits[LSF_RLIMIT_RUN] = convertWallTimeToTime(timeStr); } break; case 'g': req->options2 |= SUB2_JOB_GROUP; req->jobGroup = strdup(optarg); break; case 'H': req->options2 |= SUB2_HOLD; break; case 'c': timeStr = std::string(strdup(optarg)); if (timeStr.find("/")!=std::string::npos) { if ((timeStr.find("/")+1)!=std::string::npos) { req->options |= SUB_HOST_SPEC; req->rLimits[LSF_RLIMIT_CPU] = convertWallTimeToTime(timeStr.substr(0, timeStr.find("/"))); wHostSpec = timeStr.substr(timeStr.find("/")+1); req->hostSpec = strdup(wHostSpec.c_str()); } } else { req->rLimits[LSF_RLIMIT_CPU] = convertWallTimeToTime(timeStr); } break; case 'F': if (isNumerical(strdup(optarg))) { req->rLimits[LSF_RLIMIT_FSIZE]=vishnu::convertToInt(strdup(optarg)); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+std::string(strdup(optarg))+" is an invalid" " file_limit value for -F option."); } break; case 'p': if (isNumerical(strdup(optarg))) { req->rLimits[LSF_RLIMIT_PROCESS]=vishnu::convertToInt(strdup(optarg)); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+std::string(strdup(optarg))+" is an invalid" " process_limit value for -p option."); } break; case 'M': if (isNumerical(strdup(optarg))) { req->rLimits[LSF_RLIMIT_RSS]=vishnu::convertToInt(strdup(optarg)); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+std::string(strdup(optarg))+" is an invalid" " mem_limit value for -M option."); } break; case 'D': if (isNumerical(strdup(optarg))) { req->rLimits[LSF_RLIMIT_DATA]=vishnu::convertToInt(strdup(optarg)); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+std::string(strdup(optarg))+" is an invalid" " data_limit value for -D option."); } break; case 'S': if (isNumerical(strdup(optarg))) { req->rLimits[LSF_RLIMIT_STACK]=vishnu::convertToInt(strdup(optarg)); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+std::string(strdup(optarg))+" is an invalid" " stack_limit value for -S option."); } break; case 'v': if (isNumerical(strdup(optarg))) { req->rLimits[LSF_RLIMIT_SWAP]=vishnu::convertToInt(strdup(optarg)); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+std::string(strdup(optarg))+" is an invalid" " swap_limit value for -v option."); } break; case 'T': if (isNumerical(strdup(optarg))) { req->rLimits[LSF_RLIMIT_THREAD]=vishnu::convertToInt(strdup(optarg)); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+std::string(strdup(optarg))+" is an invalid" " thread_limit value for -T option."); } break; case 'b': req->beginTime = convertDateToTime(strdup(optarg), " See LSF manual for -b option."); break; case 't': req->termTime = convertDateToTime(strdup(optarg), " See LSF manual for -t option."); break; case 'f': //-f "lfile op [rfile]" xFileStr = strdup(optarg); xFile_tokens = getStreamTokens(xFileStr); if (xFile_tokens.size() < 2) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+xFileStr+" is an invalid" " file transfer value for -f option. This must be taken at least two arguments "); } else { if (req->nxf > 0) { oldNxf=req->nxf; tmpXfile = new xFile[req->nxf]; for(int i=0; i < oldNxf; ++i) { tmpXfile[i]=req->xf[i]; } delete [] req->xf; req->nxf +=1; req->xf = new xFile[req->nxf]; for(int i=0; i < oldNxf; ++i) { req->xf[i]=tmpXfile[i]; } delete [] tmpXfile; } else { oldNxf=0; req->nxf =1; req->xf = new xFile[req->nxf]; } req->xf[oldNxf].subFn = strdup(xFile_tokens[0].c_str()); if (xFile_tokens[1]==">") { req->xf[oldNxf].options = XF_OP_SUB2EXEC; } else if (xFile_tokens[1]=="<") { req->xf[oldNxf].options = XF_OP_EXEC2SUB; } else if (xFile_tokens[1]=="<<") { req->xf[oldNxf].options = XF_OP_EXEC2SUB_APPEND; } else if (xFile_tokens[1]=="><") { req->xf[oldNxf].options = (XF_OP_SUB2EXEC | XF_OP_EXEC2SUB); } else if (xFile_tokens[1]=="<>") { req->xf[oldNxf].options = (XF_OP_SUB2EXEC | XF_OP_EXEC2SUB); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+xFile_tokens[1]+" is an invalid" " file transfer operator for -f option. See LSF manual."); } if (xFile_tokens.size() >=3) { req->xf[oldNxf].execFn = strdup(xFile_tokens[2].c_str()); } } break; case 'Q': req->options3 |= SUB3_JOB_REQUEUE; req->requeueEValues = strdup(optarg); break; case 's': if (isNumerical(strdup(optarg))) { req->sigValue = vishnu::convertToInt(strdup(optarg)); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+std::string(strdup(optarg))+" is an invalid" " job migration threshold value for -s option."); } break; case LONG_OPT_APP: req->options3 |= SUB3_APP; req->app= strdup(optarg); break; case LONG_OPT_CWD: req->options3 |= SUB3_CWD; req->cwd= strdup(optarg); break; case LONG_OPT_UL: req->options3 |= SUB3_USER_SHELL_LIMITS; break; case LONG_OPT_WE: req->options3 |= SUB3_RUNTIME_ESTIMATION; timeStr = strdup(optarg); if (timeStr.find("/")!=std::string::npos) { if ((timeStr.find("/")+1)!=std::string::npos) { req->options |= SUB_HOST_SPEC; req->runtimeEstimation = convertWallTimeToTime(timeStr.substr(0, timeStr.find("/"))); wHostSpec = timeStr.substr(timeStr.find("/")+1); req->hostSpec = strdup(wHostSpec.c_str()); } } else { req->runtimeEstimation = convertWallTimeToTime(timeStr); } break; case LONG_OPT_RN: req->options3 |= SUB3_NOT_RERUNNABLE; if ((req->options & SUB_RERUNNABLE)==SUB_RERUNNABLE) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+" You cannot set a job to be rerunnable" "and not-rerunnable at the same time"); } break; case LONG_OPT_JD: req->options3 |= SUB3_JOB_DESCRIPTION; req->jobDescription = strdup(optarg); break; case LONG_OPT_IS: if ((req->options & SUB_IN_FILE)==SUB_IN_FILE) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+" is|i options are exclusive"); } req->options |=SUB_IN_FILE; req->options2 |=SUB2_IN_FILE_SPOOL; req->inFile = strdup(optarg); break; case LONG_OPT_EO: req->options |=SUB_ERR_FILE; req->options2 |= SUB2_OVERWRITE_ERR_FILE; req->errFile = strdup(optarg); break; case LONG_OPT_OO: req->options |=SUB_OUT_FILE; req->options2 |= SUB2_OVERWRITE_OUT_FILE; req->outFile = strdup(optarg); break; case LONG_OPT_AR: req->options3 |= SUB3_AUTO_RESIZE; break; case LONG_OPT_WA: req->options2 |=SUB2_WARNING_ACTION; req->warningAction = strdup(optarg); break; case LONG_OPT_WT: req->options2 |= SUB2_WARNING_TIME_PERIOD; req->warningTimePeriod = convertWallTimeToTime(strdup(optarg), "Is an invalid" " job action warning time value for -wt option."); break; case LONG_OPT_ZS: throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+" -Zs is not supported for VISHNU" " because LSF is unable to determine the first command" " to be spooled in an embedded job command" "(VISHNU job is considered by LSF as embedded job commands)"); break; case LONG_OPT_EP: req->options3 |= SUB3_POST_EXEC; req->postExecCmd = strdup(optarg); break; case LONG_OPT_SP: req->options2 |= SUB2_JOB_PRIORITY; if (isNumerical(strdup(optarg))) { req->userPriority = vishnu::convertToInt(strdup(optarg)); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+std::string(strdup(optarg))+" is an invalid" " job priority value for -sp option."); } break; case LONG_OPT_MIG: req->options3 |=SUB3_MIG_THRESHOLD; if (isNumerical(strdup(optarg))) { req->migThreshold = vishnu::convertToInt(strdup(optarg)); } else { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+std::string(strdup(optarg))+" is an invalid" " job migration threshold value for -mig option."); } break; case LONG_OPT_SLA: req->options2 |=SUB2_SLA; req->sla = strdup(optarg); break; case LONG_OPT_EXT: req->options2 |=SUB2_EXTSCHED; req->extsched = strdup(optarg); break; case LONG_OPT_LP: req->options2 |=SUB2_LICENSE_PROJECT; req->licenseProject = strdup(optarg); break; case LONG_OPT_JSDL: if (req->jsdlFlag == 0) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+" conflict: you cannot set jsdl" " and jsdl_strict at the same time"); } req->jsdlFlag = 1; req->jsdlDoc = strdup(optarg); break; case LONG_OPT_JSDL_STRICT: if (req->jsdlFlag == 1) { throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+" conflict: you cannot set jsdl" " and jsdl_strict at the same time"); } req->jsdlFlag = 0; req->jsdlDoc = strdup(optarg); break; case LONG_OPT_RNC: req->options3 |=SUB3_RESIZE_NOTIFY_CMD; req->notifyCmd = strdup(optarg); break; case LONG_OPT_XF: throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+" option -XF is " " not treated by VISHNU."); break; case LONG_OPT_I: case LONG_OPT_Ip: case LONG_OPT_Is: case LONG_OPT_IS2: case LONG_OPT_ISp: case LONG_OPT_ISs: case LONG_OPT_IX: throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+" LSF batch interactive job " "option "+std::string(argv[optind-1])+" is not supported by VISHNU"); break; default: throw UMSVishnuException(ERRCODE_INVALID_PARAM, errHead+"Invalid option: " +std::string(argv[optind-1])); break; }
std::vector<std::string> LSFParser::convertScriptIntoArgv(const char* pathTofile, const std::string& BATCH_PREFIX) { std::ifstream fileStream; std::string line; fileStream.open (pathTofile); std::string cmd; std::vector<std::string> tokens; std::string tmpLine=""; size_t escapePos; bool escapeFound = false; if (fileStream.is_open()) { while (!fileStream.eof()) { getline(fileStream, line); //Treating of the escape character int the script content if (boost::algorithm::ends_with(boost::algorithm::erase_all_copy(line, " "),"\\")) { escapePos = line.rfind("\\"); if (escapePos!=std::string::npos) { tmpLine += line.substr(0, escapePos); escapeFound = true; continue; } } if (escapeFound) { tmpLine +=line; line = tmpLine; escapeFound = false; tmpLine = ""; } // erase all white space until # (excluded) while(boost::algorithm::starts_with(line, " ")) { line.erase(0,1); }; /*search # character*/ size_t pos = line.find('#'); if (pos == std::string::npos) { continue; } if (boost::algorithm::starts_with(boost::algorithm::erase_all_copy(line," "), BATCH_PREFIX)) { pos = line.find(BATCH_PREFIX.substr(1));//skip the character # in BATCH_PREFIX line = line.substr(pos+BATCH_PREFIX.size()-1); //To skip a comment on the line pos = line.find('#'); if (pos != std::string::npos) { if (pos-1 >=0) { std::string tmp = line.substr(pos-1); if (boost::algorithm::starts_with(boost::algorithm::erase_all_copy(tmp, " "), "#")) { line = line.substr(0, pos); } } else { line = line.substr(0, pos); } } //verify quote characters in line verifyQuotaCharacter(line, '\"'); verifyQuotaCharacter(line, '\''); //add line to cmd cmd = cmd+" "+line; } } fileStream.close(); std::istringstream iss(cmd); std::copy(std::istream_iterator<std::string>(iss), std::istream_iterator<std::string>(), std::back_inserter<std::vector<std::string> >(tokens)); } std::string argvStr; std::vector<std::string>::iterator iter; std::vector<std::string>::iterator end = tokens.end(); std::vector<std::string> tokensArgs; char quote = '\0'; for(iter=tokens.begin(); iter!=end; ++iter) { argvStr = *iter; if (isStartByQuote(argvStr, '\"')) { quote = '\"'; } else if (isStartByQuote(argvStr, '\'')) { quote = '\''; } if (quote!='\0') { std::vector<std::string>::iterator found_iter; std::vector<std::string>::iterator beg_iter=iter; found_iter = std::find_if(beg_iter, end, IsEndByQuote(quote)); if (found_iter!=end) { while(beg_iter!=found_iter) { ++beg_iter; argvStr = argvStr+" "+*beg_iter; } iter=beg_iter; } else { std::string errorMsg = "Error: invalid argument "+argvStr; errorMsg +=". It must be closed by the character quote character (\' or \")"; throw UMSVishnuException(ERRCODE_INVALID_PARAM, errorMsg); } } quote='\0'; if (!cleanString(argvStr, '\"')) { cleanString(argvStr, '\''); } tokensArgs.push_back(argvStr); } return tokensArgs; }
time_t LSFParser::convertDateToTime(const std::string& date, const std::string& compErrMsg) { time_t totalTime; time_t timeNow; struct tm totalTimeTm; struct tm *timeNowTm; int minute = -1; int hour = -1; int day = -1; int month = -1; int year = -1; bool hasDayField = false; bool hasMonthField = false; bool hasYearField = false; std::string errMsg = "illegal date option value "+date+":"; std::vector<std::string> tokens = getTimeToKens(date); for(std::vector<std::string>::iterator iter = tokens.begin(); iter!=tokens.end(); ++iter) { if (!isNumerical(*iter)) { errMsg += " The fields values must be intergers."; throw UMSVishnuException(ERRCODE_INVALID_PARAM, errMsg+" "+compErrMsg); } } if (tokens.size() < 2) { errMsg += " At least two fields must be specified."; throw UMSVishnuException(ERRCODE_INVALID_PARAM, errMsg+" "+compErrMsg); } else { //minute minute = vishnu::convertToInt(tokens[0]); if (minute < 0 || minute > 59) { errMsg += " minute number range must be 0-59."; throw UMSVishnuException(ERRCODE_INVALID_PARAM, errMsg+" "+compErrMsg); } //hour hour = vishnu::convertToInt(tokens[1]); if (hour < 0 || hour > 23) { errMsg += " hour number range must be 0-23."; throw UMSVishnuException(ERRCODE_INVALID_PARAM, errMsg+" "+compErrMsg); } //day if (tokens.size() >= 3) { day = vishnu::convertToInt(tokens[2]); if (day < 1 || day > 31) { errMsg += " day number range must be 1-31."; throw UMSVishnuException(ERRCODE_INVALID_PARAM, errMsg+" "+compErrMsg); } hasDayField = true; } //month if (tokens.size() >= 4) { month = vishnu::convertToInt(tokens[3]); if (month < 1 || month > 12) { errMsg += " month number range must be 1-31."; throw UMSVishnuException(ERRCODE_INVALID_PARAM, errMsg+" "+compErrMsg); } hasMonthField = true; } //year if (tokens.size() >= 5) { year = vishnu::convertToInt(tokens[4]); if (year < 1970) { errMsg += " year must after 1970."; throw UMSVishnuException(ERRCODE_INVALID_PARAM, errMsg+" "+compErrMsg); } hasYearField = true; } } timeNow = std::time(NULL); timeNowTm = std::localtime(&timeNow); totalTimeTm.tm_min = minute; totalTimeTm.tm_hour = hour; //day if (hasDayField) { totalTimeTm.tm_mday = day; } else { if ((hour < timeNowTm->tm_hour)|| (hour==timeNowTm->tm_hour && minute < timeNowTm->tm_min)) { totalTimeTm.tm_mday = timeNowTm->tm_mday+1; } else { totalTimeTm.tm_mday = timeNowTm->tm_mday; } } //month if (hasMonthField) { totalTimeTm.tm_mon = month-1; } else { if ((day!=-1 && (day < timeNowTm->tm_mday)) || (day==timeNowTm->tm_mday && hour < timeNowTm->tm_hour) || (day==timeNowTm->tm_mday && hour==timeNowTm->tm_hour && minute < timeNowTm->tm_min)) { totalTimeTm.tm_mon = timeNowTm->tm_mon+1; } else { totalTimeTm.tm_mon = timeNowTm->tm_mon; } } //month if (hasYearField) { totalTimeTm.tm_year = year-1900; } else { if ((month!=-1 && ((month-1) < timeNowTm->tm_mon)) ||((month-1)==timeNowTm->tm_mon && day < timeNowTm->tm_mday) || ((month-1)==timeNowTm->tm_mon && day==timeNowTm->tm_mday && hour < timeNowTm->tm_hour) || ((month-1)==timeNowTm->tm_mon && day==timeNowTm->tm_mday && hour==timeNowTm->tm_hour && minute < timeNowTm->tm_min)) { totalTimeTm.tm_year = timeNowTm->tm_year+1; } else { totalTimeTm.tm_year = timeNowTm->tm_year; } } totalTimeTm.tm_sec = 0; totalTimeTm.tm_isdst = -1; totalTime = std::mktime(&totalTimeTm); return totalTime; }