From 8e199c2a3c3bff4d3afa4997b08c82c9e31e5e1d Mon Sep 17 00:00:00 2001 From: Ovidiu Mircescu Date: Tue, 11 Jul 2017 11:42:21 +0200 Subject: [PATCH] Add a generic widget for choosing resource parameters. --- src/evalyfx/YACSEvalResource.hxx | 4 + src/evalyfx/YACSEvalYFXPattern.cxx | 42 +++- src/evalyfx/YACSEvalYFXPattern.hxx | 3 + src/py2yacs/Test/CTestTestfileInstall.cmake | 3 +- src/py2yacs/py2yacs.cxx | 1 + src/ydfx_gui/AbstractResourceModel.cxx | 37 +++ src/ydfx_gui/AbstractResourceModel.hxx | 49 ++++ src/ydfx_gui/CMakeLists.txt | 9 + src/ydfx_gui/ResourceWidget.cxx | 262 ++++++++++++++++++++ src/ydfx_gui/ResourceWidget.hxx | 38 +++ src/ydfx_gui/SalomeResourceModel.cxx | 198 +++++++++++++++ src/ydfx_gui/SalomeResourceModel.hxx | 46 ++++ src/ydfx_gui/YDFXResourceModel.cxx | 222 +++++++++++++++++ src/ydfx_gui/YDFXResourceModel.hxx | 63 +++++ 14 files changed, 974 insertions(+), 3 deletions(-) create mode 100644 src/ydfx_gui/AbstractResourceModel.cxx create mode 100644 src/ydfx_gui/AbstractResourceModel.hxx create mode 100644 src/ydfx_gui/ResourceWidget.cxx create mode 100644 src/ydfx_gui/ResourceWidget.hxx create mode 100644 src/ydfx_gui/SalomeResourceModel.cxx create mode 100644 src/ydfx_gui/SalomeResourceModel.hxx create mode 100644 src/ydfx_gui/YDFXResourceModel.cxx create mode 100644 src/ydfx_gui/YDFXResourceModel.hxx diff --git a/src/evalyfx/YACSEvalResource.hxx b/src/evalyfx/YACSEvalResource.hxx index e66dfb933..02939e26d 100644 --- a/src/evalyfx/YACSEvalResource.hxx +++ b/src/evalyfx/YACSEvalResource.hxx @@ -26,6 +26,7 @@ #include #include #include +#include #ifdef WIN32 #define NOMINMAX @@ -147,6 +148,8 @@ public: void setNbProcs(unsigned int nbProcs) { _nbOfProcs=nbProcs; } void setMaxDuration(const std::string& maxDuration) { _maxDuration=maxDuration; } std::string getMaxDuration() const { return _maxDuration; } + std::list& getInFiles(){ return _in_files;} + const std::list& getInFiles()const { return _in_files;} YACSEVALYFX_EXPORT void checkConsistency() const; private: bool _exclusiveness; @@ -155,6 +158,7 @@ private: std::string _wcKey; std::string _maxDuration; unsigned int _nbOfProcs; + std::list _in_files; }; class YACSEvalListOfResources : public YACSEvalNonConstLocker diff --git a/src/evalyfx/YACSEvalYFXPattern.cxx b/src/evalyfx/YACSEvalYFXPattern.cxx index 43b6b6b9d..0f10f58f0 100644 --- a/src/evalyfx/YACSEvalYFXPattern.cxx +++ b/src/evalyfx/YACSEvalYFXPattern.cxx @@ -429,6 +429,11 @@ YACS::ENGINE::Proc *YACSEvalYFXRunOnlyPattern::getUndergroundGeneratedGraph() co std::string YACSEvalYFXRunOnlyPattern::getErrorDetailsInCaseOfFailure() const { + std::string generatorErrors = getGenerator()->getErrors(); + if(generatorErrors.size() > 0) + { + return generatorErrors; + } std::string st(getStatusOfRunStr());//test if a run has occurred. if(st==ST_OK) throw YACS::Exception("YACSEvalYFXRunOnlyPattern::getErrorDetailsInCaseOfFailure : The execution of scheme has been carried out to the end without any problem !"); @@ -830,6 +835,11 @@ bool YACSEvalYFXGraphGenInteractive::go(const YACSEvalExecParams& params, YACSEv return getUndergroundGeneratedGraph()->getState()==YACS::DONE; } +std::string YACSEvalYFXGraphGenInteractive::getErrors()const +{ + return ""; +} + std::vector YACSEvalYFXGraphGenInteractive::getResults() const { if(getUndergroundGeneratedGraph()->getState()!=YACS::DONE) @@ -959,6 +969,7 @@ void YACSEvalYFXGraphGenCluster::generateGraph() bool YACSEvalYFXGraphGenCluster::go(const YACSEvalExecParams& params, YACSEvalSession *session) const { YACS::ENGINE::AutoGIL agil; + _errors = ""; getUndergroundGeneratedGraph()->saveSchema(_locSchemaFile); YACSEvalListOfResources *rss(getBoss()->getResourcesInternal()); const YACSEvalParamsForCluster& cli(rss->getAddParamsForCluster()); @@ -985,7 +996,15 @@ bool YACSEvalYFXGraphGenCluster::go(const YACSEvalExecParams& params, YACSEvalSe jp.job_type=CORBA::string_dup("yacs_file"); jp.job_file=CORBA::string_dup(_locSchemaFile.c_str()); jp.env_file=CORBA::string_dup(""); - jp.in_files.length(0); + jp.in_files.length(cli.getInFiles().size()); + std::list::const_iterator it; + int i; + for (it = cli.getInFiles().begin(), i=0 ; + it != cli.getInFiles().end(); + it++, i++) + { + jp.in_files[i] = CORBA::string_dup((*it).c_str()); + } jp.out_files.length(1); jp.out_files[0]=CORBA::string_dup(_jobName.c_str()); jp.work_directory=CORBA::string_dup(cli.getRemoteWorkingDir().c_str()); @@ -1002,7 +1021,21 @@ bool YACSEvalYFXGraphGenCluster::go(const YACSEvalExecParams& params, YACSEvalSe jp.launcher_file=CORBA::string_dup(""); jp.launcher_args=CORBA::string_dup(""); _jobid=sl->createJob(jp); - sl->launchJob(_jobid); + try + { + sl->launchJob(_jobid); + } + catch (const SALOME::SALOME_Exception & ex) + { + _errors = ex.details.text.in(); + return false; + } + catch (const CORBA::SystemException& ex) + { + _errors = "Receive CORBA SystemException."; + return false; + } + bool ret(false); while(true) { @@ -1064,6 +1097,11 @@ bool YACSEvalYFXGraphGenCluster::go(const YACSEvalExecParams& params, YACSEvalSe return ret; } +std::string YACSEvalYFXGraphGenCluster::getErrors()const +{ + return _errors; +} + std::vector YACSEvalYFXGraphGenCluster::getResults() const { std::size_t sz(_res.size()); diff --git a/src/evalyfx/YACSEvalYFXPattern.hxx b/src/evalyfx/YACSEvalYFXPattern.hxx index d67e3ca82..39a56ff45 100644 --- a/src/evalyfx/YACSEvalYFXPattern.hxx +++ b/src/evalyfx/YACSEvalYFXPattern.hxx @@ -163,6 +163,7 @@ public: virtual void generateGraph() = 0; virtual bool go(const YACSEvalExecParams& params, YACSEvalSession *session) const = 0; virtual std::vector getResults() const = 0; + virtual std::string getErrors()const = 0; bool isLocked() const; int assignNbOfBranches(); void resetGeneratedGraph(); @@ -186,6 +187,7 @@ public: void generateGraph(); bool go(const YACSEvalExecParams& params, YACSEvalSession *session) const; std::vector getResults() const; + virtual std::string getErrors()const; }; class YACSEvalYFXGraphGenCluster : public YACSEvalYFXGraphGen @@ -195,6 +197,7 @@ public: void generateGraph(); bool go(const YACSEvalExecParams& params, YACSEvalSession *session) const; std::vector getResults() const; + virtual std::string getErrors()const; private: std::string _locSchemaFile; std::string _jobName; diff --git a/src/py2yacs/Test/CTestTestfileInstall.cmake b/src/py2yacs/Test/CTestTestfileInstall.cmake index 808eefd43..a98d11d52 100644 --- a/src/py2yacs/Test/CTestTestfileInstall.cmake +++ b/src/py2yacs/Test/CTestTestfileInstall.cmake @@ -20,7 +20,8 @@ IF(NOT WIN32) SET(TEST_NAME ${COMPONENT_NAME}_Py2YacsTest) # No need of a salome session for this test - ADD_TEST(${TEST_NAME} TestPy2yacs) + ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ./TestPy2yacs) + #ADD_TEST(${TEST_NAME} TestPy2yacs) SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}" ) diff --git a/src/py2yacs/py2yacs.cxx b/src/py2yacs/py2yacs.cxx index 0f4a6e1f2..5789ef408 100644 --- a/src/py2yacs/py2yacs.cxx +++ b/src/py2yacs/py2yacs.cxx @@ -380,5 +380,6 @@ YACS::ENGINE::Proc* Py2yacs::createProc(const std::string& python_function)const node->edAddOutputPort(*it, tc_double); node->setExecutionMode(YACS::ENGINE::InlineNode::REMOTE_STR); + node->setContainer(schema->containerMap["DefaultContainer"]); return schema; } \ No newline at end of file diff --git a/src/ydfx_gui/AbstractResourceModel.cxx b/src/ydfx_gui/AbstractResourceModel.cxx new file mode 100644 index 000000000..b47e865bd --- /dev/null +++ b/src/ydfx_gui/AbstractResourceModel.cxx @@ -0,0 +1,37 @@ +#include "AbstractResourceModel.hxx" +#include +#include + +AbstractResourceModel::AbstractResourceModel() +{ +} + +AbstractResourceModel::~AbstractResourceModel() +{ +} + +std::string AbstractResourceModel::getMaxDuration()const +{ + int hours = getMaxDurationHours(); + int minutes = getMaxDurationMinutes(); + if(hours<0) + hours = 0; + if(hours>99) + hours = 99; + if(minutes<0) + minutes = 5; + if(minutes > 59) + minutes = 59; + std::stringstream ss; + // hours=0 && minutes=0 => use default values + if(hours > 0 || minutes > 0) + { + if(hours<10) + ss << "0"; + ss << hours << ":"; + if(minutes<10) + ss << "0"; + ss << minutes; + } + return ss.str(); +} diff --git a/src/ydfx_gui/AbstractResourceModel.hxx b/src/ydfx_gui/AbstractResourceModel.hxx new file mode 100644 index 000000000..6602b8557 --- /dev/null +++ b/src/ydfx_gui/AbstractResourceModel.hxx @@ -0,0 +1,49 @@ +#ifndef ABSTRACTRESOURCEMODEL_HXX +#define ABSTRACTRESOURCEMODEL_HXX + +#include +#include +#include +#include "ydfxwidgetsExport.hxx" + +class YDFXWIDGETS_EXPORT AbstractResourceModel +{ +public: + + AbstractResourceModel(); + virtual ~AbstractResourceModel(); + + virtual bool getParallelizeStatus()const =0; + virtual void setParallelizeStatus(bool v)=0; + + virtual std::string getRemoteDir()const =0; + virtual std::string getDefaultRemoteDir(std::string machine)const =0; + virtual void setRemoteDir(const std::string& v)=0; + + virtual std::string getLocalDir()const =0; + virtual void setLocalDir(const std::string& v)=0; + + virtual std::string getWckey()const =0; + virtual void setWckey(const std::string& v)=0; + + virtual int getMaxDurationMinutes()const =0; + virtual void setMaxDurationMinutes(int v)=0; + + virtual int getMaxDurationHours()const =0; + virtual void setMaxDurationHours(int v)=0; + std::string getMaxDuration()const ; + + virtual unsigned int getNbprocs()const =0; + virtual void setNbprocs(unsigned int v)=0; + + virtual std::string getWantedMachine()const =0; + virtual void setWantedMachine(const std::string& v)=0; + virtual std::vector getFittingMachines()const =0; + + virtual const std::list& getInFiles()const =0; + virtual std::list& getInFiles() =0; + + virtual bool isMachineInteractive(const std::string& machine)const =0; +}; + +#endif // ABSTRACTRESOURCEMODEL_HXX diff --git a/src/ydfx_gui/CMakeLists.txt b/src/ydfx_gui/CMakeLists.txt index f8378fb22..54e408cb8 100644 --- a/src/ydfx_gui/CMakeLists.txt +++ b/src/ydfx_gui/CMakeLists.txt @@ -71,6 +71,7 @@ SET(_moc_HEADERS YDFXGUISeqInit.hxx YDFXGUIParametrizer.hxx YDFXGUIHostParametrizer.hxx + ResourceWidget.hxx ) # sources / moc wrappings @@ -87,6 +88,10 @@ SET(ydfxwidgets_HEADERS YDFXGUIPyThreadSaver.hxx YDFXGUISeqInit.hxx YDFXGUIWrap.hxx + ResourceWidget.hxx + AbstractResourceModel.hxx + YDFXResourceModel.hxx + SalomeResourceModel.hxx ) SET(ydfxwidgets_SOURCES @@ -99,6 +104,10 @@ SET(ydfxwidgets_SOURCES YDFXGUIPyThreadSaver.cxx YDFXGUISeqInit.cxx YDFXGUIWrap.cxx + YDFXResourceModel.cxx + ResourceWidget.cxx + SalomeResourceModel.cxx + AbstractResourceModel.cxx ${_moc_SOURCES} ) diff --git a/src/ydfx_gui/ResourceWidget.cxx b/src/ydfx_gui/ResourceWidget.cxx new file mode 100644 index 000000000..ecb36745d --- /dev/null +++ b/src/ydfx_gui/ResourceWidget.cxx @@ -0,0 +1,262 @@ +#include "ResourceWidget.hxx" + +ResourceWidget::ResourceWidget(AbstractResourceModel* model, QWidget* parent) +: QWidget(parent), + _model(model), + _clusterBox(0), + _localdirEdit(0) +{ + QVBoxLayout *mainLayout = new QVBoxLayout(); + setLayout(mainLayout); + QGroupBox *resourcesBox = new QGroupBox(); + resourcesBox->setTitle(tr("Launching parameters")); + mainLayout->addWidget(resourcesBox); + QGridLayout *resourcesLayout = new QGridLayout(); + resourcesBox->setLayout(resourcesLayout); + + QCheckBox *parallelizeStatusCheckBox = new QCheckBox(tr("Parallelize status")); + parallelizeStatusCheckBox->setChecked(_model->getParallelizeStatus()); + connect(parallelizeStatusCheckBox, SIGNAL(toggled(bool)), + this, SLOT(updateParallelizeStatus(bool))); + resourcesLayout->addWidget(parallelizeStatusCheckBox, 0, 0); + + QLabel * resourcesLabel = new QLabel(tr("Computing resource:")); + resourcesLayout->addWidget(resourcesLabel, 1, 0); + + QComboBox* resourcesComboBox = new QComboBox; + std::vector resources = _model->getFittingMachines(); + std::vector::const_iterator it; + for(it=resources.begin(); it!=resources.end(); it++) + resourcesComboBox->addItem(QString(it->c_str())); + resourcesLayout->addWidget(resourcesComboBox, 1, 1); + + _clusterBox = createClusterWidgets(); + mainLayout->addWidget(_clusterBox); + + resourcesComboBox->setCurrentIndex( + resourcesComboBox->findText(model->getWantedMachine().c_str())); + + connect(resourcesComboBox, SIGNAL(currentIndexChanged( const QString &)), + this, SLOT(updateWantedMachine( const QString &))); + + _clusterBox->setVisible(!model->isMachineInteractive( + model->getWantedMachine())); +} + +ResourceWidget::~ResourceWidget() +{ +} + +QWidget * ResourceWidget::createClusterWidgets() +{ + // Infos for clusters + QGroupBox *clusterBox = new QGroupBox(); + QGridLayout *groupLayout = new QGridLayout; + clusterBox->setLayout(groupLayout); + clusterBox->setTitle(tr("Specific parameters for clusters")); + QHBoxLayout *hLayout; + int pos = 0; + + QLabel *nbprocLabel = new QLabel(); + QSpinBox *nbprocEdit = new QSpinBox(); + nbprocLabel->setText(tr("Number of processes")); + nbprocEdit->setRange(1, 10000); + groupLayout->addWidget(nbprocLabel, pos, 0); + groupLayout->addWidget(nbprocEdit, pos++, 1); + connect(nbprocEdit, SIGNAL(valueChanged(int)), this, SLOT(updateNbprocs(int))); + nbprocEdit->setValue(_model->getNbprocs()); + + QLabel *remotedirLabel = new QLabel(); + _remotedirEdit = new QLineEdit(); + remotedirLabel->setText(tr("Remote working directory")); + groupLayout->addWidget(remotedirLabel, pos, 0); + groupLayout->addWidget(_remotedirEdit, pos++, 1); + connect(_remotedirEdit, SIGNAL(textEdited(const QString &)), + this, SLOT(updateRemoteDir(const QString &))); + _remotedirEdit->setText(_model->getRemoteDir().c_str()); + + QLabel *localdirLabel = new QLabel(); + _localdirEdit = new QLineEdit(); + QPushButton* localdirButton = new QPushButton("..."); + + localdirLabel->setText(tr("Local result directory")); + groupLayout->addWidget(localdirLabel, pos, 0); + groupLayout->addWidget(_localdirEdit, pos, 1); + groupLayout->addWidget(localdirButton, pos++, 2); + connect(_localdirEdit, SIGNAL(textEdited(const QString &)), + this, SLOT(updateLocalDir(const QString &))); + connect(localdirButton,SIGNAL(clicked()),this, SLOT(onChoseLocaldir())); + _localdirEdit->setText(_model->getLocalDir().c_str()); + + QLabel *wckeyLabel = new QLabel(); + QLineEdit *wckeyEdit = new QLineEdit(); + wckeyLabel->setText(tr("Working Characterization Key")); + groupLayout->addWidget(wckeyLabel, pos, 0); + groupLayout->addWidget(wckeyEdit, pos++, 1); + connect(wckeyEdit, SIGNAL(textEdited(const QString &)), + this, SLOT(updateWckey(const QString &))); + wckeyEdit->setText(_model->getWckey().c_str()); + + hLayout = new QHBoxLayout(); + QLabel *timeLabel = new QLabel(); + QLabel *hoursLabel = new QLabel(); + QLabel *minutesLabel = new QLabel(); + QSpinBox *hoursEdit = new QSpinBox(); + QSpinBox *minutesEdit = new QSpinBox(); + hoursEdit->setRange(0, 99); + minutesEdit->setRange(0,59); + timeLabel->setText(tr("Time limit (0:0 for default values):")); + hoursLabel->setText(tr("hours")); + minutesLabel->setText(tr("minutes")); + hLayout->addWidget(hoursEdit); + hLayout->addWidget(hoursLabel); + hLayout->addWidget(minutesEdit); + hLayout->addWidget(minutesLabel); + groupLayout->addWidget(timeLabel, pos, 0); + groupLayout->addLayout(hLayout, pos++, 1); + + hoursEdit->setValue(_model->getMaxDurationHours()); + minutesEdit->setValue(_model->getMaxDurationMinutes()); + connect(hoursEdit, SIGNAL(valueChanged(int)), + this, SLOT(updateMaxHours(int))); + connect(minutesEdit, SIGNAL(valueChanged(int)), + this, SLOT(updateMaxMinutes(int))); + + QGroupBox * inputFilesBox = new QGroupBox; + inputFilesBox->setTitle(tr("Input files")); + QHBoxLayout *inputFilesLayout = new QHBoxLayout; + inputFilesBox->setLayout(inputFilesLayout); + _inputFilesList = new QListWidget; + _inputFilesList->setSelectionMode(QAbstractItemView::MultiSelection); + QVBoxLayout *inputButtonsLayout = new QVBoxLayout; + QPushButton *addInputFilesButton = new QPushButton(tr("+")); + _removeInputFilesButton = new QPushButton(tr("-")); + inputButtonsLayout->addWidget(addInputFilesButton); + inputButtonsLayout->addWidget(_removeInputFilesButton); + inputFilesLayout->addWidget(_inputFilesList); + inputFilesLayout->addLayout(inputButtonsLayout); + groupLayout->addWidget(inputFilesBox, pos++, 0, 1, -1); + _removeInputFilesButton->setEnabled(false); + connect(_inputFilesList, SIGNAL(itemSelectionChanged()), + this, SLOT(inputSelectionChanged())); + connect(addInputFilesButton, SIGNAL(clicked()), + this, SLOT(addInputFiles())); + connect(_removeInputFilesButton, SIGNAL(clicked()), + this, SLOT(removeInputFiles())); + return clusterBox; +} + +void ResourceWidget::updateParallelizeStatus(bool v) +{ + _model->setParallelizeStatus(v); +} + +void ResourceWidget::updateWantedMachine( const QString& v) +{ + _model->setWantedMachine(v.toStdString()); + bool isRemote = !_model->isMachineInteractive(v.toStdString()); + _clusterBox->setVisible(isRemote); + if(isRemote) + { + std::string defaultValue = _model->getDefaultRemoteDir(v.toStdString()); + _remotedirEdit->setText(defaultValue.c_str()); + _model->setRemoteDir(defaultValue); + } +} + +void ResourceWidget::updateNbprocs(int v) +{ + _model->setNbprocs(v); +} + +void ResourceWidget::updateRemoteDir(const QString &v) +{ + _model->setRemoteDir(v.toStdString()); +} + +void ResourceWidget::updateLocalDir(const QString &v) +{ + _model->setLocalDir(v.toStdString()); +} + +void ResourceWidget::updateWckey(const QString &v) +{ + _model->setWckey(v.toStdString()); +} + +void ResourceWidget::updateMaxHours(int v) +{ + _model->setMaxDurationHours(v); +} + +void ResourceWidget::updateMaxMinutes(int v) +{ + _model->setMaxDurationMinutes(v); +} + +void ResourceWidget::onChoseLocaldir() +{ + QString dir; + dir = QFileDialog::getExistingDirectory(this, + tr("Choose local result directory"), + "", + QFileDialog::ShowDirsOnly + | QFileDialog::DontResolveSymlinks); + + if (dir != "") + { + _model->setLocalDir(dir.toStdString()); + _localdirEdit->setText(dir); + } +} + +void ResourceWidget::inputSelectionChanged() +{ + bool canRemove = (_inputFilesList->selectedItems().size() > 0); + _removeInputFilesButton->setEnabled(canRemove); +} + +void ResourceWidget::addInputFiles() +{ + // We need to be able to select both files and folders. + // Standard QFileDialog cannot do it. + QFileDialog w(this, tr("Select input files"), + "", tr("All files and folders(*)")) ; + w.setOption(QFileDialog::DontUseNativeDialog,true); + QListView *l = w.findChild("listView"); + if (l) + { + l->setSelectionMode(QAbstractItemView::MultiSelection); + } + QTreeView *t = w.findChild(); + if (t) + { + t->setSelectionMode(QAbstractItemView::MultiSelection); + } + if(w.exec()) + { + QStringList fileNames = w.selectedFiles(); + for (int i = 0; i < fileNames.size(); ++i) + { + QString fileName = fileNames.at(i); + if (_inputFilesList->findItems(fileName,Qt::MatchFixedString).size() == 0) + { + _model->getInFiles().push_back(fileName.toStdString()); + _inputFilesList->addItem(fileName); + } + } + } +} + +void ResourceWidget::removeInputFiles() +{ + QList list = _inputFilesList->selectedItems(); + for (int i = 0; i < list.size(); ++i) + { + int row = _inputFilesList->row( list.at(i) ); + QListWidgetItem * item = _inputFilesList->takeItem(row); + std::string itemName = item->text().toStdString(); + _model->getInFiles().remove(itemName); + delete item; + } +} diff --git a/src/ydfx_gui/ResourceWidget.hxx b/src/ydfx_gui/ResourceWidget.hxx new file mode 100644 index 000000000..8c7124979 --- /dev/null +++ b/src/ydfx_gui/ResourceWidget.hxx @@ -0,0 +1,38 @@ +#ifndef RESOURCEWIDGET_HXX +#define RESOURCEWIDGET_HXX + +#include +#include "AbstractResourceModel.hxx" + +class YDFXWIDGETS_EXPORT ResourceWidget: public QWidget +{ + Q_OBJECT + public: + ResourceWidget(AbstractResourceModel* model, QWidget* parent=0); + virtual ~ResourceWidget(); + + public slots: + virtual void updateParallelizeStatus(bool v); + virtual void updateWantedMachine( const QString& v); + virtual void updateNbprocs(int v); + virtual void updateRemoteDir(const QString &v); + virtual void updateLocalDir(const QString &v); + virtual void updateWckey(const QString &v); + virtual void updateMaxHours(int v); + virtual void updateMaxMinutes(int v); + virtual void onChoseLocaldir(); + virtual void inputSelectionChanged(); + virtual void addInputFiles(); + virtual void removeInputFiles(); + private: + QWidget * createClusterWidgets(); + private: + AbstractResourceModel* _model; + QWidget * _clusterBox; + QLineEdit * _localdirEdit; + QLineEdit * _remotedirEdit; + QListWidget * _inputFilesList; + QPushButton *_removeInputFilesButton; +}; + +#endif // RESOURCEWIDGET_HXX diff --git a/src/ydfx_gui/SalomeResourceModel.cxx b/src/ydfx_gui/SalomeResourceModel.cxx new file mode 100644 index 000000000..12d89eab9 --- /dev/null +++ b/src/ydfx_gui/SalomeResourceModel.cxx @@ -0,0 +1,198 @@ +#include "SalomeResourceModel.hxx" +#include "RuntimeSALOME.hxx" +#include "SALOME_ResourcesManager.hxx" +#include "SALOME_LifeCycleCORBA.hxx" +#include + +SalomeResourceModel::SalomeResourceModel() +: AbstractResourceModel(), + _wantedMachine("localhost"), + _nbProcs(1), + _hours(0), + _minutes(0), + _wcKey(""), + _localDirectory("/tmp"), + _remoteDirectory("/tmp"), + _parallelizeStatus(true), + _in_files() +{ +} + +SalomeResourceModel::~SalomeResourceModel() +{ +} + +bool SalomeResourceModel::isMachineInteractive(const std::string& machine)const +{ + return !machine.compare("localhost"); +} + +std::vector< std::string > SalomeResourceModel::getFittingMachines()const +{ + std::vector< std::string > resultat; + YACS::ENGINE::RuntimeSALOME* runTime = YACS::ENGINE::getSALOMERuntime(); + CORBA::ORB_ptr orb = runTime->getOrb(); + if (!orb) return resultat; + + SALOME_NamingService namingService(orb); + SALOME_LifeCycleCORBA lcc(&namingService); + + CORBA::Object_var obj; + obj=namingService.Resolve(SALOME_ResourcesManager::_ResourcesManagerNameInNS); + if (CORBA::is_nil(obj)) return resultat; + + Engines::ResourcesManager_var resManager; + resManager = Engines::ResourcesManager::_narrow(obj); + if(!resManager) return resultat; + + Engines::ResourceParameters params; + lcc.preSet(params); + + Engines::ResourceList* resourceList = resManager->GetFittingResources(params); + + for (int i = 0; i < resourceList->length(); i++) + { + const char* aResource = (*resourceList)[i]; + resultat.push_back(aResource); + } + return resultat; +} + +void SalomeResourceModel::setWantedMachine(const std::string& v) +{ + _wantedMachine = v; +} + +std::string SalomeResourceModel::getWantedMachine()const +{ + return _wantedMachine; +} + +void SalomeResourceModel::setNbprocs(unsigned int v) +{ + _nbProcs = v; +} + +unsigned int SalomeResourceModel::getNbprocs()const +{ + return _nbProcs; +} + +void SalomeResourceModel::setMaxDurationHours(int v) +{ + _hours = v; +} + +int SalomeResourceModel::getMaxDurationHours()const +{ + return _hours; +} + +void SalomeResourceModel::setMaxDurationMinutes(int v) +{ + _minutes = v; +} + +int SalomeResourceModel::getMaxDurationMinutes()const +{ + return _minutes; +} + +void SalomeResourceModel::setWckey(const std::string& v) +{ + _wcKey = v; +} + +std::string SalomeResourceModel::getWckey()const +{ + return _wcKey; +} + +void SalomeResourceModel::setLocalDir(const std::string& v) +{ + _localDirectory = v; +} + +std::string SalomeResourceModel::getLocalDir()const +{ + return _localDirectory; +} + +void SalomeResourceModel::setRemoteDir(const std::string& v) +{ + _remoteDirectory = v; +} + +std::string SalomeResourceModel::getRemoteDir()const +{ + return _remoteDirectory; +} + +std::string SalomeResourceModel::getDefaultRemoteDir(std::string machine)const +{ + std::string result = ""; + YACS::ENGINE::RuntimeSALOME* runTime = YACS::ENGINE::getSALOMERuntime(); + CORBA::ORB_ptr orb = runTime->getOrb(); + if (!orb) return result; + + SALOME_NamingService namingService(orb); + SALOME_LifeCycleCORBA lcc(&namingService); + + CORBA::Object_var obj; + obj=namingService.Resolve(SALOME_ResourcesManager::_ResourcesManagerNameInNS); + if (CORBA::is_nil(obj)) return result; + + Engines::ResourcesManager_var resManager; + resManager = Engines::ResourcesManager::_narrow(obj); + if(!resManager) return result; + + Engines::ResourceParameters params; + lcc.preSet(params); + + try + { + Engines::ResourceDefinition * rd; + rd = resManager->GetResourceDefinition(machine.c_str()); + result = rd->working_directory.in(); + if (result != "") + { + time_t rawtime; + time(&rawtime); + std::string launch_date = ctime(&rawtime); + for (int i = 0; i < launch_date.size(); i++) + if (launch_date[i] == '/' || + launch_date[i] == '-' || + launch_date[i] == ':' || + launch_date[i] == ' ') + launch_date[i] = '_'; + launch_date.erase(--launch_date.end()); // Last caracter is a \n + result += "/run_"; + result += launch_date; + } + } + catch (...) + { + } + + return result; +} + +void SalomeResourceModel::setParallelizeStatus(bool v) +{ + _parallelizeStatus = v; +} + +bool SalomeResourceModel::getParallelizeStatus()const +{ + return _parallelizeStatus; +} + +const std::list& SalomeResourceModel::getInFiles()const +{ + return _in_files; +} + +std::list& SalomeResourceModel::getInFiles() +{ + return _in_files; +} diff --git a/src/ydfx_gui/SalomeResourceModel.hxx b/src/ydfx_gui/SalomeResourceModel.hxx new file mode 100644 index 000000000..5af3568b4 --- /dev/null +++ b/src/ydfx_gui/SalomeResourceModel.hxx @@ -0,0 +1,46 @@ +#ifndef SALOMERESOURCEMODEL_HXX +#define SALOMERESOURCEMODEL_HXX + +#include "AbstractResourceModel.hxx" + + +class YDFXWIDGETS_EXPORT SalomeResourceModel : public AbstractResourceModel +{ +public: + SalomeResourceModel(); + ~SalomeResourceModel(); + virtual bool isMachineInteractive(const std::string& machine)const; + virtual std::vector< std::string > getFittingMachines()const; + virtual void setWantedMachine(const std::string& v); + virtual std::string getWantedMachine()const; + virtual void setNbprocs(unsigned int v); + virtual unsigned int getNbprocs()const; + virtual void setMaxDurationHours(int v); + virtual int getMaxDurationHours()const; + virtual void setMaxDurationMinutes(int v); + virtual int getMaxDurationMinutes()const; + virtual void setWckey(const std::string& v); + virtual std::string getWckey()const; + virtual void setLocalDir(const std::string& v); + virtual std::string getLocalDir()const; + virtual void setRemoteDir(const std::string& v); + virtual std::string getRemoteDir()const; + virtual std::string getDefaultRemoteDir(std::string machine)const; + virtual void setParallelizeStatus(bool v); + virtual bool getParallelizeStatus()const; + virtual const std::list& getInFiles()const; + virtual std::list& getInFiles(); + +private: + std::string _wantedMachine; + unsigned int _nbProcs; + int _hours; + int _minutes; + std::string _wcKey; + std::string _localDirectory; + std::string _remoteDirectory; + bool _parallelizeStatus; + std::list _in_files; +}; + +#endif // SALOMERESOURCEMODEL_HXX diff --git a/src/ydfx_gui/YDFXResourceModel.cxx b/src/ydfx_gui/YDFXResourceModel.cxx new file mode 100644 index 000000000..4ac1ef37c --- /dev/null +++ b/src/ydfx_gui/YDFXResourceModel.cxx @@ -0,0 +1,222 @@ +#include "YDFXResourceModel.hxx" + +#include "YACSEvalYFX.hxx" +#include "YACSEvalResource.hxx" +//#include "ResourcesManager.hxx" + +#include +#include +#include + +YDFXResourceModel::YDFXResourceModel(YACSEvalYFX* eval) +: AbstractResourceModel(), + _eval(eval) +{ +} + +YDFXResourceModel::~YDFXResourceModel() +{ +} + +bool YDFXResourceModel::getParallelizeStatus()const +{ + return _eval->getParallelizeStatus(); +} + +void YDFXResourceModel::setParallelizeStatus(bool v) +{ + _eval->setParallelizeStatus(v); +} + +std::string YDFXResourceModel::getRemoteDir()const +{ + return getClusterParams().getRemoteWorkingDir(); +} + +void YDFXResourceModel::setRemoteDir(const std::string& v) +{ + getClusterParams().setRemoteWorkingDir(v); +} + +std::string YDFXResourceModel::getDefaultRemoteDir(std::string machine)const +{ + return "/tmp"; +} + +std::string YDFXResourceModel::getLocalDir()const +{ + return getClusterParams().getLocalWorkingDir(); +} + +void YDFXResourceModel::setLocalDir(const std::string& v) +{ + getClusterParams().setLocalWorkingDir(v); +} + +std::string YDFXResourceModel::getWckey()const +{ + return getClusterParams().getWCKey(); +} + +void YDFXResourceModel::setWckey(const std::string& v) +{ + getClusterParams().setWCKey(v); +} + +int YDFXResourceModel::getMaxDurationMinutes()const +{ + int minutes; + int hours; + getMaxDuration(hours, minutes); + return minutes; +} + +void YDFXResourceModel::setMaxDurationMinutes(int v) +{ + int minutes; + int hours; + getMaxDuration(hours, minutes); + setMaxDuration(hours, v); +} + +int YDFXResourceModel::getMaxDurationHours()const +{ + int minutes; + int hours; + getMaxDuration(hours, minutes); + return hours; +} + +void YDFXResourceModel::setMaxDurationHours(int v) +{ + int minutes; + int hours; + getMaxDuration(hours, minutes); + setMaxDuration(v, minutes); +} + +unsigned int YDFXResourceModel::getNbprocs()const +{ + return getClusterParams().getNbProcs(); +} + +void YDFXResourceModel::setNbprocs(unsigned int v) +{ + getClusterParams().setNbProcs(v); +} + +std::string YDFXResourceModel::getWantedMachine()const +{ + const std::string default_machine("localhost"); + std::vector chosenMachines = resources()->getAllChosenMachines(); + std::vector fittingMachines = resources()->getAllFittingMachines(); + std::string wantedMachine=""; + std::vector::const_iterator it; + bool foundMachine = false; + it = chosenMachines.begin(); + // take the first chosen machine which is also fitting. + while(!foundMachine && it!=chosenMachines.end()) + { + if(std::find(fittingMachines.begin(), fittingMachines.end(), *it) + != fittingMachines.end()) + { + foundMachine = true; + wantedMachine = *it; + } + } + if(!foundMachine) + { + // take localhost if fitting + if(std::find(fittingMachines.begin(), fittingMachines.end(), + default_machine) != fittingMachines.end()) + { + foundMachine = true; + wantedMachine = default_machine; + } + else if(fittingMachines.size() > 0) + { + foundMachine = true; + wantedMachine = fittingMachines[0]; + } + } + +} + +void YDFXResourceModel::setWantedMachine(const std::string& v) +{ + resources()->setWantedMachine(v); +} + +std::vector YDFXResourceModel::getFittingMachines()const +{ + return resources()->getAllFittingMachines(); +} + +const std::list& YDFXResourceModel::getInFiles()const +{ + return getClusterParams().getInFiles(); +} + +std::list& YDFXResourceModel::getInFiles() +{ + return getClusterParams().getInFiles(); +} + +bool YDFXResourceModel::isMachineInteractive(const std::string& machine)const +{ + return resources()->isMachineInteractive(machine); +} + +void YDFXResourceModel::reset(YACSEvalYFX* eval) +{ + _eval = eval; +} + +YACSEvalListOfResources* YDFXResourceModel::resources() +{ + return _eval->giveResources(); +} + +const YACSEvalListOfResources* YDFXResourceModel::resources()const +{ + return _eval->giveResources(); +} + +YACSEvalParamsForCluster& YDFXResourceModel::getClusterParams() +{ + return _eval->giveResources()->getAddParamsForCluster(); +} + +const YACSEvalParamsForCluster& YDFXResourceModel::getClusterParams()const +{ + return _eval->giveResources()->getAddParamsForCluster(); +} + +void YDFXResourceModel::getMaxDuration(int& hours, int& minutes)const +{ + std::string duration = getClusterParams().getMaxDuration(); + hours=0; + minutes=0; + if(duration.size() > 0) + { + std::stringstream ss(duration); + std::string value; + std::getline(ss, value, ':'); + hours = atoi(value.c_str()); + std::getline(ss, value, ':'); + minutes = atoi(value.c_str()); + } + if(hours<0) + hours = 0; + if(hours>99) + hours = 99; + if(minutes<0) + minutes = 0; + if(minutes > 59) + minutes = 59; +} + +void YDFXResourceModel::setMaxDuration(int hours, int minutes) +{ + getClusterParams().setMaxDuration(AbstractResourceModel::getMaxDuration()); +} \ No newline at end of file diff --git a/src/ydfx_gui/YDFXResourceModel.hxx b/src/ydfx_gui/YDFXResourceModel.hxx new file mode 100644 index 000000000..d568ee095 --- /dev/null +++ b/src/ydfx_gui/YDFXResourceModel.hxx @@ -0,0 +1,63 @@ +#ifndef YDFXRESOURCEMODEL_H +#define YDFXRESOURCEMODEL_H + +#include "AbstractResourceModel.hxx" + +class YACSEvalYFX; +class YACSEvalListOfResources; +class YACSEvalParamsForCluster; + +class YDFXWIDGETS_EXPORT YDFXResourceModel : public AbstractResourceModel +{ +public: + + YDFXResourceModel(YACSEvalYFX* eval); + virtual ~YDFXResourceModel(); + + virtual bool getParallelizeStatus()const; + virtual void setParallelizeStatus(bool v); + + virtual std::string getRemoteDir()const; + virtual std::string getDefaultRemoteDir(std::string machine)const; + virtual void setRemoteDir(const std::string& v); + + virtual std::string getLocalDir()const; + virtual void setLocalDir(const std::string& v); + + virtual std::string getWckey()const; + virtual void setWckey(const std::string& v); + + virtual int getMaxDurationMinutes()const; + virtual void setMaxDurationMinutes(int v); + + virtual int getMaxDurationHours()const; + virtual void setMaxDurationHours(int v); + + virtual unsigned int getNbprocs()const; + virtual void setNbprocs(unsigned int v); + + virtual std::string getWantedMachine()const; + virtual void setWantedMachine(const std::string& v); + virtual std::vector getFittingMachines()const; + + virtual const std::list& getInFiles()const; + virtual std::list& getInFiles(); + + virtual bool isMachineInteractive(const std::string& machine)const; + + void reset(YACSEvalYFX* eval); + +private: + + YACSEvalListOfResources * resources(); + const YACSEvalListOfResources * resources()const; + YACSEvalParamsForCluster& getClusterParams(); + const YACSEvalParamsForCluster& getClusterParams()const; + void getMaxDuration(int& hours, int& minutes)const; + void setMaxDuration(int hours, int minutes); + +private: + YACSEvalYFX* _eval; +}; + +#endif // YDFXRESOURCEMODEL_H -- 2.39.2