orthanc: UnitTestsSources/MultiThreadingTests.cpp comparison

comparison UnitTestsSources/MultiThreadingTests.cpp @ 2568:a46094602346 jobs

improvements

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 07 May 2018 15:02:34 +0200
parents	3caca43371f5
children	2af17cd5eb1f

comparison

equal deleted inserted replaced

-:3caca43371f5
+:a46094602346
 {
 JobStepCode_Success,
 JobStepCode_Failure,
 JobStepCode_Continue,
 JobStepCode_Retry
 };
 class JobStepResult
 {
 private:
-JobStepCode status_;
+JobStepCode code_;
 public:
-explicit JobStepResult(JobStepCode status) :
+explicit JobStepResult(JobStepCode code) :
-status_(status)
+code_(code)
 {
 }
 virtual ~JobStepResult()
 {
 }
 JobStepCode GetCode() const
 {
-return status_;
+return code_;
 }
 };
-class RetryResult : public JobStepResult
+class JobStepRetry : public JobStepResult
 {
 private:
 unsigned int  timeout_;   // Retry after "timeout_" milliseconds
 public:
-RetryResult(unsigned int timeout) :
+JobStepRetry(unsigned int timeout) :
 JobStepResult(JobStepCode_Retry),
 timeout_(timeout)
 {
 }
 }
 }
 };
-class JobHandler : public boost::noncopyable
-{
+class JobsRegistry : public boost::noncopyable
+{
 private:
-std::string                       id_;
+class JobHandler : public boost::noncopyable
-JobState                          state_;
+{
-std::auto_ptr<IJob>               job_;
+private:
-int                               priority_;  // "+inf()" means highest priority
+std::string                       id_;
-boost::posix_time::ptime          creationTime_;
+JobState                          state_;
-boost::posix_time::ptime          lastStateChangeTime_;
+std::auto_ptr<IJob>               job_;
-boost::posix_time::time_duration  runtime_;
+int                               priority_;  // "+inf()" means highest priority
-boost::posix_time::ptime          retryTime_;
+boost::posix_time::ptime          creationTime_;
-bool                              pauseScheduled_;
+boost::posix_time::ptime          lastStateChangeTime_;
-JobStatus                         lastStatus_;
+boost::posix_time::time_duration  runtime_;
+boost::posix_time::ptime          retryTime_;
-void Touch()
+bool                              pauseScheduled_;
-{
+JobStatus                         lastStatus_;
-const boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();
+void Touch()
-if (state_ == JobState_Running)
+{
-{
+const boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();
-runtime_ += (now - lastStateChangeTime_);
-}
+if (state_ == JobState_Running)
+{
-lastStateChangeTime_ = now;
+runtime_ += (now - lastStateChangeTime_);
 }
-void SetStateInternal(JobState state)
+lastStateChangeTime_ = now;
-{
+}
-state_ = state;
-pauseScheduled_ = false;
+void SetStateInternal(JobState state)
-Touch();
+{
-}
+state_ = state;
+pauseScheduled_ = false;
-public:
+Touch();
-JobHandler(IJob* job,
+}
-int priority) :
-id_(Toolbox::GenerateUuid()),
+public:
-state_(JobState_Pending),
+JobHandler(IJob* job,
-job_(job),
+int priority) :
-priority_(priority),
+id_(Toolbox::GenerateUuid()),
-creationTime_(boost::posix_time::microsec_clock::universal_time()),
+state_(JobState_Pending),
-lastStateChangeTime_(creationTime_),
+job_(job),
-runtime_(boost::posix_time::milliseconds(0)),
+priority_(priority),
-retryTime_(creationTime_),
+creationTime_(boost::posix_time::microsec_clock::universal_time()),
-pauseScheduled_(false)
+lastStateChangeTime_(creationTime_),
-{
+runtime_(boost::posix_time::milliseconds(0)),
-if (job == NULL)
+retryTime_(creationTime_),
-{
+pauseScheduled_(false)
-throw OrthancException(ErrorCode_NullPointer);
+{
-}
+if (job == NULL)
+{
-lastStatus_ = JobStatus(ErrorCode_Success, *job);
+throw OrthancException(ErrorCode_NullPointer);
 }
-const std::string& GetId() const
+lastStatus_ = JobStatus(ErrorCode_Success, *job);
-{
+}
-return id_;
-}
+const std::string& GetId() const
+{
-IJob& GetJob() const
+return id_;
-{
+}
-assert(job_.get() != NULL);
-return *job_;
+IJob& GetJob() const
-}
+{
+assert(job_.get() != NULL);
-void SetPriority(int priority)
+return *job_;
-{
+}
-priority_ = priority;
-}
+void SetPriority(int priority)
+{
-int GetPriority() const
+priority_ = priority;
-{
+}
-return priority_;
-}
+int GetPriority() const
+{
-JobState GetState() const
+return priority_;
-{
+}
-return state_;
-}
+JobState GetState() const
+{
-void SetState(JobState state)
+return state_;
-{
+}
-if (state == JobState_Retry)
-{
+void SetState(JobState state)
-// Use "SetRetryState()"
+{
-throw OrthancException(ErrorCode_BadSequenceOfCalls);
+if (state == JobState_Retry)
-}
+{
-else
+// Use "SetRetryState()"
-{
+throw OrthancException(ErrorCode_BadSequenceOfCalls);
-SetStateInternal(state);
+}
-}
+else
-}
+{
+SetStateInternal(state);
-void SetRetryState(unsigned int timeout)
+}
-{
+}
-if (state_ == JobState_Running)
-{
+void SetRetryState(unsigned int timeout)
-SetStateInternal(JobState_Retry);
+{
-retryTime_ = (boost::posix_time::microsec_clock::universal_time() +
+if (state_ == JobState_Running)
-boost::posix_time::milliseconds(timeout));
+{
-}
+SetStateInternal(JobState_Retry);
-else
+retryTime_ = (boost::posix_time::microsec_clock::universal_time() +
-{
+boost::posix_time::milliseconds(timeout));
-// Only valid for running jobs
+}
-throw OrthancException(ErrorCode_BadSequenceOfCalls);
+else
-}
+{
-}
+// Only valid for running jobs
+throw OrthancException(ErrorCode_BadSequenceOfCalls);
-void SchedulePause()
+}
-{
+}
-if (state_ == JobState_Running)
-{
+void SchedulePause()
-pauseScheduled_ = true;
+{
-}
+if (state_ == JobState_Running)
-else
+{
-{
+pauseScheduled_ = true;
-// Only valid for running jobs
+}
-throw OrthancException(ErrorCode_BadSequenceOfCalls);
+else
-}
+{
-}
+// Only valid for running jobs
+throw OrthancException(ErrorCode_BadSequenceOfCalls);
-bool IsPauseScheduled()
+}
-{
+}
-return pauseScheduled_;
-}
+bool IsPauseScheduled()
+{
-bool IsRetryReady(const boost::posix_time::ptime& now) const
+return pauseScheduled_;
-{
+}
-if (state_ != JobState_Retry)
-{
+bool IsRetryReady(const boost::posix_time::ptime& now) const
-throw OrthancException(ErrorCode_BadSequenceOfCalls);
+{
-}
+if (state_ != JobState_Retry)
-else
+{
-{
+throw OrthancException(ErrorCode_BadSequenceOfCalls);
-return retryTime_ <= now;
+}
-}
+else
-}
+{
+return retryTime_ <= now;
-const boost::posix_time::ptime& GetCreationTime() const
+}
-{
+}
-return creationTime_;
-}
+const boost::posix_time::ptime& GetCreationTime() const
+{
-const boost::posix_time::ptime& GetLastStateChangeTime() const
+return creationTime_;
-{
+}
-return lastStateChangeTime_;
-}
+const boost::posix_time::ptime& GetLastStateChangeTime() const
+{
-const boost::posix_time::time_duration& GetRuntime() const
+return lastStateChangeTime_;
-{
+}
-return runtime_;
-}
+const boost::posix_time::time_duration& GetRuntime() const
+{
-const JobStatus& GetLastStatus() const
+return runtime_;
-{
+}
-return lastStatus_;
-}
+const JobStatus& GetLastStatus() const
+{
-void SetLastStatus(const JobStatus& status)
+return lastStatus_;
-{
+}
-lastStatus_ = status;
-Touch();
+void SetLastStatus(const JobStatus& status)
-}
+{
-};
+lastStatus_ = status;
+Touch();
+}
-class JobsRegistry : public boost::noncopyable
+};
-{
-private:
 struct PriorityComparator
 {
 bool operator() (JobHandler*& a,
 JobHandler*& b) const
 {
 target.insert(it->first);
 }
 }
-void GetJobsInfo(std::map<std::string, JobInfo>& target)
+bool GetJobInfo(JobInfo& target,
+const std::string& id)
 {
 boost::mutex::scoped_lock lock(mutex_);
 CheckInvariants();
-for (JobsIndex::const_iterator it = jobsIndex_.begin();
+JobsIndex::const_iterator found = jobsIndex_.find(id);
-it != jobsIndex_.end(); ++it)
-{
+if (found == jobsIndex_.end())
-const JobHandler& handler = *it->second;
+{
-target[it->first] = JobInfo(handler.GetId(),
+return false;
-handler.GetPriority(),
+}
-handler.GetState(),
+else
-handler.GetLastStatus(),
+{
-handler.GetCreationTime(),
+const JobHandler& handler = *found->second;
-handler.GetLastStateChangeTime(),
+target = JobInfo(handler.GetId(),
-handler.GetRuntime());
+handler.GetPriority(),
+handler.GetState(),
+handler.GetLastStatus(),
+handler.GetCreationTime(),
+handler.GetLastStateChangeTime(),
+handler.GetRuntime());
+return true;
 }
 }
 void Submit(std::string& id,
 case JobStepCode_Failure:
 running.MarkFailure();
 return false;
 case JobStepCode_Retry:
-running.MarkRetry(dynamic_cast<RetryResult&>(*result).GetTimeout());
+running.MarkRetry(dynamic_cast<JobStepRetry&>(*result).GetTimeout());
 return false;
 case JobStepCode_Continue:
 return true;
 engine.Start();
 boost::this_thread::sleep(boost::posix_time::milliseconds(100));
 {
-typedef std::map<std::string, JobInfo> Jobs;
+typedef std::set<std::string> Jobs;
 Jobs jobs;
-engine.GetRegistry().GetJobsInfo(jobs);
+engine.GetRegistry().ListJobs(jobs);
-Json::Value v;
+Json::Value v = Json::arrayValue;
 for (Jobs::const_iterator it = jobs.begin(); it != jobs.end(); ++it)
 {
-Json::Value vv;
+JobInfo info;
-it->second.Format(vv);
-v[it->first] = vv;
+if (engine.GetRegistry().GetJobInfo(info, *it))
+{
+Json::Value vv;
+info.Format(vv);
+v.append(vv);
+}
 }
 std::cout << v << std::endl;
 }
 std::cout << "====================================================" << std::endl;
 engine.Stop();
 {
-typedef std::map<std::string, JobInfo> Jobs;
+typedef std::set<std::string> Jobs;
 Jobs jobs;
-engine.GetRegistry().GetJobsInfo(jobs);
+engine.GetRegistry().ListJobs(jobs);
-Json::Value v;
+Json::Value v = Json::arrayValue;
 for (Jobs::const_iterator it = jobs.begin(); it != jobs.end(); ++it)
 {
-Json::Value vv;
+JobInfo info;
-it->second.Format(vv);
-v[it->first] = vv;
+if (engine.GetRegistry().GetJobInfo(info, *it))
+{
+Json::Value vv;
+info.Format(vv);
+v.append(vv);
+}
 }
 std::cout << v << std::endl;
 }
 }

Mercurial > hg > orthanc

comparison UnitTestsSources/MultiThreadingTests.cpp @ 2568:a46094602346 jobs