src/genericgui/BL_JobsManager_QT.cxx

   1 //  Copyright (C) 2009 CEA/DEN, EDF R&D
   2 //
   3 //  This library is free software; you can redistribute it and/or
   4 //  modify it under the terms of the GNU Lesser General Public
   5 //  License as published by the Free Software Foundation; either
   6 //  version 2.1 of the License.
   7 //
   8 //  This library is distributed in the hope that it will be useful,
   9 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 //  Lesser General Public License for more details.
  12 //
  13 //  You should have received a copy of the GNU Lesser General Public
  14 //  License along with this library; if not, write to the Free Software
  15 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "BL_JobsManager_QT.hxx"
  21
  22 BL::JobManagerEvent::JobManagerEvent(const std::string & action_i,
  23                                      const std::string & event_name_i,
  24                                      const std::string & job_name_i,
  25                                      const std::string & data_i) : QEvent(QEvent::User)
  26 {
  27   action = action_i;
  28   event_name = event_name_i;
  29   job_name = job_name_i;
  30   data = data_i;
  31 }
  32
  33 BL::JobManagerEvent::~JobManagerEvent() {}
  34
  35 BL::JobsManager_QT::JobsManager_QT(QWidget * parent, BL::SALOMEServices * salome_services) :
  36   QDockWidget(parent), BL::JobsManager(salome_services)
  37 {
  38   DEBTRACE("Creating BL::JobsManager_QT");
  39   setObserver(this);
  40
  41   // Widget Part
  42
  43   QWidget * main_widget = new QWidget(this);
  44
  45   _load_jobs = new QPushButton("Load Jobs");
  46   _save_jobs = new QPushButton("Save Jobs");
  47   _auto_refresh_jobs = new QPushButton("Auto Refresh: no");
  48   _timer = new QTimer(this);
  49   _timer->stop();
  50   connect(_timer, SIGNAL(timeout()), this, SLOT(RefreshJobs()));
  51
  52   // Menu for auto refresh
  53   QMenu * refresh_menu = new QMenu(this);
  54   refresh_menu->addAction("No", this, SLOT(no_auto_refresh()));
  55   refresh_menu->addAction("10 seconds", this, SLOT(ten_seconds_refresh()));
  56   refresh_menu->addAction("30 seconds", this, SLOT(thirty_seconds_refresh()));
  57   refresh_menu->addAction("1 minute", this, SLOT(one_minute_refresh()));
  58   refresh_menu->addAction("5 minutes", this, SLOT(five_minutes_refresh()));
  59   refresh_menu->addAction("30 minutes", this, SLOT(thirty_minutes_refresh()));
  60   refresh_menu->addAction("1 hour", this, SLOT(one_hour_refresh()));
  61   _auto_refresh_jobs->setMenu(refresh_menu);
  62
  63   QHBoxLayout * button_layout = new QHBoxLayout();
  64   button_layout->addWidget(_load_jobs);
  65   button_layout->addWidget(_save_jobs);
  66   button_layout->addWidget(_auto_refresh_jobs);
  67
  68   QGroupBox * message_box = new QGroupBox("Messages");
  69   _log = new QTextEdit(this);
  70   _log->setReadOnly(true);
  71   QVBoxLayout * message_box_layout = new QVBoxLayout(message_box);
  72   message_box_layout->addWidget(_log);
  73   message_box->setLayout(message_box_layout);
  74
  75   QVBoxLayout * mainLayout = new QVBoxLayout();
  76   mainLayout->addLayout(button_layout);
  77   mainLayout->addWidget(message_box);
  78   main_widget->setLayout(mainLayout);
  79
  80   setWidget(main_widget);
  81   setWindowTitle("Job Manager");
  82 }
  83
  84 BL::JobsManager_QT::~JobsManager_QT()
  85 {
  86   DEBTRACE("Destroying BL::JobsManager_QT");
  87 }
  88
  89 void
  90 BL::JobsManager_QT::RefreshJobs()
  91 {
  92   refresh_jobs();
  93 }
  94
  95 void
  96 BL::JobsManager_QT::no_auto_refresh()
  97 {
  98   _auto_refresh_jobs->setText("Auto Refresh: no");
  99   _timer->stop();
 100 }
 101
 102 void
 103 BL::JobsManager_QT::ten_seconds_refresh()
 104 {
 105   _auto_refresh_jobs->setText("Auto Refresh: 10s");
 106   _timer->stop();
 107   _timer->start(10 * 1000);
 108 }
 109
 110 void
 111 BL::JobsManager_QT::thirty_seconds_refresh()
 112 {
 113   _auto_refresh_jobs->setText("Auto Refresh: 30s");
 114   _timer->stop();
 115   _timer->start(30 * 1000);
 116 }
 117
 118 void
 119 BL::JobsManager_QT::one_minute_refresh()
 120 {
 121   _auto_refresh_jobs->setText("Auto Refresh: 1min");
 122   _timer->stop();
 123   _timer->start(1 * 60 * 1000);
 124 }
 125
 126 void
 127 BL::JobsManager_QT::five_minutes_refresh()
 128 {
 129   _auto_refresh_jobs->setText("Auto Refresh: 5min");
 130   _timer->stop();
 131   _timer->start(5 * 60 * 1000);
 132 }
 133
 134 void
 135 BL::JobsManager_QT::thirty_minutes_refresh()
 136 {
 137   _auto_refresh_jobs->setText("Auto Refresh: 30min");
 138   _timer->stop();
 139   _timer->start(30 * 60 * 1000);
 140 }
 141
 142 void
 143 BL::JobsManager_QT::one_hour_refresh()
 144 {
 145   _auto_refresh_jobs->setText("Auto Refresh: 1hour");
 146   _timer->stop();
 147   _timer->start(1 * 60 * 60 * 1000);
 148 }
 149
 150 void
 151 BL::JobsManager_QT::create_job_wizard()
 152 {
 153     BL::CreateJobWizard wizard(this, _salome_services);
 154     wizard.exec();
 155
 156     if (wizard.job_name != "")
 157     {
 158       BL::Job * new_job = addNewJob(wizard.job_name);
 159       if (wizard.yacs_file != "")
 160       {
 161         // YACS schema job
 162         new_job->setType(BL::Job::YACS_SCHEMA);
 163         new_job->setYACSFile(wizard.yacs_file);
 164         BL::Job::BatchParam param;
 165         param.batch_directory = wizard.batch_directory;
 166         param.expected_during_time = wizard.expected_during_time;
 167         param.expected_memory = wizard.expected_memory;
 168         param.nb_proc = wizard.nb_proc;
 169         new_job->setBatchParameters(param);
 170         BL::Job::FilesParam files_params;
 171         files_params.result_directory = wizard.result_directory;
 172         files_params.input_files_list = wizard.input_files_list;
 173         files_params.output_files_list = wizard.output_files_list;
 174         new_job->setFilesParameters(files_params);
 175         new_job->setMachine(wizard.machine_choosed);
 176       }
 177       else
 178       {
 179         // Command Job
 180         new_job->setType(BL::Job::COMMAND);
 181         new_job->setCommand(wizard.command);
 182         BL::Job::BatchParam param;
 183         param.batch_directory = wizard.batch_directory;
 184         param.expected_during_time = wizard.expected_during_time;
 185         param.expected_memory = wizard.expected_memory;
 186         param.nb_proc = wizard.nb_proc;
 187         new_job->setBatchParameters(param);
 188         BL::Job::FilesParam files_params;
 189         files_params.result_directory = wizard.result_directory;
 190         files_params.input_files_list = wizard.input_files_list;
 191         files_params.output_files_list = wizard.output_files_list;
 192         new_job->setFilesParameters(files_params);
 193         new_job->setMachine(wizard.machine_choosed);
 194       }
 195       emit new_job_added(QString::fromStdString(wizard.job_name));
 196       if (wizard.start_job)
 197         start_job(wizard.job_name);
 198     }
 199     else
 200     {
 201        DEBTRACE("User cancel Create Job Wizard");
 202     }
 203 }
 204
 205 void
 206 BL::JobsManager_QT::delete_job(QString job_name)
 207 {
 208   BL::JobsManager::removeJob(job_name.toStdString());
 209 }
 210
 211 void
 212 BL::JobsManager_QT::sendEvent(const std::string & action,
 213                               const std::string & event_name,
 214                               const std::string & job_name,
 215                               const std::string & data)
 216 {
 217   DEBTRACE("sendEvent BL::JobsManager_QT");
 218
 219   // Sending a QEvent to go back to main thread
 220   BL::JobManagerEvent * event = new JobManagerEvent(action, event_name, job_name, data);
 221   QApplication::postEvent(this, event);
 222 }
 223
 224 bool
 225 BL::JobsManager_QT::event(QEvent * e)
 226 {
 227   QDockWidget::event(e);
 228   JobManagerEvent * event = dynamic_cast<JobManagerEvent*>(e);
 229   if (!event) return false;
 230
 231   DEBTRACE("BL::JobsManager_QT Receiving event : "
 232            << event->action << " "
 233            << event->event_name << " "
 234            << event->job_name << " "
 235            << event->data);
 236   if (event->action == "start_job")
 237   {
 238     if (event->event_name == "Ok")
 239     {
 240       QString str((event->job_name).c_str());
 241       write_normal_text("Job " + str + " queued\n");
 242     }
 243     else
 244     {
 245       QString str((event->job_name).c_str());
 246       write_error_text("Error in starting job: " + str + "\n");
 247       write_error_text("*** ");
 248       write_error_text((event->data).c_str());
 249       write_error_text(" ***\n");
 250     }
 251     emit job_state_changed(QString((event->job_name).c_str()));
 252   }
 253   else if (event->action == "refresh_job")
 254   {
 255     if (event->event_name == "Ok")
 256     {
 257       QString str((event->job_name).c_str());
 258       write_normal_text("Job " + str + " state changed\n");
 259       emit job_state_changed(QString((event->job_name).c_str()));
 260     }
 261     else
 262     {
 263       QString str((event->job_name).c_str());
 264       write_error_text("Error in refreshing job: " + str + "\n");
 265       write_error_text("*** ");
 266       write_error_text((event->data).c_str());
 267       write_error_text(" ***\n");
 268     }
 269   }
 270   else if (event->action == "delete_job")
 271   {
 272     if (event->event_name == "Ok")
 273     {
 274       QString str((event->job_name).c_str());
 275       write_normal_text("Job " + str + " deleted\n");
 276     }
 277     else
 278     {
 279       QString str((event->job_name).c_str());
 280       write_error_text("Warning delete job: " + str + " maybe not complete, exception catch in SALOME Launcher service\n");
 281       write_error_text("*** ");
 282       write_error_text((event->data).c_str());
 283       write_error_text(" ***\n");
 284     }
 285   }
 286   else if (event->action == "get_results_job")
 287   {
 288     if (event->event_name == "Ok")
 289     {
 290       QString str((event->job_name).c_str());
 291       write_normal_text("Results of Job " + str + " are get\n");
 292     }
 293     else
 294     {
 295       QString str((event->job_name).c_str());
 296       write_error_text("Warning for results of job: " + str + " maybe not complete, exception catch in SALOME Launcher service\n");
 297       write_error_text("*** ");
 298       write_error_text((event->data).c_str());
 299       write_error_text(" ***\n");
 300     }
 301   }
 302   else
 303   {
 304     QString str((event->action).c_str());
 305     write_error_text("Unknown type of event received:" + str + "\n");
 306   }
 307   return true;
 308 }
 309
 310 void
 311 BL::JobsManager_QT::write_normal_text(const QString & text)
 312 {
 313   _log->setReadOnly(false);
 314   QTextCursor cursor = _log->textCursor();
 315   QTextCharFormat text_format;
 316   text_format.setForeground(Qt::darkBlue);
 317   cursor.insertText(text, text_format);
 318   _log->setTextCursor(cursor);
 319   _log->setReadOnly(true);
 320 }
 321
 322 void
 323 BL::JobsManager_QT::write_error_text(const QString & text)
 324 {
 325   QTextCursor cursor = _log->textCursor();
 326   QTextCharFormat text_format;
 327   text_format.setForeground(Qt::red);
 328   cursor.insertText(text, text_format);
 329   _log->setTextCursor(cursor);
 330 }