/**
* \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;
}
/* Returns the n first line of the file to the client application. */
int solveChangeGroup (diet_profile_t* profile) {
std::string localPath, userKey="", acLogin, machineName;
std::string path = "";
std::string host = "";
std::string sessionKey = "";
std::string group = "";
std::string cmd = "";
diet_string_get(profile, 0, sessionKey);
diet_string_get(profile, 1, path);
diet_string_get(profile, 2, host);
diet_string_get(profile, 3, group);
// reset the profile to handle result
diet_profile_reset(profile, 2);
localPath = path;
SessionServer sessionServer (sessionKey);
try {
int mapperkey;
//MAPPER CREATION
Mapper *mapper = MapperRegistry::getInstance()->getMapper(vishnu::FMSMAPPERNAME);
mapperkey = mapper->code("vishnu_chgrp");
mapper->code(group, mapperkey);
mapper->code(host + ":" + path, mapperkey);
cmd = mapper->finalize(mapperkey);
sessionServer.check();
UMS_Data::Machine_ptr machine = new UMS_Data::Machine();
machine->setMachineId(host);
MachineServer machineServer(machine);
// check the machine
machineServer.checkMachine();
machineName = machineServer.getMachineName();
delete machine;
// get the acLogin
acLogin = UserServer(sessionServer).getUserAccountLogin(host);
FileFactory fileFactory;
fileFactory.setSSHServer(machineName);
boost::scoped_ptr<File> file (fileFactory.getFileServer(sessionServer,localPath, acLogin, userKey));
file->chgrp(group);
// set success result
diet_string_set(profile, 0, "success");
diet_string_set(profile, 1, "");
//To register the command
sessionServer.finish(cmd, vishnu::FMS, vishnu::CMDSUCCESS);
} catch (VishnuException& err) {
try {
sessionServer.finish(cmd, vishnu::FMS, vishnu::CMDFAILED);
} catch (VishnuException& fe) {
err.appendMsgComp(fe.what());
}
// set error result
diet_string_set(profile, 0, "error");
diet_string_set(profile, 1, err.what());
}
return 0;
}
/* The function returns all the information about a file:
* - The local owner
* - The local group
* - The local uid & gid
* - The creation, modification and acces time.
* - The file type.
*/
int
solveGetInfos(diet_profile_t* profile) {
std::string path = "";
std::string host = "";
std::string sessionKey = "";
std::string localPath, userKey, machineName;
std::string cmd = "";
std::string fileStatSerialized = "";
diet_string_get(profile, 0, sessionKey);
diet_string_get(profile, 1, path);
diet_string_get(profile, 2, host);
// reset the profile to handle result
diet_profile_reset(profile, 2);
localPath = path;
SessionServer sessionServer (sessionKey);
try {
int mapperkey;
//MAPPER CREATION
Mapper *mapper = MapperRegistry::getInstance()->getMapper(vishnu::FMSMAPPERNAME);
mapperkey = mapper->code("vishnu_stat");
mapper->code(host + ":" + path, mapperkey);
cmd = mapper->finalize(mapperkey);
// check the sessionKey
sessionServer.check();
UMS_Data::Machine_ptr machine = new UMS_Data::Machine();
machine->setMachineId(host);
MachineServer machineServer(machine);
// check the machine
machineServer.checkMachine();
// get the machineName
machineName = machineServer.getMachineName();
delete machine;
std::string acLogin = UserServer(sessionServer).getUserAccountLogin(host);
FileFactory ff;
ff.setSSHServer(machineName);
boost::scoped_ptr<File> file (ff.getFileServer(sessionServer,localPath, acLogin, userKey));
boost::scoped_ptr<FMS_Data::FileStat> fileStat_ptr (new FMS_Data::FileStat());
if ( file->exists()) {
*fileStat_ptr=file->getFileStat();
::ecorecpp::serializer::serializer _ser;
fileStatSerialized = _ser.serialize_str(const_cast<FMS_Data::FileStat_ptr>(fileStat_ptr.get()));
} else {
throw FMSVishnuException(ERRCODE_RUNTIME_ERROR, static_cast<SSHFile*>(file.get())->getErrorMsg());
}
// set success result
diet_string_set(profile, 1, fileStatSerialized);
diet_string_set(profile, 0, "success");
//To register the command
sessionServer.finish(cmd, vishnu::FMS, vishnu::CMDSUCCESS);
} catch (VishnuException& err) {
try {
sessionServer.finish(cmd, vishnu::FMS, vishnu::CMDFAILED);
} catch (VishnuException& fe) {
err.appendMsgComp(fe.what());
}
// set error result
diet_string_set(profile, 0, "error");
diet_string_set(profile, 1, err.what());
}
return 0;
}
/* Returns the n last lines of a file to the client application. */
int solveTailFile(diet_profile_t* profile) {
std::string localPath;
std::string userKey;
std::string acLogin;
std::string machineName;
std::string path = "";
std::string host = "";
std::string sessionKey = "";
std::string optionsSerialized = "";
std::string cmd = "";
diet_string_get(profile, 0, sessionKey);
diet_string_get(profile, 1, path);
diet_string_get(profile, 2, host);
diet_string_get(profile, 3, optionsSerialized);
// reset the profile to handle result
diet_profile_reset(profile, 2);
localPath = path;
SessionServer sessionServer (sessionKey);
try {
sessionServer.check();
//MAPPER CREATION
int mapperkey;
Mapper *mapper = MapperRegistry::getInstance()->getMapper(vishnu::FMSMAPPERNAME);
mapperkey = mapper->code("vishnu_tail_of_file");
mapper->code(host + ":" + path, mapperkey);
mapper->code(optionsSerialized, mapperkey);
cmd = mapper->finalize(mapperkey);
// Check machine
UMS_Data::Machine_ptr machine = new UMS_Data::Machine();
machine->setMachineId(host);
MachineServer machineServer(machine);
machineServer.checkMachine();
machineName = machineServer.getMachineName();
delete machine;
// get the acLogin
acLogin = UserServer(sessionServer).getUserAccountLogin(host);
FileFactory ff;
ff.setSSHServer(machineName);
boost::scoped_ptr<File> file (ff.getFileServer(sessionServer,localPath, acLogin, userKey));
FMS_Data::TailOfFileOptions_ptr options_ptr= NULL;
if(!vishnu::parseEmfObject(optionsSerialized, options_ptr )) {
throw SystemException(ERRCODE_INVDATA, "solve_Tail: TailOfFileOptions object is not well built");
}
// set success result
diet_string_set(profile, 1, file->tail(*options_ptr));
diet_string_set(profile, 0, "success");
delete options_ptr;
//To register the command
sessionServer.finish(cmd, vishnu::FMS, vishnu::CMDSUCCESS);
} catch (VishnuException& err) {
try {
sessionServer.finish(cmd, vishnu::FMS, vishnu::CMDFAILED);
} catch (VishnuException& fe) {
err.appendMsgComp(fe.what());
}
// set error result
diet_string_set(profile, 0, "error");
diet_string_set(profile, 1, err.what());
}
return 0;
}
int
solveTransferFile(diet_profile_t* profile){
std::string srcUserKey = "";
std::string destUser = "";
std::string destMachineName = "";
std::string fileTransferSerialized = "";
std::string errMsg = "";
std::string finishError = "";
std::string srcPath = "";
std::string srcUser = "";
std::string srcHost = "";
std::string sessionKey = "";
std::string dest = "";
std::string optionsSerialized = "";
std::string cmd = "";
diet_string_get(profile, 0, sessionKey);
diet_string_get(profile, 1, srcPath);
diet_string_get(profile, 2, srcHost);
diet_string_get(profile, 3, dest);
diet_string_get(profile, 4, optionsSerialized);
// reset profile to handle result
diet_profile_reset(profile, 2);
std:: string destPath=File::extName(dest);
std:: string destHost=File::extHost(dest);
SessionServer sessionServer (sessionKey);
try {
int mapperkey;
//MAPPER CREATION
Mapper *mapper = MapperRegistry::getInstance()->getMapper(vishnu::FMSMAPPERNAME);
if (transferMode==File::sync){
if(transferType==File::copy){
mapperkey = mapper->code("vishnu_cp");
}
if(transferType==File::move){
mapperkey = mapper->code("vishnu_mv");
}
}
else{
if(transferType==File::copy){
mapperkey = mapper->code("vishnu_acp");
}
if(transferType==File::move){
mapperkey = mapper->code("vishnu_amv");
}
}
mapper->code(srcPath, mapperkey);
mapper->code(dest, mapperkey);
mapper->code(optionsSerialized, mapperkey);
cmd = mapper->finalize(mapperkey);
// check the sessionKey
sessionServer.check();
UMS_Data::Machine_ptr machine = new UMS_Data::Machine();
machine->setMachineId(destHost);
MachineServer machineServer(machine);
// check the machine
if (destHost != "localhost"){
machineServer.checkMachine();
}
// get the machineName
destMachineName = machineServer.getMachineName();
delete machine;
// get the acLogin
if (destHost != "localhost"){
destUser = UserServer(sessionServer).getUserAccountLogin(destHost);
} else {
destUser = destHost;
}
// get the acLogin
if (srcHost != "localhost"){
srcUser = UserServer(sessionServer).getUserAccountLogin(srcHost);
} else {
srcUser = srcHost;
}
FMS_Data::CpFileOptions* options_ptr= NULL;
if(!vishnu::parseEmfObject(optionsSerialized, options_ptr) ) {
throw SystemException(ERRCODE_INVDATA, "solve_Copy: CpFileOptions object is not well built");
}
boost::shared_ptr<FileTransferServer> fileTransferServer = \
boost::make_shared<FileTransferServer>(sessionServer,
srcHost,
destHost,
srcPath,
destPath);
// Perfor the transfer now
if (transferMode == File::sync) {
if (transferType == File::copy) {
fileTransferServer->addCpThread(srcUser,
srcHost,
srcUserKey,
destUser,
destMachineName,
*options_ptr);
}
if (transferType == File::move) {
fileTransferServer->addMvThread(srcUser,
srcHost,
srcUserKey,
destUser,
destMachineName,
*options_ptr);
}
}
else{
if(transferType==File::copy){
fileTransferServer->addCpAsyncThread(srcUser,
srcHost,
srcUserKey,
destUser,
destMachineName,
*options_ptr);
}
if (transferType==File::move){
fileTransferServer->addMvAsyncThread(srcUser,
srcHost,
srcUserKey,
destUser,
destMachineName,
*options_ptr);
}
}
FMS_Data::FMS_DataFactory_ptr ecoreFactory = FMS_Data::FMS_DataFactory::_instance();
FMS_Data::FileTransfer_ptr fileTransfer=ecoreFactory->createFileTransfer();
*fileTransfer= fileTransferServer->getFileTransfer();
delete fileTransfer;
::ecorecpp::serializer::serializer _ser;
fileTransferSerialized = _ser.serialize_str(const_cast<FMS_Data::FileTransfer_ptr>(fileTransfer));
//To register the command
sessionServer.finish(cmd, vishnu::FMS, vishnu::CMDSUCCESS);
} catch (VishnuException& err) {
try {
sessionServer.finish(cmd, vishnu::FMS, vishnu::CMDFAILED);
} catch (VishnuException& fe) {
finishError = fe.what();
finishError +="\n";
}
err.appendMsgComp(finishError);
errMsg = err.buildExceptionString();
}
if (errMsg.empty()){
diet_string_set(profile, 0, "success");
diet_string_set(profile, 1, fileTransferSerialized.c_str());
} else {
diet_string_set(profile, 0, "error");
diet_string_set(profile, 1, errMsg);
}
return 0;
}