orthanc-stone: Samples/Sdl/Loader.cpp comparison

comparison Samples/Sdl/Loader.cpp @ 744:a4bfb420b869

SleepOracleCommand

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 22 May 2019 11:28:42 +0200
parents	fa5febe0f0c2
children	c44c1d2d3598

comparison

equal deleted inserted replaced

-:bcd3ea868bcd
+:a4bfb420b869
 class IOracleCommand : public boost::noncopyable
 {
 public:
 enum Type
 {
+Type_Sleep,
 Type_OrthancRestApi,
 Type_GetOrthancImage,
 Type_GetOrthancWebViewerJpeg
 };
 const Orthanc::IDynamicObject& GetPayload() const
 {
 if (HasPayload())
 {
 return *payload_;
+}
+else
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
+}
+}
+Orthanc::IDynamicObject* ReleasePayload()
+{
+if (HasPayload())
+{
+return payload_.release();
 }
 else
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 const Orthanc::OrthancException& GetException() const
 {
 return exception_;
 }
 };
+class SleepOracleCommand : public OracleCommandWithPayload
+{
+private:
+unsigned int  milliseconds_;
+public:
+ORTHANC_STONE_DEFINE_ORIGIN_MESSAGE(__FILE__, __LINE__, TimeoutMessage, SleepOracleCommand);
+SleepOracleCommand(unsigned int milliseconds) :
+milliseconds_(milliseconds)
+{
+}
+virtual Type GetType() const
+{
+return Type_Sleep;
+}
+unsigned int GetDelay() const
+{
+return milliseconds_;
+}
+};
 typedef std::map<std::string, std::string>  HttpHeaders;
 class OrthancRestApiCommand : public OracleCommandWithPayload
-class NativeOracle : public IOracle
+class ThreadedOracle : public IOracle
 {
 private:
 class Item : public Orthanc::IDynamicObject
 {
 private:
 const OrthancStone::IObserver& GetReceiver() const
 {
 return receiver_;
 }
-const IOracleCommand& GetCommand() const
+IOracleCommand& GetCommand()
 {
 assert(command_.get() != NULL);
 return *command_;
 }
 };
 enum State
 {
 State_Setup,
 State_Running,
 State_Stopped
+};
+class SleepingCommands : public boost::noncopyable
+{
+private:
+class Item
+{
+private:
+const OrthancStone::IObserver&     receiver_;
+std::auto_ptr<SleepOracleCommand>  command_;
+boost::posix_time::ptime           expiration_;
+public:
+Item(const OrthancStone::IObserver& receiver,
+SleepOracleCommand* command) :
+receiver_(receiver),
+command_(command)
+{
+if (command == NULL)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
+}
+expiration_ = (boost::posix_time::second_clock::local_time() +
+boost::posix_time::milliseconds(command_->GetDelay()));
+}
+const boost::posix_time::ptime& GetExpirationTime() const
+{
+return expiration_;
+}
+void Awake(IMessageEmitter& emitter)
+{
+assert(command_.get() != NULL);
+SleepOracleCommand::TimeoutMessage message(*command_);
+emitter.EmitMessage(receiver_, message);
+}
+};
+typedef std::list<Item*>  Content;
+boost::mutex  mutex_;
+Content       content_;
+public:
+~SleepingCommands()
+{
+for (Content::iterator it = content_.begin(); it != content_.end(); ++it)
+{
+if (*it != NULL)
+{
+delete *it;
+}
+}
+}
+void Add(const OrthancStone::IObserver& receiver,
+SleepOracleCommand* command)   // Takes ownership
+{
+boost::mutex::scoped_lock lock(mutex_);
+content_.push_back(new Item(receiver, command));
+}
+void AwakeExpired(IMessageEmitter& emitter)
+{
+boost::mutex::scoped_lock lock(mutex_);
+const boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();
+Content  stillSleeping;
+for (Content::iterator it = content_.begin(); it != content_.end(); ++it)
+{
+if (*it != NULL &&
+(*it)->GetExpirationTime() <= now)
+{
+(*it)->Awake(emitter);
+delete *it;
+*it = NULL;
+}
+else
+{
+stillSleeping.push_back(*it);
+}
+}
+// Compact the still-sleeping commands
+content_ = stillSleeping;
+}
 };
 IMessageEmitter&               emitter_;
 Orthanc::WebServiceParameters  orthanc_;
 Orthanc::SharedMessageQueue    queue_;
 State                          state_;
 boost::mutex                   mutex_;
 std::vector<boost::thread*>    workers_;
+SleepingCommands               sleepingCommands_;
+boost::thread                  sleepingWorker_;
+unsigned int                   sleepingTimeResolution_;
 void CopyHttpHeaders(Orthanc::HttpClient& client,
 const HttpHeaders& headers)
 {
 for (HttpHeaders::const_iterator it = headers.begin(); it != headers.end(); it++ )
 }
 }
 void Execute(const OrthancStone::IObserver& receiver,
+SleepOracleCommand& command)
+{
+std::auto_ptr<SleepOracleCommand> copy(new SleepOracleCommand(command.GetDelay()));
+if (command.HasPayload())
+{
+copy->SetPayload(command.ReleasePayload());
+}
+sleepingCommands_.Add(receiver, copy.release());
+}
+void Execute(const OrthancStone::IObserver& receiver,
 const OrthancRestApiCommand& command)
 {
 Orthanc::HttpClient client(orthanc_, command.GetUri());
 client.SetMethod(command.GetMethod());
 client.SetTimeout(command.GetTimeout());
 {
 std::auto_ptr<Orthanc::IDynamicObject>  object(queue_.Dequeue(100));
 if (object.get() != NULL)
 {
-const Item& item = dynamic_cast<Item&>(*object);
+Item& item = dynamic_cast<Item&>(*object);
 try
 {
 switch (item.GetCommand().GetType())
 {
+case IOracleCommand::Type_Sleep:
+Execute(item.GetReceiver(),
+dynamic_cast<SleepOracleCommand&>(item.GetCommand()));
+break;
 case IOracleCommand::Type_OrthancRestApi:
 Execute(item.GetReceiver(),
 dynamic_cast<const OrthancRestApiCommand&>(item.GetCommand()));
 break;
 }
 }
 }
-static void Worker(NativeOracle* that)
+static void Worker(ThreadedOracle* that)
 {
 assert(that != NULL);
 for (;;)
 {
 that->Step();
 }
 }
+static void SleepingWorker(ThreadedOracle* that)
+{
+assert(that != NULL);
+for (;;)
+{
+{
+boost::mutex::scoped_lock lock(that->mutex_);
+if (that->state_ != State_Running)
+{
+return;
+}
+}
+that->sleepingCommands_.AwakeExpired(that->emitter_);
+boost::this_thread::sleep(boost::posix_time::milliseconds(that->sleepingTimeResolution_));
+}
+}
 void StopInternal()
 {
 {
 boost::mutex::scoped_lock lock(mutex_);
 }
 else
 {
 state_ = State_Stopped;
 }
+}
+if (sleepingWorker_.joinable())
+{
+sleepingWorker_.join();
 }
 for (size_t i = 0; i < workers_.size(); i++)
 {
 if (workers_[i] != NULL)
 }
 }
 public:
-NativeOracle(IMessageEmitter& emitter) :
+ThreadedOracle(IMessageEmitter& emitter) :
 emitter_(emitter),
 state_(State_Setup),
-workers_(4)
+workers_(4),
-{
+sleepingTimeResolution_(50)  // By default, time resolution of 50ms
-}
+{
+}
-virtual ~NativeOracle()
+virtual ~ThreadedOracle()
 {
 StopInternal();
 }
 void SetOrthancParameters(const Orthanc::WebServiceParameters& orthanc)
 {
 workers_.resize(count);
 }
 }
+void SetSleepingTimeResolution(unsigned int milliseconds)
+{
+boost::mutex::scoped_lock lock(mutex_);
+if (milliseconds <= 0)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
+}
+else if (state_ != State_Setup)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
+}
+else
+{
+sleepingTimeResolution_ = milliseconds;
+}
+}
 void Start()
 {
 boost::mutex::scoped_lock lock(mutex_);
 if (state_ != State_Setup)
 for (unsigned int i = 0; i < workers_.size(); i++)
 {
 workers_[i] = new boost::thread(Worker, this);
 }
+sleepingWorker_ = boost::thread(SleepingWorker, this);
 }
 }
 void Stop()
 {
 class Toto : public OrthancStone::IObserver
 {
 private:
+void Handle(const Refactoring::SleepOracleCommand::TimeoutMessage& message)
+{
+printf("TIMEOUT! %d\n", dynamic_cast<const Orthanc::SingleValueObject<unsigned int>& >(message.GetOrigin().GetPayload()).GetValue());
+}
 void Handle(const Refactoring::OrthancRestApiCommand::SuccessMessage& message)
 {
 Json::Value v;
 message.ParseJsonBody(v);
 Toto(OrthancStone::IObservable& oracle) :
 IObserver(oracle.GetBroker())
 {
 oracle.RegisterObserverCallback
 (new OrthancStone::Callable
+<Toto, Refactoring::SleepOracleCommand::TimeoutMessage>(*this, &Toto::Handle));
+oracle.RegisterObserverCallback
+(new OrthancStone::Callable
 <Toto, Refactoring::OrthancRestApiCommand::SuccessMessage>(*this, &Toto::Handle));
 oracle.RegisterObserverCallback
 (new OrthancStone::Callable
 <Toto, Refactoring::GetOrthancImageCommand::SuccessMessage>(*this, &Toto::Handle));
 toto.reset(new Toto(lock.GetOracleObservable()));
 loader1.reset(new Refactoring::VolumeSeriesOrthancLoader(oracle, lock.GetOracleObservable()));
 loader2.reset(new Refactoring::VolumeSeriesOrthancLoader(oracle, lock.GetOracleObservable()));
 }
-if (1)
+if (0)
 {
 Json::Value v = Json::objectValue;
 v["Level"] = "Series";
 v["Query"] = Json::objectValue;
 command->SetBody(v);
 oracle.Schedule(*toto, command.release());
 }
-if (1)
+if (0)
 {
 std::auto_ptr<Refactoring::GetOrthancImageCommand>  command(new Refactoring::GetOrthancImageCommand);
 command->SetHttpHeader("Accept", std::string(Orthanc::EnumerationToString(Orthanc::MimeType_Jpeg)));
 command->SetUri("/instances/6687cc73-07cae193-52ff29c8-f646cb16-0753ed92/preview");
 oracle.Schedule(*toto, command.release());
 }
-if (1)
+if (0)
 {
 std::auto_ptr<Refactoring::GetOrthancImageCommand>  command(new Refactoring::GetOrthancImageCommand);
 command->SetHttpHeader("Accept", std::string(Orthanc::EnumerationToString(Orthanc::MimeType_Png)));
 command->SetUri("/instances/6687cc73-07cae193-52ff29c8-f646cb16-0753ed92/preview");
 oracle.Schedule(*toto, command.release());
 }
-if (1)
+if (0)
 {
 std::auto_ptr<Refactoring::GetOrthancImageCommand>  command(new Refactoring::GetOrthancImageCommand);
 command->SetHttpHeader("Accept", std::string(Orthanc::EnumerationToString(Orthanc::MimeType_Png)));
 command->SetUri("/instances/6687cc73-07cae193-52ff29c8-f646cb16-0753ed92/image-uint16");
 oracle.Schedule(*toto, command.release());
 }
-if (1)
+if (0)
 {
 std::auto_ptr<Refactoring::GetOrthancImageCommand>  command(new Refactoring::GetOrthancImageCommand);
 command->SetHttpHeader("Accept-Encoding", "gzip");
 command->SetHttpHeader("Accept", std::string(Orthanc::EnumerationToString(Orthanc::MimeType_Pam)));
 command->SetUri("/instances/6687cc73-07cae193-52ff29c8-f646cb16-0753ed92/image-uint16");
 oracle.Schedule(*toto, command.release());
 }
-if (1)
+if (0)
 {
 std::auto_ptr<Refactoring::GetOrthancImageCommand>  command(new Refactoring::GetOrthancImageCommand);
 command->SetHttpHeader("Accept", std::string(Orthanc::EnumerationToString(Orthanc::MimeType_Pam)));
 command->SetUri("/instances/6687cc73-07cae193-52ff29c8-f646cb16-0753ed92/image-uint16");
 oracle.Schedule(*toto, command.release());
 }
-if (1)
+if (0)
 {
 std::auto_ptr<Refactoring::GetOrthancWebViewerJpegCommand>  command(new Refactoring::GetOrthancWebViewerJpegCommand);
 command->SetHttpHeader("Accept-Encoding", "gzip");
 command->SetInstance("e6c7c20b-c9f65d7e-0d76f2e2-830186f2-3e3c600e");
 command->SetQuality(90);
 oracle.Schedule(*toto, command.release());
 }
+if (0)
+{
+for (unsigned int i = 0; i < 10; i++)
+{
+std::auto_ptr<Refactoring::SleepOracleCommand> command(new Refactoring::SleepOracleCommand(i * 1000));
+command->SetPayload(new Orthanc::SingleValueObject<unsigned int>(42 * i));
+oracle.Schedule(*toto, command.release());
+}
+}
 // 2017-11-17-Anonymized
 //loader1->LoadSeries("cb3ea4d1-d08f3856-ad7b6314-74d88d77-60b05618");  // CT
 //loader2->LoadInstance("41029085-71718346-811efac4-420e2c15-d39f99b6");  // RT-DOSE
 // Delphine
-loader1->LoadSeries("5990e39c-51e5f201-fe87a54c-31a55943-e59ef80e");  // CT
+//loader1->LoadSeries("5990e39c-51e5f201-fe87a54c-31a55943-e59ef80e");  // CT
+loader1->LoadSeries("67f1b334-02c16752-45026e40-a5b60b6b-030ecab5");  // Lung 1/10mm
 LOG(WARNING) << "...Waiting for Ctrl-C...";
 Orthanc::SystemToolbox::ServerBarrier();
 //boost::this_thread::sleep(boost::posix_time::seconds(1));
 }
 try
 {
 Refactoring::NativeApplicationContext context;
-Refactoring::NativeOracle oracle(context);
+Refactoring::ThreadedOracle oracle(context);
 {
 Orthanc::WebServiceParameters p;
 //p.SetUrl("http://localhost:8043/");
 p.SetCredentials("orthanc", "orthanc");

Mercurial > hg > orthanc-stone

comparison Samples/Sdl/Loader.cpp @ 744:a4bfb420b869