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