#include <libdcp/exceptions.h>
#include "job.h"
#include "util.h"
+#include "cross.h"
-using namespace std;
-using namespace boost;
+#include "i18n.h"
-/** @param s FilmState for the film that we are operating on.
- * @param o Options.
- * @param l A log that we can write to.
+using std::string;
+using std::list;
+using std::stringstream;
+using boost::shared_ptr;
+
+/** @param s Film that we are operating on.
*/
-Job::Job (shared_ptr<const FilmState> s, shared_ptr<const Options> o, Log* l)
- : _fs (s)
- , _opt (o)
- , _log (l)
+Job::Job (shared_ptr<Film> f)
+ : _film (f)
+ , _thread (0)
, _state (NEW)
, _start_time (0)
, _progress_unknown (false)
+ , _ran_for (0)
{
- assert (_log);
-
descend (1);
}
{
set_state (RUNNING);
_start_time = time (0);
- boost::thread (boost::bind (&Job::run_wrapper, this));
+ _thread = new boost::thread (boost::bind (&Job::run_wrapper, this));
}
/** A wrapper for the ::run() method to catch exceptions */
set_progress (1);
set_state (FINISHED_ERROR);
- stringstream s;
- s << e.what() << "(" << filesystem::path (e.filename()).leaf() << ")";
- set_error (s.str ());
+ string m = String::compose (_("An error occurred whilst handling the file %1."), boost::filesystem::path (e.filename()).leaf());
+
+ try {
+ boost::filesystem::space_info const s = boost::filesystem::space (e.filename());
+ if (s.available < pow (1024, 3)) {
+ m += N_("\n\n");
+ m += _("The drive that the film is stored on is low in disc space. Free some more space and try again.");
+ }
+ } catch (...) {
+
+ }
+
+ set_error (e.what(), m);
+
+ } catch (boost::thread_interrupted &) {
+
+ set_state (FINISHED_CANCELLED);
+
} catch (std::exception& e) {
set_progress (1);
set_state (FINISHED_ERROR);
- set_error (e.what ());
+ set_error (
+ e.what (),
+ _("It is not known what caused this error. The best idea is to report the problem to the DVD-o-matic mailing list (dvdomatic@carlh.net)")
+ );
+
+ } catch (...) {
+
+ set_progress (1);
+ set_state (FINISHED_ERROR);
+ set_error (
+ _("Unknown error"),
+ _("It is not known what caused this error. The best idea is to report the problem to the DVD-o-matic mailing list (dvdomatic@carlh.net)")
+ );
}
}
+/** @return true if this job is new (ie has not started running) */
+bool
+Job::is_new () const
+{
+ boost::mutex::scoped_lock lm (_state_mutex);
+ return _state == NEW;
+}
+
/** @return true if the job is running */
bool
Job::running () const
Job::finished () const
{
boost::mutex::scoped_lock lm (_state_mutex);
- return _state == FINISHED_OK || _state == FINISHED_ERROR;
+ return _state == FINISHED_OK || _state == FINISHED_ERROR || _state == FINISHED_CANCELLED;
}
/** @return true if the job has finished successfully */
return _state == FINISHED_ERROR;
}
+bool
+Job::finished_cancelled () const
+{
+ boost::mutex::scoped_lock lm (_state_mutex);
+ return _state == FINISHED_CANCELLED;
+}
+
+bool
+Job::paused () const
+{
+ boost::mutex::scoped_lock lm (_state_mutex);
+ return _state == PAUSED;
+}
+
/** Set the state of this job.
* @param s New state.
*/
{
boost::mutex::scoped_lock lm (_state_mutex);
_state = s;
-}
-/** A hack to work around our lack of cross-thread
- * signalling; this emits Finished, and listeners
- * assume that it will be emitted in the GUI thread,
- * so this method must be called from the GUI thread.
- */
-void
-Job::emit_finished ()
-{
- Finished ();
+ if (_state == FINISHED_OK || _state == FINISHED_ERROR) {
+ _ran_for = elapsed_time ();
+ }
}
/** @return Time (in seconds) that this job has been running */
Job::set_progress (float p)
{
boost::mutex::scoped_lock lm (_progress_mutex);
+ _progress_unknown = false;
_stack.back().normalised = p;
+ boost::this_thread::interruption_point ();
+
+ if (paused ()) {
+ dvdomatic_sleep (1);
+ }
}
/** @return fractional overall progress, or -1 if not known */
_stack.push_back (Level (a));
}
-/** @return Any error string that the job has generated */
string
-Job::error () const
+Job::error_details () const
+{
+ boost::mutex::scoped_lock lm (_state_mutex);
+ return _error_details;
+}
+
+/** @return A summary of any error that the job has generated */
+string
+Job::error_summary () const
{
boost::mutex::scoped_lock lm (_state_mutex);
- return _error;
+ return _error_summary;
}
/** Set the current error string.
* @param e New error string.
*/
void
-Job::set_error (string e)
+Job::set_error (string s, string d)
{
boost::mutex::scoped_lock lm (_state_mutex);
- _error = e;
+ _error_summary = s;
+ _error_details = d;
}
-/** Set that this job's progress will always be unknown */
+/** Say that this job's progress will be unknown until further notice */
void
Job::set_progress_unknown ()
{
_progress_unknown = true;
}
+/** @return Human-readable status of this job */
string
Job::status () const
{
float const p = overall_progress ();
int const t = elapsed_time ();
-
+ int const r = remaining_time ();
+
+ int pc = rint (p * 100);
+ if (pc == 100) {
+ /* 100% makes it sound like we've finished when we haven't */
+ pc = 99;
+ }
+
stringstream s;
- if (!finished () && p >= 0 && t > 10) {
- s << rint (p * 100) << "%; about " << seconds_to_approximate_hms (t / p - t) << " remaining";
- } else if (!finished () && t <= 10) {
- s << rint (p * 100) << "%";
+ if (!finished ()) {
+ s << pc << N_("%");
+ if (p >= 0 && t > 10 && r > 0) {
+ /// TRANSLATORS: remaining here follows an amount of time that is remaining
+ /// on an operation.
+ s << "; " << seconds_to_approximate_hms (r) << " " << _("remaining");
+ }
} else if (finished_ok ()) {
- s << "OK (ran for " << seconds_to_hms (t) << ")";
+ s << String::compose (_("OK (ran for %1)"), seconds_to_hms (_ran_for));
} else if (finished_in_error ()) {
- s << "Error (" << error() << ")";
+ s << String::compose (_("Error (%1)"), error_summary());
+ } else if (finished_cancelled ()) {
+ s << _("Cancelled");
}
return s.str ();
}
+
+/** @return An estimate of the remaining time for this job, in seconds */
+int
+Job::remaining_time () const
+{
+ return elapsed_time() / overall_progress() - elapsed_time();
+}
+
+void
+Job::cancel ()
+{
+ if (!_thread) {
+ return;
+ }
+
+ _thread->interrupt ();
+ _thread->join ();
+}
+
+void
+Job::pause ()
+{
+ if (running ()) {
+ set_state (PAUSED);
+ }
+}
+
+void
+Job::resume ()
+{
+ if (paused ()) {
+ set_state (RUNNING);
+ }
+}
projects / dcpomatic.git / blobdiff