#include <map>
#include <string>
#include <vector>
+#include <list>
#ifdef WIN32
#define NOMINMAX
void setNbProcs(unsigned int nbProcs) { _nbOfProcs=nbProcs; }
void setMaxDuration(const std::string& maxDuration) { _maxDuration=maxDuration; }
std::string getMaxDuration() const { return _maxDuration; }
+ std::list<std::string>& getInFiles(){ return _in_files;}
+ const std::list<std::string>& getInFiles()const { return _in_files;}
YACSEVALYFX_EXPORT void checkConsistency() const;
private:
bool _exclusiveness;
std::string _wcKey;
std::string _maxDuration;
unsigned int _nbOfProcs;
+ std::list<std::string> _in_files;
};
class YACSEvalListOfResources : public YACSEvalNonConstLocker
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 !");
return getUndergroundGeneratedGraph()->getState()==YACS::DONE;
}
+std::string YACSEvalYFXGraphGenInteractive::getErrors()const
+{
+ return "";
+}
+
std::vector<YACSEvalSeqAny *> YACSEvalYFXGraphGenInteractive::getResults() const
{
if(getUndergroundGeneratedGraph()->getState()!=YACS::DONE)
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());
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<std::string>::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());
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)
{
return ret;
}
+std::string YACSEvalYFXGraphGenCluster::getErrors()const
+{
+ return _errors;
+}
+
std::vector<YACSEvalSeqAny *> YACSEvalYFXGraphGenCluster::getResults() const
{
std::size_t sz(_res.size());
virtual void generateGraph() = 0;
virtual bool go(const YACSEvalExecParams& params, YACSEvalSession *session) const = 0;
virtual std::vector<YACSEvalSeqAny *> getResults() const = 0;
+ virtual std::string getErrors()const = 0;
bool isLocked() const;
int assignNbOfBranches();
void resetGeneratedGraph();
void generateGraph();
bool go(const YACSEvalExecParams& params, YACSEvalSession *session) const;
std::vector<YACSEvalSeqAny *> getResults() const;
+ virtual std::string getErrors()const;
};
class YACSEvalYFXGraphGenCluster : public YACSEvalYFXGraphGen
void generateGraph();
bool go(const YACSEvalExecParams& params, YACSEvalSession *session) const;
std::vector<YACSEvalSeqAny *> getResults() const;
+ virtual std::string getErrors()const;
private:
std::string _locSchemaFile;
std::string _jobName;
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}"
)
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
--- /dev/null
+#include "AbstractResourceModel.hxx"
+#include <sstream>
+#include <iostream>
+
+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();
+}
--- /dev/null
+#ifndef ABSTRACTRESOURCEMODEL_HXX
+#define ABSTRACTRESOURCEMODEL_HXX
+
+#include <string>
+#include <vector>
+#include <list>
+#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<std::string> getFittingMachines()const =0;
+
+ virtual const std::list<std::string>& getInFiles()const =0;
+ virtual std::list<std::string>& getInFiles() =0;
+
+ virtual bool isMachineInteractive(const std::string& machine)const =0;
+};
+
+#endif // ABSTRACTRESOURCEMODEL_HXX
YDFXGUISeqInit.hxx
YDFXGUIParametrizer.hxx
YDFXGUIHostParametrizer.hxx
+ ResourceWidget.hxx
)
# sources / moc wrappings
YDFXGUIPyThreadSaver.hxx
YDFXGUISeqInit.hxx
YDFXGUIWrap.hxx
+ ResourceWidget.hxx
+ AbstractResourceModel.hxx
+ YDFXResourceModel.hxx
+ SalomeResourceModel.hxx
)
SET(ydfxwidgets_SOURCES
YDFXGUIPyThreadSaver.cxx
YDFXGUISeqInit.cxx
YDFXGUIWrap.cxx
+ YDFXResourceModel.cxx
+ ResourceWidget.cxx
+ SalomeResourceModel.cxx
+ AbstractResourceModel.cxx
${_moc_SOURCES}
)
--- /dev/null
+#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<std::string> resources = _model->getFittingMachines();
+ std::vector<std::string>::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<QListView*>("listView");
+ if (l)
+ {
+ l->setSelectionMode(QAbstractItemView::MultiSelection);
+ }
+ QTreeView *t = w.findChild<QTreeView*>();
+ 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<QListWidgetItem *> 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;
+ }
+}
--- /dev/null
+#ifndef RESOURCEWIDGET_HXX
+#define RESOURCEWIDGET_HXX
+
+#include <QtWidgets>
+#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
--- /dev/null
+#include "SalomeResourceModel.hxx"
+#include "RuntimeSALOME.hxx"
+#include "SALOME_ResourcesManager.hxx"
+#include "SALOME_LifeCycleCORBA.hxx"
+#include <ctime>
+
+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<std::string>& SalomeResourceModel::getInFiles()const
+{
+ return _in_files;
+}
+
+std::list<std::string>& SalomeResourceModel::getInFiles()
+{
+ return _in_files;
+}
--- /dev/null
+#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<std::string>& getInFiles()const;
+ virtual std::list<std::string>& 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<std::string> _in_files;
+};
+
+#endif // SALOMERESOURCEMODEL_HXX
--- /dev/null
+#include "YDFXResourceModel.hxx"
+
+#include "YACSEvalYFX.hxx"
+#include "YACSEvalResource.hxx"
+//#include "ResourcesManager.hxx"
+
+#include <algorithm>
+#include <sstream>
+#include <cstdlib>
+
+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<std::string> chosenMachines = resources()->getAllChosenMachines();
+ std::vector<std::string> fittingMachines = resources()->getAllFittingMachines();
+ std::string wantedMachine="";
+ std::vector<std::string>::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<std::string> YDFXResourceModel::getFittingMachines()const
+{
+ return resources()->getAllFittingMachines();
+}
+
+const std::list<std::string>& YDFXResourceModel::getInFiles()const
+{
+ return getClusterParams().getInFiles();
+}
+
+std::list<std::string>& 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
--- /dev/null
+#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<std::string> getFittingMachines()const;
+
+ virtual const std::list<std::string>& getInFiles()const;
+ virtual std::list<std::string>& 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
