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