Mercurial > hg > orthanc
annotate OrthancServer/ServerIndex.cpp @ 681:3bdb5db8e839 query-retrieve
generalization of query/retrieve
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Fri, 24 Jan 2014 17:40:45 +0100 |
| parents | 08eca5d86aad |
| children | 67e6400fca03 |
| rev | line source |
|---|---|
| 0 | 1 /** |
| 62 | 2 * Orthanc - A Lightweight, RESTful DICOM Store |
| 399 | 3 * Copyright (C) 2012-2013 Medical Physics Department, CHU of Liege, |
| 0 | 4 * Belgium |
| 5 * | |
| 6 * This program is free software: you can redistribute it and/or | |
| 7 * modify it under the terms of the GNU General Public License as | |
| 8 * published by the Free Software Foundation, either version 3 of the | |
| 9 * License, or (at your option) any later version. | |
| 136 | 10 * |
| 11 * In addition, as a special exception, the copyright holders of this | |
| 12 * program give permission to link the code of its release with the | |
| 13 * OpenSSL project's "OpenSSL" library (or with modified versions of it | |
| 14 * that use the same license as the "OpenSSL" library), and distribute | |
| 15 * the linked executables. You must obey the GNU General Public License | |
| 16 * in all respects for all of the code used other than "OpenSSL". If you | |
| 17 * modify file(s) with this exception, you may extend this exception to | |
| 18 * your version of the file(s), but you are not obligated to do so. If | |
| 19 * you do not wish to do so, delete this exception statement from your | |
| 20 * version. If you delete this exception statement from all source files | |
| 21 * in the program, then also delete it here. | |
| 0 | 22 * |
| 23 * This program is distributed in the hope that it will be useful, but | |
| 24 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 26 * General Public License for more details. | |
| 27 * | |
| 28 * You should have received a copy of the GNU General Public License | |
| 29 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 30 **/ | |
| 31 | |
| 32 | |
| 33 #include "ServerIndex.h" | |
| 34 | |
| 6 | 35 #ifndef NOMINMAX |
| 2 | 36 #define NOMINMAX |
| 6 | 37 #endif |
| 38 | |
| 8 | 39 #include "EmbeddedResources.h" |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
40 #include "OrthancInitialization.h" |
| 0 | 41 #include "../Core/Toolbox.h" |
| 42 #include "../Core/Uuid.h" | |
| 43 #include "../Core/DicomFormat/DicomArray.h" | |
| 44 #include "../Core/SQLite/Transaction.h" | |
| 45 #include "FromDcmtkBridge.h" | |
|
226
8a26a8e85edf
refactoring to read files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
224
diff
changeset
|
46 #include "ServerContext.h" |
| 0 | 47 |
| 48 #include <boost/lexical_cast.hpp> | |
| 49 #include <stdio.h> | |
| 108 | 50 #include <glog/logging.h> |
| 0 | 51 |
|
440
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
52 static const uint64_t MEGA_BYTES = 1024 * 1024; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
53 |
| 62 | 54 namespace Orthanc |
| 0 | 55 { |
| 56 namespace Internals | |
| 57 { | |
| 202 | 58 class ServerIndexListener : public IServerIndexListener |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
59 { |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
60 private: |
|
226
8a26a8e85edf
refactoring to read files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
224
diff
changeset
|
61 ServerContext& context_; |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
62 bool hasRemainingLevel_; |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
63 ResourceType remainingType_; |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
64 std::string remainingPublicId_; |
|
264
5b8e8b74bc8b
remove files only after the sqlite transaction has succeeded
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
240
diff
changeset
|
65 std::list<std::string> pendingFilesToRemove_; |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
66 uint64_t sizeOfFilesToRemove_; |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
67 |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
68 public: |
|
226
8a26a8e85edf
refactoring to read files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
224
diff
changeset
|
69 ServerIndexListener(ServerContext& context) : |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
70 context_(context) |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
71 { |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
72 Reset(); |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
73 assert(ResourceType_Patient < ResourceType_Study && |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
74 ResourceType_Study < ResourceType_Series && |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
75 ResourceType_Series < ResourceType_Instance); |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
76 } |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
77 |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
78 void Reset() |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
79 { |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
80 sizeOfFilesToRemove_ = 0; |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
81 hasRemainingLevel_ = false; |
|
264
5b8e8b74bc8b
remove files only after the sqlite transaction has succeeded
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
240
diff
changeset
|
82 pendingFilesToRemove_.clear(); |
|
5b8e8b74bc8b
remove files only after the sqlite transaction has succeeded
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
240
diff
changeset
|
83 } |
|
5b8e8b74bc8b
remove files only after the sqlite transaction has succeeded
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
240
diff
changeset
|
84 |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
85 uint64_t GetSizeOfFilesToRemove() |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
86 { |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
87 return sizeOfFilesToRemove_; |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
88 } |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
89 |
|
264
5b8e8b74bc8b
remove files only after the sqlite transaction has succeeded
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
240
diff
changeset
|
90 void CommitFilesToRemove() |
|
5b8e8b74bc8b
remove files only after the sqlite transaction has succeeded
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
240
diff
changeset
|
91 { |
|
5b8e8b74bc8b
remove files only after the sqlite transaction has succeeded
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
240
diff
changeset
|
92 for (std::list<std::string>::iterator |
|
5b8e8b74bc8b
remove files only after the sqlite transaction has succeeded
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
240
diff
changeset
|
93 it = pendingFilesToRemove_.begin(); |
| 656 | 94 it != pendingFilesToRemove_.end(); ++it) |
|
264
5b8e8b74bc8b
remove files only after the sqlite transaction has succeeded
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
240
diff
changeset
|
95 { |
|
5b8e8b74bc8b
remove files only after the sqlite transaction has succeeded
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
240
diff
changeset
|
96 context_.RemoveFile(*it); |
|
5b8e8b74bc8b
remove files only after the sqlite transaction has succeeded
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
240
diff
changeset
|
97 } |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
98 } |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
99 |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
100 virtual void SignalRemainingAncestor(ResourceType parentType, |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
101 const std::string& publicId) |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
102 { |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
103 LOG(INFO) << "Remaining ancestor \"" << publicId << "\" (" << parentType << ")"; |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
104 |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
105 if (hasRemainingLevel_) |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
106 { |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
107 if (parentType < remainingType_) |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
108 { |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
109 remainingType_ = parentType; |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
110 remainingPublicId_ = publicId; |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
111 } |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
112 } |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
113 else |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
114 { |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
115 hasRemainingLevel_ = true; |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
116 remainingType_ = parentType; |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
117 remainingPublicId_ = publicId; |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
118 } |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
119 } |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
120 |
|
273
d384af918264
more detailed signal about deleted file
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
272
diff
changeset
|
121 virtual void SignalFileDeleted(const FileInfo& info) |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
122 { |
|
273
d384af918264
more detailed signal about deleted file
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
272
diff
changeset
|
123 assert(Toolbox::IsUuid(info.GetUuid())); |
|
d384af918264
more detailed signal about deleted file
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
272
diff
changeset
|
124 pendingFilesToRemove_.push_back(info.GetUuid()); |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
125 sizeOfFilesToRemove_ += info.GetCompressedSize(); |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
126 } |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
127 |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
128 bool HasRemainingLevel() const |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
129 { |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
130 return hasRemainingLevel_; |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
131 } |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
132 |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
133 ResourceType GetRemainingType() const |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
134 { |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
135 assert(HasRemainingLevel()); |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
136 return remainingType_; |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
137 } |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
138 |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
139 const std::string& GetRemainingPublicId() const |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
140 { |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
141 assert(HasRemainingLevel()); |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
142 return remainingPublicId_; |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
143 } |
|
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
144 }; |
| 0 | 145 } |
| 146 | |
| 147 | |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
148 class ServerIndex::Transaction |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
149 { |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
150 private: |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
151 ServerIndex& index_; |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
152 std::auto_ptr<SQLite::Transaction> transaction_; |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
153 bool isCommitted_; |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
154 |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
155 public: |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
156 Transaction(ServerIndex& index) : |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
157 index_(index), |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
158 isCommitted_(false) |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
159 { |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
160 assert(index_.currentStorageSize_ == index_.db_->GetTotalCompressedSize()); |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
161 |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
162 index_.listener_->Reset(); |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
163 transaction_.reset(index_.db_->StartTransaction()); |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
164 transaction_->Begin(); |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
165 } |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
166 |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
167 void Commit(uint64_t sizeOfAddedFiles) |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
168 { |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
169 if (!isCommitted_) |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
170 { |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
171 transaction_->Commit(); |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
172 |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
173 // We can remove the files once the SQLite transaction has |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
174 // been successfully committed. Some files might have to be |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
175 // deleted because of recycling. |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
176 index_.listener_->CommitFilesToRemove(); |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
177 |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
178 index_.currentStorageSize_ += sizeOfAddedFiles; |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
179 |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
180 assert(index_.currentStorageSize_ >= index_.listener_->GetSizeOfFilesToRemove()); |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
181 index_.currentStorageSize_ -= index_.listener_->GetSizeOfFilesToRemove(); |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
182 |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
183 assert(index_.currentStorageSize_ == index_.db_->GetTotalCompressedSize()); |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
184 |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
185 isCommitted_ = true; |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
186 } |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
187 } |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
188 }; |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
189 |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
190 |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
191 struct ServerIndex::UnstableResourcePayload |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
192 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
193 Orthanc::ResourceType type_; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
194 boost::posix_time::ptime time_; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
195 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
196 UnstableResourcePayload() : type_(Orthanc::ResourceType_Instance) |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
197 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
198 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
199 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
200 UnstableResourcePayload(Orthanc::ResourceType type) : type_(type) |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
201 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
202 time_ = boost::posix_time::second_clock::local_time(); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
203 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
204 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
205 unsigned int GetAge() const |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
206 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
207 return (boost::posix_time::second_clock::local_time() - time_).total_seconds(); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
208 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
209 }; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
210 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
211 |
| 212 | 212 bool ServerIndex::DeleteResource(Json::Value& target, |
| 0 | 213 const std::string& uuid, |
| 202 | 214 ResourceType expectedType) |
| 0 | 215 { |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
216 boost::mutex::scoped_lock lock(mutex_); |
| 202 | 217 listener_->Reset(); |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
218 |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
219 Transaction t(*this); |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
220 |
| 202 | 221 int64_t id; |
| 222 ResourceType type; | |
| 223 if (!db_->LookupResource(uuid, id, type) || | |
| 224 expectedType != type) | |
| 0 | 225 { |
| 226 return false; | |
| 227 } | |
| 202 | 228 |
| 229 db_->DeleteResource(id); | |
| 0 | 230 |
| 202 | 231 if (listener_->HasRemainingLevel()) |
| 0 | 232 { |
| 202 | 233 ResourceType type = listener_->GetRemainingType(); |
| 234 const std::string& uuid = listener_->GetRemainingPublicId(); | |
| 0 | 235 |
| 236 target["RemainingAncestor"] = Json::Value(Json::objectValue); | |
| 204 | 237 target["RemainingAncestor"]["Path"] = GetBasePath(type, uuid); |
|
434
ccf3a0a43dac
EnumerationDictionary
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
433
diff
changeset
|
238 target["RemainingAncestor"]["Type"] = EnumerationToString(type); |
| 0 | 239 target["RemainingAncestor"]["ID"] = uuid; |
| 240 } | |
| 241 else | |
| 242 { | |
| 243 target["RemainingAncestor"] = Json::nullValue; | |
| 244 } | |
| 245 | |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
246 t.Commit(0); |
|
264
5b8e8b74bc8b
remove files only after the sqlite transaction has succeeded
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
240
diff
changeset
|
247 |
| 0 | 248 return true; |
| 249 } | |
| 250 | |
| 251 | |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
252 void ServerIndex::FlushThread(ServerIndex* that) |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
253 { |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
254 unsigned int sleep; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
255 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
256 try |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
257 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
258 std::string sleepString = that->db_->GetGlobalProperty(GlobalProperty_FlushSleep); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
259 sleep = boost::lexical_cast<unsigned int>(sleepString); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
260 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
261 catch (boost::bad_lexical_cast&) |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
262 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
263 // By default, wait for 10 seconds before flushing |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
264 sleep = 10; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
265 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
266 |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
267 LOG(INFO) << "Starting the database flushing thread (sleep = " << sleep << ")"; |
|
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
268 |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
269 unsigned int count = 0; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
270 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
271 while (!that->done_) |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
272 { |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
273 boost::this_thread::sleep(boost::posix_time::seconds(1)); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
274 count++; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
275 if (count < sleep) |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
276 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
277 continue; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
278 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
279 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
280 boost::mutex::scoped_lock lock(that->mutex_); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
281 that->db_->FlushToDisk(); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
282 count = 0; |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
283 } |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
284 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
285 LOG(INFO) << "Stopping the database flushing thread"; |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
286 } |
|
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
287 |
|
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
288 |
| 433 | 289 static void ComputeExpectedNumberOfInstances(DatabaseWrapper& db, |
| 290 int64_t series, | |
| 291 const DicomMap& dicomSummary) | |
| 292 { | |
| 293 try | |
| 294 { | |
| 656 | 295 const DicomValue* value; |
| 296 const DicomValue* value2; | |
| 297 | |
| 433 | 298 if ((value = dicomSummary.TestAndGetValue(DICOM_TAG_IMAGES_IN_ACQUISITION)) != NULL && |
| 299 (value2 = dicomSummary.TestAndGetValue(DICOM_TAG_NUMBER_OF_TEMPORAL_POSITIONS)) != NULL) | |
| 300 { | |
| 301 // Patch for series with temporal positions thanks to Will Ryder | |
| 302 int64_t imagesInAcquisition = boost::lexical_cast<int64_t>(value->AsString()); | |
| 303 int64_t countTemporalPositions = boost::lexical_cast<int64_t>(value2->AsString()); | |
| 304 std::string expected = boost::lexical_cast<std::string>(imagesInAcquisition * countTemporalPositions); | |
| 305 db.SetMetadata(series, MetadataType_Series_ExpectedNumberOfInstances, expected); | |
| 306 } | |
| 307 | |
| 308 else if ((value = dicomSummary.TestAndGetValue(DICOM_TAG_NUMBER_OF_SLICES)) != NULL && | |
| 309 (value2 = dicomSummary.TestAndGetValue(DICOM_TAG_NUMBER_OF_TIME_SLICES)) != NULL) | |
| 310 { | |
| 311 // Support of Cardio-PET images | |
| 312 int64_t numberOfSlices = boost::lexical_cast<int64_t>(value->AsString()); | |
| 313 int64_t numberOfTimeSlices = boost::lexical_cast<int64_t>(value2->AsString()); | |
| 314 std::string expected = boost::lexical_cast<std::string>(numberOfSlices * numberOfTimeSlices); | |
| 315 db.SetMetadata(series, MetadataType_Series_ExpectedNumberOfInstances, expected); | |
| 316 } | |
| 317 | |
| 318 else if ((value = dicomSummary.TestAndGetValue(DICOM_TAG_CARDIAC_NUMBER_OF_IMAGES)) != NULL) | |
| 319 { | |
| 320 db.SetMetadata(series, MetadataType_Series_ExpectedNumberOfInstances, value->AsString()); | |
| 321 } | |
| 322 } | |
| 323 catch (boost::bad_lexical_cast) | |
| 324 { | |
| 325 } | |
| 326 } | |
| 327 | |
| 328 | |
|
226
8a26a8e85edf
refactoring to read files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
224
diff
changeset
|
329 ServerIndex::ServerIndex(ServerContext& context, |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
330 const std::string& dbPath) : |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
331 done_(false), |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
332 maximumStorageSize_(0), |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
333 maximumPatients_(0) |
|
186
f68c039b0571
preparing refactoring of ServerIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
180
diff
changeset
|
334 { |
|
226
8a26a8e85edf
refactoring to read files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
224
diff
changeset
|
335 listener_.reset(new Internals::ServerIndexListener(context)); |
|
186
f68c039b0571
preparing refactoring of ServerIndex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
180
diff
changeset
|
336 |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
337 if (dbPath == ":memory:") |
|
180
626777d01dc4
use of hashes to index dicom objects
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
179
diff
changeset
|
338 { |
| 202 | 339 db_.reset(new DatabaseWrapper(*listener_)); |
|
180
626777d01dc4
use of hashes to index dicom objects
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
179
diff
changeset
|
340 } |
|
626777d01dc4
use of hashes to index dicom objects
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
179
diff
changeset
|
341 else |
| 0 | 342 { |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
343 boost::filesystem::path p = dbPath; |
|
180
626777d01dc4
use of hashes to index dicom objects
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
179
diff
changeset
|
344 |
|
626777d01dc4
use of hashes to index dicom objects
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
179
diff
changeset
|
345 try |
|
626777d01dc4
use of hashes to index dicom objects
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
179
diff
changeset
|
346 { |
|
201
bee20e978835
refactoring of delete
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
200
diff
changeset
|
347 boost::filesystem::create_directories(p); |
|
180
626777d01dc4
use of hashes to index dicom objects
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
179
diff
changeset
|
348 } |
|
626777d01dc4
use of hashes to index dicom objects
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
179
diff
changeset
|
349 catch (boost::filesystem::filesystem_error) |
|
626777d01dc4
use of hashes to index dicom objects
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
179
diff
changeset
|
350 { |
|
626777d01dc4
use of hashes to index dicom objects
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
179
diff
changeset
|
351 } |
|
626777d01dc4
use of hashes to index dicom objects
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
179
diff
changeset
|
352 |
| 202 | 353 db_.reset(new DatabaseWrapper(p.string() + "/index", *listener_)); |
| 0 | 354 } |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
355 |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
356 currentStorageSize_ = db_->GetTotalCompressedSize(); |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
357 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
358 // Initial recycling if the parameters have changed since the last |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
359 // execution of Orthanc |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
360 StandaloneRecycling(); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
361 |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
362 flushThread_ = boost::thread(FlushThread, this); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
363 unstableResourcesMonitorThread_ = boost::thread(UnstableResourcesMonitorThread, this); |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
364 } |
|
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
365 |
|
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
366 |
|
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
367 ServerIndex::~ServerIndex() |
|
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
368 { |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
369 done_ = true; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
370 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
371 if (flushThread_.joinable()) |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
372 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
373 flushThread_.join(); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
374 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
375 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
376 if (unstableResourcesMonitorThread_.joinable()) |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
377 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
378 unstableResourcesMonitorThread_.join(); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
379 } |
| 0 | 380 } |
| 381 | |
| 382 | |
|
187
8e673a65564d
refactoring of storing new instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
186
diff
changeset
|
383 StoreStatus ServerIndex::Store(const DicomMap& dicomSummary, |
|
232
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
384 const Attachments& attachments, |
|
187
8e673a65564d
refactoring of storing new instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
186
diff
changeset
|
385 const std::string& remoteAet) |
| 0 | 386 { |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
387 boost::mutex::scoped_lock lock(mutex_); |
|
268
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
388 listener_->Reset(); |
| 0 | 389 |
| 178 | 390 DicomInstanceHasher hasher(dicomSummary); |
| 0 | 391 |
| 392 try | |
| 393 { | |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
394 Transaction t(*this); |
| 0 | 395 |
| 202 | 396 // Do nothing if the instance already exists |
| 0 | 397 { |
| 432 | 398 ResourceType type; |
| 399 int64_t tmp; | |
| 400 if (db_->LookupResource(hasher.HashInstance(), tmp, type)) | |
| 401 { | |
| 402 assert(type == ResourceType_Instance); | |
| 403 return StoreStatus_AlreadyStored; | |
| 404 } | |
| 0 | 405 } |
| 406 | |
|
268
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
407 // Ensure there is enough room in the storage for the new instance |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
408 uint64_t instanceSize = 0; |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
409 for (Attachments::const_iterator it = attachments.begin(); |
| 656 | 410 it != attachments.end(); ++it) |
|
268
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
411 { |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
412 instanceSize += it->GetCompressedSize(); |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
413 } |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
414 |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
415 Recycle(instanceSize, hasher.HashPatient()); |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
416 |
| 202 | 417 // Create the instance |
| 432 | 418 int64_t instance = db_->CreateResource(hasher.HashInstance(), ResourceType_Instance); |
| 202 | 419 |
| 420 DicomMap dicom; | |
| 421 dicomSummary.ExtractInstanceInformation(dicom); | |
| 422 db_->SetMainDicomTags(instance, dicom); | |
| 423 | |
| 432 | 424 // Detect up to which level the patient/study/series/instance |
| 425 // hierarchy must be created | |
| 426 int64_t patient = -1, study = -1, series = -1; | |
| 427 bool isNewPatient = false; | |
| 428 bool isNewStudy = false; | |
| 429 bool isNewSeries = false; | |
| 430 | |
| 0 | 431 { |
| 432 | 432 ResourceType dummy; |
| 433 | |
| 434 if (db_->LookupResource(hasher.HashSeries(), series, dummy)) | |
| 435 { | |
| 436 assert(dummy == ResourceType_Series); | |
| 437 // The patient, the study and the series already exist | |
| 438 | |
| 439 bool ok = (db_->LookupResource(hasher.HashPatient(), patient, dummy) && | |
| 440 db_->LookupResource(hasher.HashStudy(), study, dummy)); | |
| 441 assert(ok); | |
| 442 } | |
| 443 else if (db_->LookupResource(hasher.HashStudy(), study, dummy)) | |
| 444 { | |
| 445 assert(dummy == ResourceType_Study); | |
| 446 | |
| 447 // New series: The patient and the study already exist | |
| 448 isNewSeries = true; | |
| 449 | |
| 450 bool ok = db_->LookupResource(hasher.HashPatient(), patient, dummy); | |
| 451 assert(ok); | |
| 452 } | |
| 453 else if (db_->LookupResource(hasher.HashPatient(), patient, dummy)) | |
| 454 { | |
| 455 assert(dummy == ResourceType_Patient); | |
| 456 | |
| 457 // New study and series: The patient already exist | |
| 458 isNewStudy = true; | |
| 459 isNewSeries = true; | |
| 460 } | |
| 461 else | |
| 462 { | |
| 463 // New patient, study and series: Nothing exists | |
| 464 isNewPatient = true; | |
| 465 isNewStudy = true; | |
| 466 isNewSeries = true; | |
| 467 } | |
| 468 } | |
| 469 | |
| 470 // Create the series if needed | |
| 471 if (isNewSeries) | |
| 472 { | |
| 202 | 473 series = db_->CreateResource(hasher.HashSeries(), ResourceType_Series); |
| 474 dicomSummary.ExtractSeriesInformation(dicom); | |
| 475 db_->SetMainDicomTags(series, dicom); | |
| 432 | 476 } |
| 202 | 477 |
| 432 | 478 // Create the study if needed |
| 479 if (isNewStudy) | |
| 480 { | |
| 481 study = db_->CreateResource(hasher.HashStudy(), ResourceType_Study); | |
| 482 dicomSummary.ExtractStudyInformation(dicom); | |
| 483 db_->SetMainDicomTags(study, dicom); | |
| 484 } | |
| 485 | |
| 486 // Create the patient if needed | |
| 487 if (isNewPatient) | |
| 488 { | |
| 489 patient = db_->CreateResource(hasher.HashPatient(), ResourceType_Patient); | |
| 490 dicomSummary.ExtractPatientInformation(dicom); | |
| 491 db_->SetMainDicomTags(patient, dicom); | |
| 492 } | |
| 202 | 493 |
| 432 | 494 // Create the parent-to-child links |
| 495 db_->AttachChild(series, instance); | |
| 496 | |
| 497 if (isNewSeries) | |
| 498 { | |
| 499 db_->AttachChild(study, series); | |
| 0 | 500 } |
| 432 | 501 |
| 502 if (isNewStudy) | |
| 0 | 503 { |
| 432 | 504 db_->AttachChild(patient, study); |
| 0 | 505 } |
| 506 | |
| 432 | 507 // Sanity checks |
| 508 assert(patient != -1); | |
| 509 assert(study != -1); | |
| 510 assert(series != -1); | |
| 511 assert(instance != -1); | |
| 512 | |
| 202 | 513 // Attach the files to the newly created instance |
|
232
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
514 for (Attachments::const_iterator it = attachments.begin(); |
| 656 | 515 it != attachments.end(); ++it) |
|
232
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
516 { |
|
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
517 db_->AddAttachment(instance, *it); |
|
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
518 } |
| 202 | 519 |
| 520 // Attach the metadata | |
| 432 | 521 std::string now = Toolbox::GetNowIsoString(); |
| 522 db_->SetMetadata(instance, MetadataType_Instance_ReceptionDate, now); | |
| 523 db_->SetMetadata(series, MetadataType_LastUpdate, now); | |
| 524 db_->SetMetadata(study, MetadataType_LastUpdate, now); | |
| 525 db_->SetMetadata(patient, MetadataType_LastUpdate, now); | |
| 202 | 526 db_->SetMetadata(instance, MetadataType_Instance_RemoteAet, remoteAet); |
| 527 | |
| 528 const DicomValue* value; | |
| 529 if ((value = dicomSummary.TestAndGetValue(DICOM_TAG_INSTANCE_NUMBER)) != NULL || | |
| 530 (value = dicomSummary.TestAndGetValue(DICOM_TAG_IMAGE_INDEX)) != NULL) | |
| 0 | 531 { |
| 202 | 532 db_->SetMetadata(instance, MetadataType_Instance_IndexInSeries, value->AsString()); |
| 0 | 533 } |
| 534 | |
| 202 | 535 if (isNewSeries) |
| 536 { | |
| 433 | 537 ComputeExpectedNumberOfInstances(*db_, series, dicomSummary); |
| 202 | 538 } |
| 539 | |
|
205
6ab754744446
logging of completed series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
204
diff
changeset
|
540 // Check whether the series of this new instance is now completed |
|
6ab754744446
logging of completed series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
204
diff
changeset
|
541 SeriesStatus seriesStatus = GetSeriesStatus(series); |
|
6ab754744446
logging of completed series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
204
diff
changeset
|
542 if (seriesStatus == SeriesStatus_Complete) |
|
6ab754744446
logging of completed series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
204
diff
changeset
|
543 { |
|
6ab754744446
logging of completed series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
204
diff
changeset
|
544 db_->LogChange(ChangeType_CompletedSeries, series, ResourceType_Series); |
|
6ab754744446
logging of completed series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
204
diff
changeset
|
545 } |
|
6ab754744446
logging of completed series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
204
diff
changeset
|
546 |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
547 // Mark the parent resources of this instance as unstable |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
548 MarkAsUnstable(patient, ResourceType_Patient); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
549 MarkAsUnstable(study, ResourceType_Study); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
550 MarkAsUnstable(series, ResourceType_Series); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
551 |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
552 t.Commit(instanceSize); |
|
268
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
553 |
| 0 | 554 return StoreStatus_Success; |
| 555 } | |
| 62 | 556 catch (OrthancException& e) |
| 0 | 557 { |
|
268
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
558 LOG(ERROR) << "EXCEPTION [" << e.What() << "]" |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
559 << " (SQLite status: " << db_->GetErrorMessage() << ")"; |
| 0 | 560 } |
| 561 | |
| 562 return StoreStatus_Failure; | |
| 563 } | |
| 564 | |
| 565 | |
| 238 | 566 void ServerIndex::ComputeStatistics(Json::Value& target) |
| 0 | 567 { |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
568 boost::mutex::scoped_lock lock(mutex_); |
| 238 | 569 target = Json::objectValue; |
| 0 | 570 |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
571 uint64_t cs = currentStorageSize_; |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
572 assert(cs == db_->GetTotalCompressedSize()); |
| 238 | 573 uint64_t us = db_->GetTotalUncompressedSize(); |
|
440
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
574 target["TotalDiskSize"] = boost::lexical_cast<std::string>(cs); |
| 238 | 575 target["TotalUncompressedSize"] = boost::lexical_cast<std::string>(us); |
|
440
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
576 target["TotalDiskSizeMB"] = boost::lexical_cast<unsigned int>(cs / MEGA_BYTES); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
577 target["TotalUncompressedSizeMB"] = boost::lexical_cast<unsigned int>(us / MEGA_BYTES); |
| 238 | 578 |
| 579 target["CountPatients"] = static_cast<unsigned int>(db_->GetResourceCount(ResourceType_Patient)); | |
| 580 target["CountStudies"] = static_cast<unsigned int>(db_->GetResourceCount(ResourceType_Study)); | |
| 581 target["CountSeries"] = static_cast<unsigned int>(db_->GetResourceCount(ResourceType_Series)); | |
| 582 target["CountInstances"] = static_cast<unsigned int>(db_->GetResourceCount(ResourceType_Instance)); | |
| 583 } | |
| 584 | |
|
187
8e673a65564d
refactoring of storing new instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
186
diff
changeset
|
585 |
|
8e673a65564d
refactoring of storing new instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
186
diff
changeset
|
586 |
| 585 | 587 SeriesStatus ServerIndex::GetSeriesStatus(int64_t id) |
| 199 | 588 { |
| 589 // Get the expected number of instances in this series (from the metadata) | |
| 202 | 590 std::string s = db_->GetMetadata(id, MetadataType_Series_ExpectedNumberOfInstances); |
| 199 | 591 |
| 592 size_t expected; | |
| 593 try | |
| 594 { | |
| 595 expected = boost::lexical_cast<size_t>(s); | |
| 596 } | |
| 597 catch (boost::bad_lexical_cast&) | |
| 598 { | |
| 599 return SeriesStatus_Unknown; | |
| 600 } | |
| 601 | |
| 602 // Loop over the instances of this series | |
| 603 std::list<int64_t> children; | |
| 202 | 604 db_->GetChildrenInternalId(children, id); |
| 199 | 605 |
| 606 std::set<size_t> instances; | |
| 607 for (std::list<int64_t>::const_iterator | |
| 656 | 608 it = children.begin(); it != children.end(); ++it) |
| 199 | 609 { |
| 610 // Get the index of this instance in the series | |
| 202 | 611 s = db_->GetMetadata(*it, MetadataType_Instance_IndexInSeries); |
| 199 | 612 size_t index; |
| 613 try | |
| 614 { | |
| 615 index = boost::lexical_cast<size_t>(s); | |
| 616 } | |
| 617 catch (boost::bad_lexical_cast&) | |
| 618 { | |
| 619 return SeriesStatus_Unknown; | |
| 620 } | |
| 621 | |
| 656 | 622 if (!(index > 0 && index <= expected)) |
| 199 | 623 { |
| 624 // Out-of-range instance index | |
| 625 return SeriesStatus_Inconsistent; | |
| 626 } | |
| 627 | |
| 628 if (instances.find(index) != instances.end()) | |
| 629 { | |
| 630 // Twice the same instance index | |
| 631 return SeriesStatus_Inconsistent; | |
| 632 } | |
| 633 | |
| 634 instances.insert(index); | |
| 635 } | |
| 636 | |
| 637 if (instances.size() == expected) | |
| 638 { | |
| 639 return SeriesStatus_Complete; | |
| 640 } | |
| 641 else | |
| 642 { | |
| 643 return SeriesStatus_Missing; | |
| 644 } | |
| 645 } | |
| 646 | |
| 647 | |
| 648 | |
| 202 | 649 void ServerIndex::MainDicomTagsToJson(Json::Value& target, |
| 650 int64_t resourceId) | |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
651 { |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
652 DicomMap tags; |
| 202 | 653 db_->GetMainDicomTags(tags, resourceId); |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
654 target["MainDicomTags"] = Json::objectValue; |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
655 FromDcmtkBridge::ToJson(target["MainDicomTags"], tags); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
656 } |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
657 |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
658 bool ServerIndex::LookupResource(Json::Value& result, |
| 199 | 659 const std::string& publicId, |
| 660 ResourceType expectedType) | |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
661 { |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
662 result = Json::objectValue; |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
663 |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
664 boost::mutex::scoped_lock lock(mutex_); |
| 199 | 665 |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
666 // Lookup for the requested resource |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
667 int64_t id; |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
668 ResourceType type; |
| 202 | 669 if (!db_->LookupResource(publicId, id, type) || |
| 199 | 670 type != expectedType) |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
671 { |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
672 return false; |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
673 } |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
674 |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
675 // Find the parent resource (if it exists) |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
676 if (type != ResourceType_Patient) |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
677 { |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
678 int64_t parentId; |
| 202 | 679 if (!db_->LookupParent(parentId, id)) |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
680 { |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
681 throw OrthancException(ErrorCode_InternalError); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
682 } |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
683 |
| 202 | 684 std::string parent = db_->GetPublicId(parentId); |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
685 |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
686 switch (type) |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
687 { |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
688 case ResourceType_Study: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
689 result["ParentPatient"] = parent; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
690 break; |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
691 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
692 case ResourceType_Series: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
693 result["ParentStudy"] = parent; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
694 break; |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
695 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
696 case ResourceType_Instance: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
697 result["ParentSeries"] = parent; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
698 break; |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
699 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
700 default: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
701 throw OrthancException(ErrorCode_InternalError); |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
702 } |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
703 } |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
704 |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
705 // List the children resources |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
706 std::list<std::string> children; |
| 202 | 707 db_->GetChildrenPublicId(children, id); |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
708 |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
709 if (type != ResourceType_Instance) |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
710 { |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
711 Json::Value c = Json::arrayValue; |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
712 |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
713 for (std::list<std::string>::const_iterator |
| 656 | 714 it = children.begin(); it != children.end(); ++it) |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
715 { |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
716 c.append(*it); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
717 } |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
718 |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
719 switch (type) |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
720 { |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
721 case ResourceType_Patient: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
722 result["Studies"] = c; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
723 break; |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
724 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
725 case ResourceType_Study: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
726 result["Series"] = c; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
727 break; |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
728 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
729 case ResourceType_Series: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
730 result["Instances"] = c; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
731 break; |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
732 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
733 default: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
734 throw OrthancException(ErrorCode_InternalError); |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
735 } |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
736 } |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
737 |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
738 // Set the resource type |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
739 switch (type) |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
740 { |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
741 case ResourceType_Patient: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
742 result["Type"] = "Patient"; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
743 break; |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
744 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
745 case ResourceType_Study: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
746 result["Type"] = "Study"; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
747 break; |
| 199 | 748 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
749 case ResourceType_Series: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
750 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
751 result["Type"] = "Series"; |
|
434
ccf3a0a43dac
EnumerationDictionary
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
433
diff
changeset
|
752 result["Status"] = EnumerationToString(GetSeriesStatus(id)); |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
753 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
754 int i; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
755 if (db_->GetMetadataAsInteger(i, id, MetadataType_Series_ExpectedNumberOfInstances)) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
756 result["ExpectedNumberOfInstances"] = i; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
757 else |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
758 result["ExpectedNumberOfInstances"] = Json::nullValue; |
|
200
9c58b2b03cf0
refactoring of read operations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
199
diff
changeset
|
759 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
760 break; |
|
200
9c58b2b03cf0
refactoring of read operations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
199
diff
changeset
|
761 } |
|
9c58b2b03cf0
refactoring of read operations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
199
diff
changeset
|
762 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
763 case ResourceType_Instance: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
764 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
765 result["Type"] = "Instance"; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
766 |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
767 FileInfo attachment; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
768 if (!db_->LookupAttachment(attachment, id, FileContentType_Dicom)) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
769 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
770 throw OrthancException(ErrorCode_InternalError); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
771 } |
|
200
9c58b2b03cf0
refactoring of read operations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
199
diff
changeset
|
772 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
773 result["FileSize"] = static_cast<unsigned int>(attachment.GetUncompressedSize()); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
774 result["FileUuid"] = attachment.GetUuid(); |
|
200
9c58b2b03cf0
refactoring of read operations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
199
diff
changeset
|
775 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
776 int i; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
777 if (db_->GetMetadataAsInteger(i, id, MetadataType_Instance_IndexInSeries)) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
778 result["IndexInSeries"] = i; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
779 else |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
780 result["IndexInSeries"] = Json::nullValue; |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
781 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
782 break; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
783 } |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
784 |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
785 default: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
786 throw OrthancException(ErrorCode_InternalError); |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
787 } |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
788 |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
789 // Record the remaining information |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
790 result["ID"] = publicId; |
| 202 | 791 MainDicomTagsToJson(result, id); |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
792 |
| 315 | 793 std::string tmp; |
| 794 | |
| 795 tmp = db_->GetMetadata(id, MetadataType_AnonymizedFrom); | |
| 796 if (tmp.size() != 0) | |
| 797 result["AnonymizedFrom"] = tmp; | |
| 798 | |
| 799 tmp = db_->GetMetadata(id, MetadataType_ModifiedFrom); | |
| 800 if (tmp.size() != 0) | |
| 801 result["ModifiedFrom"] = tmp; | |
| 802 | |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
803 if (type == ResourceType_Patient || |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
804 type == ResourceType_Study || |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
805 type == ResourceType_Series) |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
806 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
807 result["IsStable"] = !unstableResources_.Contains(id); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
808 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
809 |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
810 return true; |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
811 } |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
812 |
| 0 | 813 |
|
232
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
814 bool ServerIndex::LookupAttachment(FileInfo& attachment, |
|
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
815 const std::string& instanceUuid, |
| 233 | 816 FileContentType contentType) |
| 0 | 817 { |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
818 boost::mutex::scoped_lock lock(mutex_); |
| 0 | 819 |
|
193
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
192
diff
changeset
|
820 int64_t id; |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
192
diff
changeset
|
821 ResourceType type; |
| 202 | 822 if (!db_->LookupResource(instanceUuid, id, type) || |
|
193
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
192
diff
changeset
|
823 type != ResourceType_Instance) |
|
192
c56dc32266e0
refactoring getfile
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
191
diff
changeset
|
824 { |
|
c56dc32266e0
refactoring getfile
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
191
diff
changeset
|
825 throw OrthancException(ErrorCode_InternalError); |
|
c56dc32266e0
refactoring getfile
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
191
diff
changeset
|
826 } |
|
193
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
192
diff
changeset
|
827 |
|
232
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
828 if (db_->LookupAttachment(attachment, id, contentType)) |
|
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
829 { |
| 233 | 830 assert(attachment.GetContentType() == contentType); |
|
232
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
831 return true; |
|
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
832 } |
|
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
833 else |
|
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
834 { |
|
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
835 return false; |
|
5368bbe813cf
refactoring of attachments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
231
diff
changeset
|
836 } |
|
192
c56dc32266e0
refactoring getfile
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
191
diff
changeset
|
837 } |
|
c56dc32266e0
refactoring getfile
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
191
diff
changeset
|
838 |
|
c56dc32266e0
refactoring getfile
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
191
diff
changeset
|
839 |
|
c56dc32266e0
refactoring getfile
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
191
diff
changeset
|
840 |
| 0 | 841 void ServerIndex::GetAllUuids(Json::Value& target, |
| 190 | 842 ResourceType resourceType) |
| 0 | 843 { |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
844 boost::mutex::scoped_lock lock(mutex_); |
| 202 | 845 db_->GetAllPublicIds(target, resourceType); |
| 0 | 846 } |
| 847 | |
| 848 | |
| 849 bool ServerIndex::GetChanges(Json::Value& target, | |
| 204 | 850 int64_t since, |
| 0 | 851 unsigned int maxResults) |
| 852 { | |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
205
diff
changeset
|
853 boost::mutex::scoped_lock lock(mutex_); |
|
237
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
854 db_->GetChanges(target, since, maxResults); |
|
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
855 return true; |
|
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
856 } |
| 0 | 857 |
|
237
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
858 bool ServerIndex::GetLastChange(Json::Value& target) |
|
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
859 { |
|
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
860 boost::mutex::scoped_lock lock(mutex_); |
|
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
861 db_->GetLastChange(target); |
| 204 | 862 return true; |
| 0 | 863 } |
| 231 | 864 |
| 865 void ServerIndex::LogExportedResource(const std::string& publicId, | |
| 866 const std::string& remoteModality) | |
| 867 { | |
| 868 boost::mutex::scoped_lock lock(mutex_); | |
| 869 | |
| 870 int64_t id; | |
| 871 ResourceType type; | |
| 872 if (!db_->LookupResource(publicId, id, type)) | |
| 873 { | |
| 874 throw OrthancException(ErrorCode_InternalError); | |
| 875 } | |
| 876 | |
| 877 std::string patientId; | |
| 878 std::string studyInstanceUid; | |
| 879 std::string seriesInstanceUid; | |
| 880 std::string sopInstanceUid; | |
| 881 | |
| 882 int64_t currentId = id; | |
| 883 ResourceType currentType = type; | |
| 884 | |
| 885 // Iteratively go up inside the patient/study/series/instance hierarchy | |
| 886 bool done = false; | |
| 887 while (!done) | |
| 888 { | |
| 889 DicomMap map; | |
| 890 db_->GetMainDicomTags(map, currentId); | |
| 891 | |
| 892 switch (currentType) | |
| 893 { | |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
894 case ResourceType_Patient: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
895 patientId = map.GetValue(DICOM_TAG_PATIENT_ID).AsString(); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
896 done = true; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
897 break; |
| 231 | 898 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
899 case ResourceType_Study: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
900 studyInstanceUid = map.GetValue(DICOM_TAG_STUDY_INSTANCE_UID).AsString(); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
901 currentType = ResourceType_Patient; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
902 break; |
| 231 | 903 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
904 case ResourceType_Series: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
905 seriesInstanceUid = map.GetValue(DICOM_TAG_SERIES_INSTANCE_UID).AsString(); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
906 currentType = ResourceType_Study; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
907 break; |
| 231 | 908 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
909 case ResourceType_Instance: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
910 sopInstanceUid = map.GetValue(DICOM_TAG_SOP_INSTANCE_UID).AsString(); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
911 currentType = ResourceType_Series; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
912 break; |
| 231 | 913 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
914 default: |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
915 throw OrthancException(ErrorCode_InternalError); |
| 231 | 916 } |
| 917 | |
| 918 // If we have not reached the Patient level, find the parent of | |
| 919 // the current resource | |
| 920 if (!done) | |
| 921 { | |
|
375
d1ea72f1c967
major fix of storescu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
315
diff
changeset
|
922 bool ok = db_->LookupParent(currentId, currentId); |
|
d1ea72f1c967
major fix of storescu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
315
diff
changeset
|
923 assert(ok); |
| 231 | 924 } |
| 925 } | |
| 926 | |
| 927 // No need for a SQLite::Transaction here, as we only insert 1 record | |
| 928 db_->LogExportedResource(type, | |
| 929 publicId, | |
| 930 remoteModality, | |
| 931 patientId, | |
| 932 studyInstanceUid, | |
| 933 seriesInstanceUid, | |
| 934 sopInstanceUid); | |
| 935 } | |
| 936 | |
| 937 | |
| 938 bool ServerIndex::GetExportedResources(Json::Value& target, | |
| 939 int64_t since, | |
| 940 unsigned int maxResults) | |
| 941 { | |
| 942 boost::mutex::scoped_lock lock(mutex_); | |
| 943 db_->GetExportedResources(target, since, maxResults); | |
| 944 return true; | |
| 945 } | |
|
237
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
946 |
|
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
947 bool ServerIndex::GetLastExportedResource(Json::Value& target) |
|
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
948 { |
|
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
949 boost::mutex::scoped_lock lock(mutex_); |
|
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
950 db_->GetLastExportedResource(target); |
|
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
951 return true; |
|
16a4ac70bd8a
last change and export
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
233
diff
changeset
|
952 } |
|
268
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
953 |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
954 |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
955 bool ServerIndex::IsRecyclingNeeded(uint64_t instanceSize) |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
956 { |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
957 if (maximumStorageSize_ != 0) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
958 { |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
959 uint64_t currentSize = currentStorageSize_ - listener_->GetSizeOfFilesToRemove(); |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
960 assert(db_->GetTotalCompressedSize() == currentSize); |
|
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
961 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
962 if (currentSize + instanceSize > maximumStorageSize_) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
963 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
964 return true; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
965 } |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
966 } |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
967 |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
968 if (maximumPatients_ != 0) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
969 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
970 uint64_t patientCount = db_->GetResourceCount(ResourceType_Patient); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
971 if (patientCount > maximumPatients_) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
972 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
973 return true; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
974 } |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
975 } |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
976 |
|
268
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
977 return false; |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
978 } |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
979 |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
980 |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
981 void ServerIndex::Recycle(uint64_t instanceSize, |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
982 const std::string& newPatientId) |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
983 { |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
984 if (!IsRecyclingNeeded(instanceSize)) |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
985 { |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
986 return; |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
987 } |
|
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
988 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
989 // Check whether other DICOM instances from this patient are |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
990 // already stored |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
991 int64_t patientToAvoid; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
992 ResourceType type; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
993 bool hasPatientToAvoid = db_->LookupResource(newPatientId, patientToAvoid, type); |
|
268
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
994 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
995 if (hasPatientToAvoid && type != ResourceType_Patient) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
996 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
997 throw OrthancException(ErrorCode_InternalError); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
998 } |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
999 |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1000 // Iteratively select patient to remove until there is enough |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1001 // space in the DICOM store |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1002 int64_t patientToRecycle; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1003 while (true) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1004 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1005 // If other instances of this patient are already in the store, |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1006 // we must avoid to recycle them |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1007 bool ok = hasPatientToAvoid ? |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1008 db_->SelectPatientToRecycle(patientToRecycle, patientToAvoid) : |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1009 db_->SelectPatientToRecycle(patientToRecycle); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1010 |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1011 if (!ok) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1012 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1013 throw OrthancException(ErrorCode_FullStorage); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1014 } |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1015 |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1016 LOG(INFO) << "Recycling one patient"; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1017 db_->DeleteResource(patientToRecycle); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1018 |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1019 if (!IsRecyclingNeeded(instanceSize)) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1020 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1021 // OK, we're done |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1022 break; |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1023 } |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1024 } |
|
268
4bc02e2254ec
preparing ServerIndex for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
264
diff
changeset
|
1025 } |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1026 |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1027 void ServerIndex::SetMaximumPatientCount(unsigned int count) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1028 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1029 boost::mutex::scoped_lock lock(mutex_); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1030 maximumPatients_ = count; |
|
270
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1031 |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1032 if (count == 0) |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1033 { |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1034 LOG(WARNING) << "No limit on the number of stored patients"; |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1035 } |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1036 else |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1037 { |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1038 LOG(WARNING) << "At most " << count << " patients will be stored"; |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1039 } |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1040 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1041 StandaloneRecycling(); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1042 } |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1043 |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1044 void ServerIndex::SetMaximumStorageSize(uint64_t size) |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1045 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1046 boost::mutex::scoped_lock lock(mutex_); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1047 maximumStorageSize_ = size; |
|
270
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1048 |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1049 if (size == 0) |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1050 { |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1051 LOG(WARNING) << "No limit on the size of the storage area"; |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1052 } |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1053 else |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1054 { |
|
440
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1055 LOG(WARNING) << "At most " << (size / MEGA_BYTES) << "MB will be used for the storage area"; |
|
270
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1056 } |
|
e6a4c4329481
parameters for storage capacity
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
269
diff
changeset
|
1057 |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1058 StandaloneRecycling(); |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1059 } |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1060 |
|
272
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1061 void ServerIndex::StandaloneRecycling() |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1062 { |
|
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1063 // WARNING: No mutex here, do not include this as a public method |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
1064 Transaction t(*this); |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1065 Recycle(0, ""); |
|
278
771f12042be9
more efficient determination of storage size for recycling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
273
diff
changeset
|
1066 t.Commit(0); |
|
269
f6fdf5abe751
recycling up and running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
268
diff
changeset
|
1067 } |
|
272
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1068 |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1069 |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1070 bool ServerIndex::IsProtectedPatient(const std::string& publicId) |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1071 { |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1072 boost::mutex::scoped_lock lock(mutex_); |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1073 |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1074 // Lookup for the requested resource |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1075 int64_t id; |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1076 ResourceType type; |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1077 if (!db_->LookupResource(publicId, id, type) || |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1078 type != ResourceType_Patient) |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1079 { |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1080 throw OrthancException(ErrorCode_ParameterOutOfRange); |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1081 } |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1082 |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1083 return db_->IsProtectedPatient(id); |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1084 } |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1085 |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1086 |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1087 void ServerIndex::SetProtectedPatient(const std::string& publicId, |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1088 bool isProtected) |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1089 { |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1090 boost::mutex::scoped_lock lock(mutex_); |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1091 |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1092 // Lookup for the requested resource |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1093 int64_t id; |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1094 ResourceType type; |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1095 if (!db_->LookupResource(publicId, id, type) || |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1096 type != ResourceType_Patient) |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1097 { |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1098 throw OrthancException(ErrorCode_ParameterOutOfRange); |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1099 } |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1100 |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1101 // No need for a SQLite::Transaction here, as we only make 1 write to the DB |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1102 db_->SetProtectedPatient(id, isProtected); |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1103 |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1104 if (isProtected) |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1105 LOG(INFO) << "Patient " << publicId << " has been protected"; |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1106 else |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1107 LOG(INFO) << "Patient " << publicId << " has been unprotected"; |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1108 } |
|
337c506461d2
protection from rest api
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
270
diff
changeset
|
1109 |
| 304 | 1110 |
| 1111 void ServerIndex::GetChildInstances(std::list<std::string>& result, | |
| 1112 const std::string& publicId) | |
| 1113 { | |
| 1114 result.clear(); | |
| 1115 | |
| 1116 boost::mutex::scoped_lock lock(mutex_); | |
| 1117 | |
| 1118 ResourceType type; | |
| 1119 int64_t top; | |
| 1120 if (!db_->LookupResource(publicId, top, type)) | |
| 1121 { | |
| 1122 throw OrthancException(ErrorCode_UnknownResource); | |
| 1123 } | |
| 1124 | |
| 1125 if (type == ResourceType_Instance) | |
| 1126 { | |
| 1127 // The resource is already an instance: Do not go down the hierarchy | |
| 1128 result.push_back(publicId); | |
| 1129 return; | |
| 1130 } | |
| 1131 | |
| 1132 std::stack<int64_t> toExplore; | |
| 1133 toExplore.push(top); | |
| 1134 | |
| 1135 std::list<int64_t> tmp; | |
| 1136 | |
| 1137 while (!toExplore.empty()) | |
| 1138 { | |
| 1139 // Get the internal ID of the current resource | |
| 1140 int64_t resource = toExplore.top(); | |
| 1141 toExplore.pop(); | |
| 1142 | |
| 1143 if (db_->GetResourceType(resource) == ResourceType_Instance) | |
| 1144 { | |
| 1145 result.push_back(db_->GetPublicId(resource)); | |
| 1146 } | |
| 1147 else | |
| 1148 { | |
| 1149 // Tag all the children of this resource as to be explored | |
| 1150 db_->GetChildrenInternalId(tmp, resource); | |
| 1151 for (std::list<int64_t>::const_iterator | |
| 656 | 1152 it = tmp.begin(); it != tmp.end(); ++it) |
| 304 | 1153 { |
| 1154 toExplore.push(*it); | |
| 1155 } | |
| 1156 } | |
| 1157 } | |
| 1158 } | |
| 1159 | |
|
306
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1160 |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1161 void ServerIndex::SetMetadata(const std::string& publicId, |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1162 MetadataType type, |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1163 const std::string& value) |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1164 { |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1165 boost::mutex::scoped_lock lock(mutex_); |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1166 |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1167 ResourceType rtype; |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1168 int64_t id; |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1169 if (!db_->LookupResource(publicId, id, rtype)) |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1170 { |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1171 throw OrthancException(ErrorCode_UnknownResource); |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1172 } |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1173 |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1174 db_->SetMetadata(id, type, value); |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1175 } |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1176 |
| 438 | 1177 |
| 1178 void ServerIndex::DeleteMetadata(const std::string& publicId, | |
| 1179 MetadataType type) | |
| 1180 { | |
| 1181 boost::mutex::scoped_lock lock(mutex_); | |
| 1182 | |
| 1183 ResourceType rtype; | |
| 1184 int64_t id; | |
| 1185 if (!db_->LookupResource(publicId, id, rtype)) | |
| 1186 { | |
| 1187 throw OrthancException(ErrorCode_UnknownResource); | |
| 1188 } | |
| 1189 | |
| 1190 db_->DeleteMetadata(id, type); | |
| 1191 } | |
| 1192 | |
| 1193 | |
|
306
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1194 bool ServerIndex::LookupMetadata(std::string& target, |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1195 const std::string& publicId, |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1196 MetadataType type) |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1197 { |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1198 boost::mutex::scoped_lock lock(mutex_); |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1199 |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1200 ResourceType rtype; |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1201 int64_t id; |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1202 if (!db_->LookupResource(publicId, id, rtype)) |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1203 { |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1204 throw OrthancException(ErrorCode_UnknownResource); |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1205 } |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1206 |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1207 return db_->LookupMetadata(target, id, type); |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1208 } |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1209 |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1210 |
|
436
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1211 bool ServerIndex::ListAvailableMetadata(std::list<MetadataType>& target, |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1212 const std::string& publicId) |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1213 { |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1214 boost::mutex::scoped_lock lock(mutex_); |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1215 |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1216 ResourceType rtype; |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1217 int64_t id; |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1218 if (!db_->LookupResource(publicId, id, rtype)) |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1219 { |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1220 throw OrthancException(ErrorCode_UnknownResource); |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1221 } |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1222 |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1223 return db_->ListAvailableMetadata(target, id); |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1224 } |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1225 |
|
d51186bf7602
read access to metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
434
diff
changeset
|
1226 |
|
306
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1227 bool ServerIndex::LookupParent(std::string& target, |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1228 const std::string& publicId) |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1229 { |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1230 boost::mutex::scoped_lock lock(mutex_); |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1231 |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1232 ResourceType type; |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1233 int64_t id; |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1234 if (!db_->LookupResource(publicId, id, type)) |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1235 { |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1236 throw OrthancException(ErrorCode_UnknownResource); |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1237 } |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1238 |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1239 int64_t parentId; |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1240 if (db_->LookupParent(parentId, id)) |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1241 { |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1242 target = db_->GetPublicId(parentId); |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1243 return true; |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1244 } |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1245 else |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1246 { |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1247 return false; |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1248 } |
|
326d5a4a5af3
modification of instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
304
diff
changeset
|
1249 } |
| 310 | 1250 |
| 1251 | |
| 1252 uint64_t ServerIndex::IncrementGlobalSequence(GlobalProperty sequence) | |
| 1253 { | |
| 1254 boost::mutex::scoped_lock lock(mutex_); | |
| 311 | 1255 |
| 1256 std::auto_ptr<SQLite::Transaction> transaction(db_->StartTransaction()); | |
| 1257 | |
| 1258 transaction->Begin(); | |
| 1259 uint64_t seq = db_->IncrementGlobalSequence(sequence); | |
| 1260 transaction->Commit(); | |
| 1261 | |
| 1262 return seq; | |
| 310 | 1263 } |
| 315 | 1264 |
| 1265 | |
| 1266 | |
| 1267 void ServerIndex::LogChange(ChangeType changeType, | |
| 1268 const std::string& publicId) | |
| 1269 { | |
| 1270 boost::mutex::scoped_lock lock(mutex_); | |
| 1271 std::auto_ptr<SQLite::Transaction> transaction(db_->StartTransaction()); | |
| 1272 transaction->Begin(); | |
| 1273 | |
| 1274 int64_t id; | |
| 1275 ResourceType type; | |
| 1276 if (!db_->LookupResource(publicId, id, type)) | |
| 1277 { | |
| 1278 throw OrthancException(ErrorCode_UnknownResource); | |
| 1279 } | |
| 1280 | |
| 1281 db_->LogChange(changeType, id, type); | |
| 1282 | |
| 1283 transaction->Commit(); | |
| 1284 } | |
|
413
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1285 |
|
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1286 |
|
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1287 void ServerIndex::DeleteChanges() |
|
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1288 { |
|
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1289 boost::mutex::scoped_lock lock(mutex_); |
|
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1290 db_->ClearTable("Changes"); |
|
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1291 } |
|
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1292 |
|
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1293 void ServerIndex::DeleteExportedResources() |
|
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1294 { |
|
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1295 boost::mutex::scoped_lock lock(mutex_); |
|
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1296 db_->ClearTable("ExportedResources"); |
|
47d63c941902
clearing /exports and /changes
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
399
diff
changeset
|
1297 } |
|
440
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1298 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1299 |
| 646 | 1300 void ServerIndex::GetStatisticsInternal(/* out */ uint64_t& compressedSize, |
| 1301 /* out */ uint64_t& uncompressedSize, | |
| 1302 /* out */ unsigned int& countStudies, | |
| 1303 /* out */ unsigned int& countSeries, | |
| 1304 /* out */ unsigned int& countInstances, | |
| 1305 /* in */ int64_t id, | |
| 1306 /* in */ ResourceType type) | |
|
440
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1307 { |
| 646 | 1308 std::stack<int64_t> toExplore; |
| 1309 toExplore.push(id); | |
|
440
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1310 |
| 646 | 1311 countInstances = 0; |
| 1312 countSeries = 0; | |
| 1313 countStudies = 0; | |
| 1314 compressedSize = 0; | |
| 1315 uncompressedSize = 0; | |
|
440
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1316 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1317 while (!toExplore.empty()) |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1318 { |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1319 // Get the internal ID of the current resource |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1320 int64_t resource = toExplore.top(); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1321 toExplore.pop(); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1322 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1323 ResourceType thisType = db_->GetResourceType(resource); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1324 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1325 if (thisType == ResourceType_Instance) |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1326 { |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1327 std::list<FileContentType> f; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1328 db_->ListAvailableAttachments(f, resource); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1329 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1330 for (std::list<FileContentType>::const_iterator |
| 656 | 1331 it = f.begin(); it != f.end(); ++it) |
|
440
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1332 { |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1333 FileInfo attachment; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1334 if (db_->LookupAttachment(attachment, resource, *it)) |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1335 { |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1336 compressedSize += attachment.GetCompressedSize(); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1337 uncompressedSize += attachment.GetUncompressedSize(); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1338 } |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1339 } |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1340 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1341 countInstances++; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1342 } |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1343 else |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1344 { |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1345 switch (thisType) |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1346 { |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1347 case ResourceType_Study: |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1348 countStudies++; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1349 break; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1350 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1351 case ResourceType_Series: |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1352 countSeries++; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1353 break; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1354 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1355 default: |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1356 break; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1357 } |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1358 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1359 // Tag all the children of this resource as to be explored |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1360 std::list<int64_t> tmp; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1361 db_->GetChildrenInternalId(tmp, resource); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1362 for (std::list<int64_t>::const_iterator |
| 656 | 1363 it = tmp.begin(); it != tmp.end(); ++it) |
|
440
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1364 { |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1365 toExplore.push(*it); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1366 } |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1367 } |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1368 } |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1369 |
| 646 | 1370 if (countStudies == 0) |
| 1371 { | |
| 1372 countStudies = 1; | |
| 1373 } | |
| 1374 | |
| 1375 if (countSeries == 0) | |
| 1376 { | |
| 1377 countSeries = 1; | |
| 1378 } | |
| 1379 } | |
| 1380 | |
| 1381 | |
| 1382 | |
| 1383 void ServerIndex::GetStatistics(Json::Value& target, | |
| 1384 const std::string& publicId) | |
| 1385 { | |
| 1386 boost::mutex::scoped_lock lock(mutex_); | |
| 1387 | |
| 1388 ResourceType type; | |
| 1389 int64_t top; | |
| 1390 if (!db_->LookupResource(publicId, top, type)) | |
| 1391 { | |
| 1392 throw OrthancException(ErrorCode_UnknownResource); | |
| 1393 } | |
| 1394 | |
| 1395 uint64_t uncompressedSize; | |
| 1396 uint64_t compressedSize; | |
| 1397 unsigned int countStudies; | |
| 1398 unsigned int countSeries; | |
| 1399 unsigned int countInstances; | |
| 1400 GetStatisticsInternal(compressedSize, uncompressedSize, countStudies, | |
| 1401 countSeries, countInstances, top, type); | |
| 1402 | |
|
440
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1403 target = Json::objectValue; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1404 target["DiskSize"] = boost::lexical_cast<std::string>(compressedSize); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1405 target["DiskSizeMB"] = boost::lexical_cast<unsigned int>(compressedSize / MEGA_BYTES); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1406 target["UncompressedSize"] = boost::lexical_cast<std::string>(uncompressedSize); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1407 target["UncompressedSizeMB"] = boost::lexical_cast<unsigned int>(uncompressedSize / MEGA_BYTES); |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1408 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1409 switch (type) |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1410 { |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1411 // Do NOT add "break" below this point! |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1412 case ResourceType_Patient: |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1413 target["CountStudies"] = countStudies; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1414 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1415 case ResourceType_Study: |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1416 target["CountSeries"] = countSeries; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1417 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1418 case ResourceType_Series: |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1419 target["CountInstances"] = countInstances; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1420 |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1421 case ResourceType_Instance: |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1422 default: |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1423 break; |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1424 } |
|
23e5b35e3c5c
statistics for patient/studies/series/instances
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
438
diff
changeset
|
1425 } |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1426 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1427 |
| 646 | 1428 void ServerIndex::GetStatistics(/* out */ uint64_t& compressedSize, |
| 1429 /* out */ uint64_t& uncompressedSize, | |
| 1430 /* out */ unsigned int& countStudies, | |
| 1431 /* out */ unsigned int& countSeries, | |
| 1432 /* out */ unsigned int& countInstances, | |
| 1433 const std::string& publicId) | |
| 1434 { | |
| 1435 boost::mutex::scoped_lock lock(mutex_); | |
| 1436 | |
| 1437 ResourceType type; | |
| 1438 int64_t top; | |
| 1439 if (!db_->LookupResource(publicId, top, type)) | |
| 1440 { | |
| 1441 throw OrthancException(ErrorCode_UnknownResource); | |
| 1442 } | |
| 1443 | |
| 1444 GetStatisticsInternal(compressedSize, uncompressedSize, countStudies, | |
| 1445 countSeries, countInstances, top, type); | |
| 1446 } | |
| 1447 | |
| 1448 | |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1449 void ServerIndex::UnstableResourcesMonitorThread(ServerIndex* that) |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1450 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1451 int stableAge = GetGlobalIntegerParameter("StableAge", 60); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1452 if (stableAge <= 0) |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1453 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1454 stableAge = 60; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1455 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1456 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1457 LOG(INFO) << "Starting the monitor for stable resources (stable age = " << stableAge << ")"; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1458 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1459 while (!that->done_) |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1460 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1461 // Check for stable resources each second |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1462 boost::this_thread::sleep(boost::posix_time::seconds(1)); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1463 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1464 boost::mutex::scoped_lock lock(that->mutex_); |
| 513 | 1465 |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1466 while (!that->unstableResources_.IsEmpty() && |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1467 that->unstableResources_.GetOldestPayload().GetAge() > static_cast<unsigned int>(stableAge)) |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1468 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1469 // This DICOM resource has not received any new instance for |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1470 // some time. It can be considered as stable. |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1471 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1472 UnstableResourcePayload payload; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1473 int64_t id = that->unstableResources_.RemoveOldest(payload); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1474 |
| 513 | 1475 // Ensure that the resource is still existing before logging the change |
| 1476 if (that->db_->IsExistingResource(id)) | |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1477 { |
| 513 | 1478 switch (payload.type_) |
| 1479 { | |
| 1480 case Orthanc::ResourceType_Patient: | |
| 1481 that->db_->LogChange(ChangeType_StablePatient, id, ResourceType_Patient); | |
| 1482 break; | |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1483 |
| 513 | 1484 case Orthanc::ResourceType_Study: |
| 1485 that->db_->LogChange(ChangeType_StableStudy, id, ResourceType_Study); | |
| 1486 break; | |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1487 |
| 513 | 1488 case Orthanc::ResourceType_Series: |
| 1489 that->db_->LogChange(ChangeType_StableSeries, id, ResourceType_Series); | |
| 1490 break; | |
| 1491 | |
| 1492 default: | |
| 1493 throw OrthancException(ErrorCode_InternalError); | |
| 1494 } | |
| 1495 | |
| 1496 //LOG(INFO) << "Stable resource: " << EnumerationToString(payload.type_) << " " << id; | |
|
511
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1497 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1498 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1499 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1500 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1501 LOG(INFO) << "Closing the monitor thread for stable resources"; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1502 } |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1503 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1504 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1505 void ServerIndex::MarkAsUnstable(int64_t id, |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1506 Orthanc::ResourceType type) |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1507 { |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1508 // WARNING: Before calling this method, "mutex_" must be locked. |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1509 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1510 assert(type == Orthanc::ResourceType_Patient || |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1511 type == Orthanc::ResourceType_Study || |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1512 type == Orthanc::ResourceType_Series); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1513 |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1514 unstableResources_.AddOrMakeMostRecent(id, type); |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1515 //LOG(INFO) << "Unstable resource: " << EnumerationToString(type) << " " << id; |
|
3b735fdf320b
monitoring of stable patients/studies/series
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
440
diff
changeset
|
1516 } |
| 521 | 1517 |
| 1518 | |
| 1519 | |
| 1520 void ServerIndex::LookupTagValue(std::list<std::string>& result, | |
| 1521 DicomTag tag, | |
| 615 | 1522 const std::string& value, |
| 1523 ResourceType type) | |
| 1524 { | |
| 1525 result.clear(); | |
| 1526 | |
| 1527 boost::mutex::scoped_lock lock(mutex_); | |
| 1528 | |
| 1529 std::list<int64_t> id; | |
| 1530 db_->LookupTagValue(id, tag, value); | |
| 1531 | |
| 1532 for (std::list<int64_t>::const_iterator | |
| 656 | 1533 it = id.begin(); it != id.end(); ++it) |
| 615 | 1534 { |
| 1535 if (db_->GetResourceType(*it) == type) | |
| 1536 { | |
| 1537 result.push_back(db_->GetPublicId(*it)); | |
| 1538 } | |
| 1539 } | |
| 1540 } | |
| 1541 | |
| 1542 | |
| 1543 void ServerIndex::LookupTagValue(std::list<std::string>& result, | |
| 1544 DicomTag tag, | |
| 521 | 1545 const std::string& value) |
| 1546 { | |
| 1547 result.clear(); | |
| 1548 | |
| 1549 boost::mutex::scoped_lock lock(mutex_); | |
| 1550 | |
| 1551 std::list<int64_t> id; | |
| 1552 db_->LookupTagValue(id, tag, value); | |
| 1553 | |
| 1554 for (std::list<int64_t>::const_iterator | |
| 656 | 1555 it = id.begin(); it != id.end(); ++it) |
| 521 | 1556 { |
| 1557 result.push_back(db_->GetPublicId(*it)); | |
| 1558 } | |
| 1559 } | |
| 1560 | |
| 1561 | |
| 1562 void ServerIndex::LookupTagValue(std::list<std::string>& result, | |
| 1563 const std::string& value) | |
| 1564 { | |
| 1565 result.clear(); | |
| 1566 | |
| 1567 boost::mutex::scoped_lock lock(mutex_); | |
| 1568 | |
| 1569 std::list<int64_t> id; | |
| 1570 db_->LookupTagValue(id, value); | |
| 1571 | |
| 1572 for (std::list<int64_t>::const_iterator | |
| 656 | 1573 it = id.begin(); it != id.end(); ++it) |
| 521 | 1574 { |
| 1575 result.push_back(db_->GetPublicId(*it)); | |
| 1576 } | |
| 1577 } | |
|
681
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1578 |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1579 |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1580 // TODO IS IT USEFUL??? |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1581 void ServerIndex::LookupTagValue(std::set<std::string>& result, |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1582 DicomTag tag, |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1583 const std::string& value, |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1584 ResourceType type) |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1585 { |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1586 std::list<std::string> lst; |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1587 LookupTagValue(lst, tag, value, type); |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1588 |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1589 result.clear(); |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1590 for (std::list<std::string>::const_iterator |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1591 it = lst.begin(); it != lst.end(); it++) |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1592 { |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1593 result.insert(*it); |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1594 } |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1595 } |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1596 |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1597 |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1598 // TODO IS IT USEFUL??? |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1599 void ServerIndex::LookupTagValue(std::set<std::string>& result, |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1600 DicomTag tag, |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1601 const std::string& value) |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1602 { |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1603 std::list<std::string> lst; |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1604 LookupTagValue(lst, tag, value); |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1605 |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1606 result.clear(); |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1607 for (std::list<std::string>::const_iterator |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1608 it = lst.begin(); it != lst.end(); it++) |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1609 { |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1610 result.insert(*it); |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1611 } |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1612 } |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1613 |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1614 |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1615 // TODO IS IT USEFUL??? |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1616 void ServerIndex::LookupTagValue(std::set<std::string>& result, |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1617 const std::string& value) |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1618 { |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1619 std::list<std::string> lst; |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1620 LookupTagValue(lst, value); |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1621 |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1622 result.clear(); |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1623 for (std::list<std::string>::const_iterator |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1624 it = lst.begin(); it != lst.end(); it++) |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1625 { |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1626 result.insert(*it); |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1627 } |
|
3bdb5db8e839
generalization of query/retrieve
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
656
diff
changeset
|
1628 } |
| 0 | 1629 } |