*/
+
/** @file src/job.cc
* @brief A parent class to represent long-running tasks which are run in their own thread.
*/
-#include "job.h"
-#include "util.h"
+
+#include "compose.hpp"
+#include "constants.h"
#include "cross.h"
+#include "dcpomatic_log.h"
#include "exceptions.h"
#include "film.h"
+#include "job.h"
#include "log.h"
-#include "dcpomatic_log.h"
-#include "compose.hpp"
+#include "util.h"
#include <dcp/exceptions.h>
#include <sub/exceptions.h>
-#include <boost/thread.hpp>
-#include <boost/filesystem.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/thread.hpp>
#include <iostream>
#include "i18n.h"
-using std::string;
-using std::list;
+
using std::cout;
+using std::function;
+using std::list;
using std::shared_ptr;
+using std::string;
using boost::optional;
-using boost::function;
using namespace dcpomatic;
+
/** @param film Associated film, or 0 */
Job::Job (shared_ptr<const Film> film)
: _film (film)
}
+
Job::~Job ()
{
#ifdef DCPOMATIC_DEBUG
#endif
}
+
void
Job::stop_thread ()
{
} catch (...) {}
}
+
/** Start the job in a separate thread, returning immediately */
void
Job::start ()
#endif
}
+
/** A wrapper for the ::run() method to catch exceptions */
void
Job::run_wrapper ()
{
+ start_of_thread (String::compose("Job-%1", json_name()));
+
try {
run ();
set_state (FINISHED_ERROR);
} catch (boost::thread_interrupted &) {
-
- set_state (FINISHED_CANCELLED);
-
+ /* The job was cancelled; there's nothing else we need to do here */
} catch (sub::SubripError& e) {
string extra = "Error is near:\n";
set_progress (1);
set_state (FINISHED_ERROR);
+ } catch (CPLNotFoundError& e) {
+
+ set_error(e.what());
+ set_progress(1);
+ set_state(FINISHED_ERROR);
+
} catch (std::exception& e) {
set_error (
}
}
+
/** @return true if this job is new (ie has not started running) */
bool
Job::is_new () const
return _state == NEW;
}
+
/** @return true if the job is running */
bool
Job::running () const
return _state == RUNNING;
}
+
/** @return true if the job has finished (either successfully or unsuccessfully) */
bool
Job::finished () const
return _state == FINISHED_OK || _state == FINISHED_ERROR || _state == FINISHED_CANCELLED;
}
+
/** @return true if the job has finished successfully */
bool
Job::finished_ok () const
return _state == FINISHED_OK;
}
+
/** @return true if the job has finished unsuccessfully */
bool
Job::finished_in_error () const
return _state == FINISHED_ERROR;
}
+
bool
Job::finished_cancelled () const
{
return _state == FINISHED_CANCELLED;
}
+
bool
Job::paused_by_user () const
{
return _state == PAUSED_BY_USER;
}
+
bool
Job::paused_by_priority () const
{
return _state == PAUSED_BY_PRIORITY;
}
+
/** Set the state of this job.
* @param s New state.
*/
{
boost::mutex::scoped_lock lm (_state_mutex);
+ if (_state == s) {
+ return;
+ }
+
_state = s;
if (_state == FINISHED_OK || _state == FINISHED_ERROR || _state == FINISHED_CANCELLED) {
}
if (finished) {
- emit (boost::bind (boost::ref (Finished)));
- FinishedImmediate ();
+ auto const result = state_to_result(s);
+ emit(boost::bind(boost::ref(Finished), result));
+ FinishedImmediate(result);
}
}
+
+Job::Result
+Job::state_to_result(State state) const
+{
+ switch (state) {
+ case FINISHED_OK:
+ return Result::RESULT_OK;
+ case FINISHED_ERROR:
+ return Result::RESULT_ERROR;
+ case FINISHED_CANCELLED:
+ return Result::RESULT_CANCELLED;
+ default:
+ DCPOMATIC_ASSERT(false);
+ };
+
+ DCPOMATIC_ASSERT(false);
+}
+
+
/** @return DCPTime (in seconds) that this sub-job has been running */
int
Job::elapsed_sub_time () const
return time (0) - _sub_start_time;
}
+
/** Check to see if this job has been interrupted or paused */
void
Job::check_for_interruption_or_pause ()
}
}
+
+optional<float>
+Job::seconds_since_last_progress_update () const
+{
+ boost::mutex::scoped_lock lm (_progress_mutex);
+ if (!_last_progress_update) {
+ return {};
+ }
+
+ struct timeval now;
+ gettimeofday (&now, 0);
+
+ return seconds(now) - seconds(*_last_progress_update);
+}
+
+
/** Set the progress of the current part of the job.
* @param p Progress (from 0 to 1)
* @param force Do not ignore this update, even if it hasn't been long since the last one.
struct timeval now;
gettimeofday (&now, 0);
if (_last_progress_update && _last_progress_update->tv_sec > 0) {
- double const elapsed = (now.tv_sec + now.tv_usec / 1000000.0)
- - (_last_progress_update->tv_sec + _last_progress_update->tv_usec / 1000000.0);
+ double const elapsed = seconds(now) - seconds(*_last_progress_update);
if (elapsed < 0.5) {
return;
}
set_progress_common (p);
}
+
void
Job::set_progress_common (optional<float> p)
{
emit (boost::bind (boost::ref (Progress)));
}
+
/** @return fractional progress of the current sub-job, if known */
optional<float>
Job::progress () const
return _progress;
}
+
void
Job::sub (string n)
{
_sub_start_time = time (0);
}
+
string
Job::error_details () const
{
return _error_details;
}
+
/** @return A summary of any error that the job has generated */
string
Job::error_summary () const
return _error_summary;
}
+
/** Set the current error string.
* @param s New error string.
* @param d New error detail string.
_error_details = d;
}
+
/** Say that this job's progress will be unknown until further notice */
void
Job::set_progress_unknown ()
set_progress_common (optional<float> ());
}
+
/** @return Human-readable status of this job */
string
Job::status () const
int const t = elapsed_sub_time ();
int const r = remaining_time ();
+ auto day_of_week_to_string = [](boost::gregorian::greg_weekday d) -> std::string {
+ switch (d.as_enum()) {
+ case boost::date_time::Sunday:
+ return _("Sunday");
+ case boost::date_time::Monday:
+ return _("Monday");
+ case boost::date_time::Tuesday:
+ return _("Tuesday");
+ case boost::date_time::Wednesday:
+ return _("Wednesday");
+ case boost::date_time::Thursday:
+ return _("Thursday");
+ case boost::date_time::Friday:
+ return _("Friday");
+ case boost::date_time::Saturday:
+ return _("Saturday");
+ }
+
+ return d.as_long_string();
+ };
+
string s;
if (!finished () && p) {
int pc = lrintf (p.get() * 100);
return s;
}
+
string
Job::json_status () const
{
return "";
}
+
/** @return An estimate of the remaining time for this sub-job, in seconds */
int
Job::remaining_time () const
return elapsed_sub_time() / progress().get() - elapsed_sub_time();
}
+
void
Job::cancel ()
{
- if (!_thread.joinable()) {
- return;
- }
+ if (_thread.joinable()) {
+ resume();
- if (paused_by_user() || paused_by_priority()) {
- resume ();
+ _thread.interrupt ();
+ _thread.join ();
}
- _thread.interrupt ();
- _thread.join ();
+ set_state (FINISHED_CANCELLED);
}
+
/** @return true if the job was paused, false if it was not running */
bool
Job::pause_by_user ()
return paused;
}
+
void
Job::pause_by_priority ()
{
}
}
+
void
Job::resume ()
{
}
}
+
void
-Job::when_finished (boost::signals2::connection& connection, function<void()> finished)
+Job::when_finished(boost::signals2::connection& connection, function<void(Result)> finished)
{
boost::mutex::scoped_lock lm (_state_mutex);
if (_state == FINISHED_OK || _state == FINISHED_ERROR || _state == FINISHED_CANCELLED) {
- finished ();
+ finished(state_to_result(_state));
} else {
connection = Finished.connect (finished);
}
}
+
optional<string>
Job::message () const
{
return _message;
}
+
void
Job::set_message (string m)
{
projects / dcpomatic.git / blobdiff