orthanc: OrthancServer/OrthancRestApi/OrthancRestArchive.cpp comparison

comparison OrthancServer/OrthancRestApi/OrthancRestArchive.cpp @ 2627:00b6a7f935fc jobs

refactoring of archive creation

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Fri, 25 May 2018 14:07:52 +0200
parents	878b59270859
children	7ba7d5806911

comparison

equal deleted inserted replaced

-:e09021ddc00d
+:00b6a7f935fc
 // Download of ZIP files ----------------------------------------------------
 static bool IsZip64Required(uint64_t uncompressedSize,
 unsigned int countInstances)
 {
-static const uint64_t  SAFETY_MARGIN = 64 * MEGA_BYTES;
+static const uint64_t      SAFETY_MARGIN = 64 * MEGA_BYTES;  // Should be large enough to hold DICOMDIR
+static const unsigned int  FILES_MARGIN = 10;
 /**
 * Determine whether ZIP64 is required. Original ZIP format can
 * store up to 2GB of data (some implementation supporting up to
 * 4GB of data), and up to 65535 files.
 * https://en.wikipedia.org/wiki/Zip_(file_format)#ZIP64
 **/
 const bool isZip64 = (uncompressedSize >= 2 * GIGA_BYTES - SAFETY_MARGIN ||
-countInstances >= 65535);
+countInstances >= 65535 - FILES_MARGIN);
 LOG(INFO) << "Creating a ZIP file with " << countInstances << " files of size "
 << (uncompressedSize / MEGA_BYTES) << "MB using the "
 << (isZip64 ? "ZIP64" : "ZIP32") << " file format";
 }
 namespace
 {
-class ResourceIdentifiers
+class ResourceIdentifiers : public boost::noncopyable
 {
 private:
 ResourceType   level_;
 std::string    patient_;
 std::string    study_;
 virtual void AddInstance(const std::string& instanceId,
 const FileInfo& dicom) = 0;
 };
-class ArchiveIndex
+class ArchiveIndex : public boost::noncopyable
 {
 private:
 struct Instance
 {
 std::string  id_;
 }
 }
 };
-class StatisticsVisitor : public IArchiveVisitor
+class ArchiveCommands : public boost::noncopyable
 {
 private:
-uint64_t       size_;
+enum Type
-unsigned int   instances_;
+{
+Type_OpenDirectory,
+Type_CloseDirectory,
+Type_WriteInstance
+};
+class Command : public boost::noncopyable
+{
+private:
+Type          type_;
+std::string   filename_;
+std::string   instanceId_;
+FileInfo      info_;
+public:
+explicit Command(Type type) :
+type_(type)
+{
+assert(type_ == Type_CloseDirectory);
+}
+Command(Type type,
+const std::string& filename) :
+type_(type),
+filename_(filename)
+{
+assert(type_ == Type_OpenDirectory);
+}
+Command(Type type,
+const std::string& filename,
+const std::string& instanceId,
+const FileInfo& info) :
+type_(type),
+filename_(filename),
+instanceId_(instanceId),
+info_(info)
+{
+assert(type_ == Type_WriteInstance);
+}
+void Apply(HierarchicalZipWriter& writer,
+ServerContext& context,
+DicomDirWriter* dicomDir,
+const std::string& dicomDirFolder) const
+{
+switch (type_)
+{
+case Type_OpenDirectory:
+writer.OpenDirectory(filename_.c_str());
+break;
+case Type_CloseDirectory:
+writer.CloseDirectory();
+break;
+case Type_WriteInstance:
+{
+std::string content;
+try
+{
+context.ReadAttachment(content, info_);
+}
+catch (OrthancException& e)
+{
+LOG(WARNING) << "An instance was removed after the job was issued: " << instanceId_;
+return;
+}
+writer.OpenFile(filename_.c_str());
+writer.Write(content);
+if (dicomDir != NULL)
+{
+ParsedDicomFile parsed(content);
+dicomDir->Add(dicomDirFolder, filename_, parsed);
+}
+break;
+}
+default:
+throw OrthancException(ErrorCode_InternalError);
+}
+}
+};
+std::deque<Command*>  commands_;
+uint64_t              uncompressedSize_;
+unsigned int          instancesCount_;
+void ApplyInternal(HierarchicalZipWriter& writer,
+ServerContext& context,
+size_t index,
+DicomDirWriter* dicomDir,
+const std::string& dicomDirFolder) const
+{
+if (index >= commands_.size())
+{
+throw OrthancException(ErrorCode_ParameterOutOfRange);
+}
+commands_[index]->Apply(writer, context, dicomDir, dicomDirFolder);
+}
 public:
-StatisticsVisitor() : size_(0), instances_(0)
+ArchiveCommands() :
-{
+uncompressedSize_(0),
+instancesCount_(0)
+{
+}
+~ArchiveCommands()
+{
+for (std::deque<Command*>::iterator it = commands_.begin();
+it != commands_.end(); ++it)
+{
+assert(*it != NULL);
+delete *it;
+}
+}
+size_t GetSize() const
+{
+return commands_.size();
+}
+unsigned int GetInstancesCount() const
+{
+return instancesCount_;
 }
 uint64_t GetUncompressedSize() const
 {
-return size_;
+return uncompressedSize_;
 }
-unsigned int GetInstancesCount() const
+void Apply(HierarchicalZipWriter& writer,
-{
+ServerContext& context,
-return instances_;
+size_t index,
-}
+DicomDirWriter& dicomDir,
+const std::string& dicomDirFolder) const
-virtual void Open(ResourceType level,
+{
-const std::string& publicId)
+ApplyInternal(writer, context, index, &dicomDir, dicomDirFolder);
-{
+}
-}
+void Apply(HierarchicalZipWriter& writer,
-virtual void Close()
+ServerContext& context,
-{
+size_t index) const
-}
+{
+ApplyInternal(writer, context, index, NULL, "");
-virtual void AddInstance(const std::string& instanceId,
+}
-const FileInfo& dicom)
-{
+void AddOpenDirectory(const std::string& filename)
-instances_ ++;
+{
-size_ += dicom.GetUncompressedSize();
+commands_.push_back(new Command(Type_OpenDirectory, filename));
+}
+void AddCloseDirectory()
+{
+commands_.push_back(new Command(Type_CloseDirectory));
+}
+void AddWriteInstance(const std::string& filename,
+const std::string& instanceId,
+const FileInfo& info)
+{
+commands_.push_back(new Command(Type_WriteInstance, filename, instanceId, info));
+instancesCount_ ++;
+uncompressedSize_ += info.GetUncompressedSize();
+}
+bool IsZip64() const
+{
+return IsZip64Required(GetUncompressedSize(), GetInstancesCount());
 }
 };
-class PrintVisitor : public IArchiveVisitor
+class ArchiveWriterVisitor : public IArchiveVisitor
 {
 private:
-std::ostream& out_;
+ArchiveCommands&  commands_;
-std::string   indent_;
+ServerContext&    context_;
+char              instanceFormat_[24];
-public:
+unsigned int      counter_;
-PrintVisitor(std::ostream& out) : out_(out)
-{
-}
-virtual void Open(ResourceType level,
-const std::string& publicId)
-{
-switch (level)
-{
-case ResourceType_Patient:  indent_ = "";       break;
-case ResourceType_Study:    indent_ = "  ";     break;
-case ResourceType_Series:   indent_ = "    ";   break;
-default:
-throw OrthancException(ErrorCode_InternalError);
-}
-out_ << indent_ << publicId << std::endl;
-}
-virtual void Close()
-{
-}
-virtual void AddInstance(const std::string& instanceId,
-const FileInfo& dicom)
-{
-out_ << "      " << instanceId << std::endl;
-}
-};
-class ArchiveWriterVisitor : public IArchiveVisitor
-{
-private:
-HierarchicalZipWriter&  writer_;
-ServerContext&            context_;
-char                    instanceFormat_[24];
-unsigned int            countInstances_;
 static std::string GetTag(const DicomMap& tags,
 const DicomTag& tag)
 {
 const DicomValue* v = tags.TestAndGetValue(tag);
 return "";
 }
 }
 public:
-ArchiveWriterVisitor(HierarchicalZipWriter& writer,
+ArchiveWriterVisitor(ArchiveCommands& commands,
 ServerContext& context) :
-writer_(writer),
+commands_(commands),
 context_(context),
-countInstances_(0)
+counter_(0)
 {
+if (commands.GetSize() != 0)
+{
+throw OrthancException(ErrorCode_BadSequenceOfCalls);
+}
 snprintf(instanceFormat_, sizeof(instanceFormat_) - 1, "%%08d.dcm");
 }
 virtual void Open(ResourceType level,
 const std::string& publicId)
 {
 snprintf(instanceFormat_, sizeof(instanceFormat_) - 1, "%c%c%%06d.dcm",
 toupper(modality[0]), toupper(modality[1]));
 }
-countInstances_ = 0;
+counter_ = 0;
 break;
 }
 default:
 if (path.empty())
 {
 path = std::string("Unknown ") + EnumerationToString(level);
 }
-writer_.OpenDirectory(path.c_str());
+commands_.AddOpenDirectory(path.c_str());
 }
 virtual void Close()
 {
-writer_.CloseDirectory();
+commands_.AddCloseDirectory();
 }
 virtual void AddInstance(const std::string& instanceId,
 const FileInfo& dicom)
 {
-std::string content;
-context_.ReadAttachment(content, dicom);
 char filename[24];
-snprintf(filename, sizeof(filename) - 1, instanceFormat_, countInstances_);
+snprintf(filename, sizeof(filename) - 1, instanceFormat_, counter_);
-countInstances_ ++;
+counter_ ++;
-writer_.OpenFile(filename);
+commands_.AddWriteInstance(filename, instanceId, dicom);
-writer_.Write(content);
 }
 static void Apply(RestApiOutput& output,
 ServerContext& context,
 ArchiveIndex& archive,
 const std::string& filename)
 {
-archive.Expand(context.GetIndex());
+ArchiveCommands commands;
-StatisticsVisitor stats;
+{
-archive.Apply(stats);
+ArchiveWriterVisitor visitor(commands, context);
+archive.Expand(context.GetIndex());
-const bool isZip64 = IsZip64Required(stats.GetUncompressedSize(), stats.GetInstancesCount());
+archive.Apply(visitor);
+}
 // Create a RAII for the temporary file to manage the ZIP file
 TemporaryFile tmp;
 {
-// Create a ZIP writer
 HierarchicalZipWriter writer(tmp.GetPath().c_str());
-writer.SetZip64(isZip64);
+writer.SetZip64(commands.IsZip64());
-ArchiveWriterVisitor v(writer, context);
+for (size_t i = 0; i < commands.GetSize(); i++)
-archive.Apply(v);
+{
+commands.Apply(writer, context, i);
+}
 }
 // Prepare the sending of the ZIP file
 FilesystemHttpSender sender(tmp.GetPath());
 sender.SetContentType("application/zip");
 class MediaWriterVisitor : public IArchiveVisitor
 {
 private:
-HierarchicalZipWriter&  writer_;
+ArchiveCommands&  commands_;
-DicomDirWriter          dicomDir_;
+ServerContext&    context_;
-ServerContext&          context_;
+unsigned int      counter_;
-unsigned int            countInstances_;
 public:
-MediaWriterVisitor(HierarchicalZipWriter& writer,
+MediaWriterVisitor(ArchiveCommands& commands,
 ServerContext& context) :
-writer_(writer),
+commands_(commands),
 context_(context),
-countInstances_(0)
+counter_(0)
 {
-}
-void EncodeDicomDir(std::string& result)
-{
-dicomDir_.Encode(result);
 }
 virtual void Open(ResourceType level,
 const std::string& publicId)
 {
 const FileInfo& dicom)
 {
 // "DICOM restricts the filenames on DICOM media to 8
 // characters (some systems wrongly use 8.3, but this does not
 // conform to the standard)."
-std::string filename = "IM" + boost::lexical_cast<std::string>(countInstances_);
+std::string filename = "IM" + boost::lexical_cast<std::string>(counter_);
-writer_.OpenFile(filename.c_str());
+commands_.AddWriteInstance(filename, instanceId, dicom);
-std::string content;
+counter_ ++;
-context_.ReadAttachment(content, dicom);
-writer_.Write(content);
-ParsedDicomFile parsed(content);
-dicomDir_.Add("IMAGES", filename, parsed);
-countInstances_ ++;
 }
 static void Apply(RestApiOutput& output,
 ServerContext& context,
 ArchiveIndex& archive,
 const std::string& filename,
 bool enableExtendedSopClass)
 {
-archive.Expand(context.GetIndex());
+static const char* IMAGES_FOLDER = "IMAGES";
-StatisticsVisitor stats;
+ArchiveCommands commands;
-archive.Apply(stats);
+{
-const bool isZip64 = IsZip64Required(stats.GetUncompressedSize(), stats.GetInstancesCount());
+MediaWriterVisitor visitor(commands, context);
+archive.Expand(context.GetIndex());
+commands.AddOpenDirectory(IMAGES_FOLDER);
+archive.Apply(visitor);
+commands.AddCloseDirectory();
+}
 // Create a RAII for the temporary file to manage the ZIP file
 TemporaryFile tmp;
 {
-// Create a ZIP writer
+DicomDirWriter dicomDir;
+dicomDir.EnableExtendedSopClass(enableExtendedSopClass);
 HierarchicalZipWriter writer(tmp.GetPath().c_str());
-writer.SetZip64(isZip64);
+writer.SetZip64(commands.IsZip64());
-writer.OpenDirectory("IMAGES");
+for (size_t i = 0; i < commands.GetSize(); i++)
-// Create a DICOMDIR writer
+{
-MediaWriterVisitor v(writer, context);
+commands.Apply(writer, context, i, dicomDir, IMAGES_FOLDER);
+}
-// Request type-3 arguments to be added to the DICOMDIR
-v.dicomDir_.EnableExtendedSopClass(enableExtendedSopClass);
-archive.Apply(v);
 // Add the DICOMDIR
-writer.CloseDirectory();
 writer.OpenFile("DICOMDIR");
 std::string s;
-v.EncodeDicomDir(s);
+dicomDir.Encode(s);
 writer.Write(s);
 }
 // Prepare the sending of the ZIP file
 FilesystemHttpSender sender(tmp.GetPath());
 sender.SetContentType("application/zip");
 sender.SetContentFilename(filename);
 output.AnswerStream(sender);
 // The temporary file is automatically removed thanks to the RAII
 }
 };
+#if 0
+class ArchiveJob : public IJob
+{
+private:
+ServerContext&                        context_;
+ArchiveIndex                          archive_;
+bool                                  isMedia_;
+std::auto_ptr<TemporaryFile>          file_;
+std::auto_ptr<HierarchicalZipWriter>  writer_;
+std::auto_ptr<IArchiveVisitor>        visitor_;
+std::string                           description_;
+bool                                  started_;
+unsigned int                          currentInstance_;
+public:
+ArchiveJob(ServerContext& context,
+ResourceType level,
+bool isMedia) :
+context_(context),
+archive_(level),
+isMedia_(isMedia),
+started_(false),
+currentInstance_(0)
+{
+}
+void SetDescription(const std::string& description)
+{
+description_ = description;
+}
+const std::string& GetDescription() const
+{
+return description_;
+}
+void AddResource(const std::string& publicId)
+{
+if (started_)
+{
+throw OrthancException(ErrorCode_BadSequenceOfCalls);
+}
+ResourceIdentifiers resource(context_.GetIndex(), publicId);
+archive_.Add(context_.GetIndex(), resource);
+}
+virtual void SignalResubmit()
+{
+LOG(ERROR) << "Cannot resubmit the creation of an archive";
+throw OrthancException(ErrorCode_BadSequenceOfCalls);
+}
+virtual void Start()
+{
+if (started_)
+{
+throw OrthancException(ErrorCode_BadSequenceOfCalls);
+}
+started_ = true;
+archive_.Expand(context_.GetIndex());
+const bool isZip64 = IsZip64Required(stats_.GetUncompressedSize(), stats_.GetInstancesCount());
+file_.reset(new TemporaryFile);
+writer_.reset(new HierarchicalZipWriter(file_->GetPath().c_str()));
+writer_->SetZip64(isZip64);
+if (isMedia_)
+{
+//visitor_.reset(new
+}
+}
+};
+#endif
 }
 static bool AddResourcesOfInterest(ArchiveIndex& archive,
 RestApiPostCall& call)

Mercurial > hg > orthanc

comparison OrthancServer/OrthancRestApi/OrthancRestArchive.cpp @ 2627:00b6a7f935fc jobs