Mercurial > hg > orthanc
annotate UnitTests/ServerIndex.cpp @ 208:de640de989b8
HttpFileSender
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Wed, 28 Nov 2012 17:00:46 +0100 |
| parents | 7f74209ea0f8 |
| children | 9960642f0f45 |
| rev | line source |
|---|---|
| 181 | 1 #include "gtest/gtest.h" |
| 2 | |
| 183 | 3 #include "../OrthancServer/DatabaseWrapper.h" |
| 4 | |
| 181 | 5 #include <ctype.h> |
| 6 #include <glog/logging.h> | |
| 7 | |
| 183 | 8 using namespace Orthanc; |
| 181 | 9 |
| 183 | 10 namespace |
| 11 { | |
| 181 | 12 class ServerIndexListener : public IServerIndexListener |
| 13 { | |
| 14 public: | |
| 183 | 15 std::set<std::string> deletedFiles_; |
| 16 std::string ancestorId_; | |
| 17 ResourceType ancestorType_; | |
| 18 | |
| 19 void Reset() | |
| 181 | 20 { |
| 183 | 21 ancestorId_ = ""; |
| 22 deletedFiles_.clear(); | |
| 23 } | |
| 24 | |
| 25 virtual void SignalRemainingAncestor(ResourceType type, | |
| 26 const std::string& publicId) | |
| 27 { | |
| 28 ancestorId_ = publicId; | |
| 29 ancestorType_ = type; | |
| 181 | 30 } |
| 31 | |
| 32 virtual void SignalFileDeleted(const std::string& fileUuid) | |
| 33 { | |
| 183 | 34 deletedFiles_.insert(fileUuid); |
| 181 | 35 LOG(INFO) << "A file must be removed: " << fileUuid; |
| 36 } | |
| 37 }; | |
| 38 } | |
| 39 | |
| 40 | |
| 183 | 41 TEST(DatabaseWrapper, Simple) |
| 181 | 42 { |
| 43 ServerIndexListener listener; | |
| 183 | 44 DatabaseWrapper index(listener); |
| 181 | 45 |
| 46 int64_t a[] = { | |
| 182 | 47 index.CreateResource("a", ResourceType_Patient), // 0 |
| 48 index.CreateResource("b", ResourceType_Study), // 1 | |
| 49 index.CreateResource("c", ResourceType_Series), // 2 | |
| 50 index.CreateResource("d", ResourceType_Instance), // 3 | |
| 51 index.CreateResource("e", ResourceType_Instance), // 4 | |
| 52 index.CreateResource("f", ResourceType_Instance), // 5 | |
| 53 index.CreateResource("g", ResourceType_Study) // 6 | |
| 181 | 54 }; |
| 55 | |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
56 ASSERT_EQ("a", index.GetPublicId(a[0])); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
57 ASSERT_EQ("b", index.GetPublicId(a[1])); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
58 ASSERT_EQ("c", index.GetPublicId(a[2])); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
59 ASSERT_EQ("d", index.GetPublicId(a[3])); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
60 ASSERT_EQ("e", index.GetPublicId(a[4])); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
61 ASSERT_EQ("f", index.GetPublicId(a[5])); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
62 ASSERT_EQ("g", index.GetPublicId(a[6])); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
63 |
| 190 | 64 { |
| 65 Json::Value t; | |
| 66 index.GetAllPublicIds(t, ResourceType_Patient); | |
| 67 | |
| 68 ASSERT_EQ(1, t.size()); | |
| 69 ASSERT_EQ("a", t[0u].asString()); | |
| 70 | |
| 71 index.GetAllPublicIds(t, ResourceType_Series); | |
| 72 ASSERT_EQ(1, t.size()); | |
| 73 ASSERT_EQ("c", t[0u].asString()); | |
| 74 | |
| 75 index.GetAllPublicIds(t, ResourceType_Study); | |
| 76 ASSERT_EQ(2, t.size()); | |
| 77 | |
| 78 index.GetAllPublicIds(t, ResourceType_Instance); | |
| 79 ASSERT_EQ(3, t.size()); | |
| 80 } | |
| 81 | |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
198
diff
changeset
|
82 index.SetGlobalProperty(GlobalProperty_FlushSleep, "World"); |
| 181 | 83 |
| 84 index.AttachChild(a[0], a[1]); | |
| 85 index.AttachChild(a[1], a[2]); | |
| 86 index.AttachChild(a[2], a[3]); | |
| 87 index.AttachChild(a[2], a[4]); | |
| 88 index.AttachChild(a[6], a[5]); | |
| 182 | 89 |
|
198
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
90 int64_t parent; |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
91 ASSERT_FALSE(index.LookupParent(parent, a[0])); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
92 ASSERT_TRUE(index.LookupParent(parent, a[1])); ASSERT_EQ(a[0], parent); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
93 ASSERT_TRUE(index.LookupParent(parent, a[2])); ASSERT_EQ(a[1], parent); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
94 ASSERT_TRUE(index.LookupParent(parent, a[3])); ASSERT_EQ(a[2], parent); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
95 ASSERT_TRUE(index.LookupParent(parent, a[4])); ASSERT_EQ(a[2], parent); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
96 ASSERT_TRUE(index.LookupParent(parent, a[5])); ASSERT_EQ(a[6], parent); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
97 ASSERT_FALSE(index.LookupParent(parent, a[6])); |
|
663cc6c46d0a
before refactoring of ServerIndex::GetXXX
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
197
diff
changeset
|
98 |
| 182 | 99 std::string s; |
| 100 | |
| 101 ASSERT_FALSE(index.GetParentPublicId(s, a[0])); | |
| 102 ASSERT_FALSE(index.GetParentPublicId(s, a[6])); | |
| 103 ASSERT_TRUE(index.GetParentPublicId(s, a[1])); ASSERT_EQ("a", s); | |
| 104 ASSERT_TRUE(index.GetParentPublicId(s, a[2])); ASSERT_EQ("b", s); | |
| 105 ASSERT_TRUE(index.GetParentPublicId(s, a[3])); ASSERT_EQ("c", s); | |
| 106 ASSERT_TRUE(index.GetParentPublicId(s, a[4])); ASSERT_EQ("c", s); | |
| 107 ASSERT_TRUE(index.GetParentPublicId(s, a[5])); ASSERT_EQ("g", s); | |
| 108 | |
| 185 | 109 std::list<std::string> l; |
| 182 | 110 index.GetChildrenPublicId(l, a[0]); ASSERT_EQ(1, l.size()); ASSERT_EQ("b", l.front()); |
| 111 index.GetChildrenPublicId(l, a[1]); ASSERT_EQ(1, l.size()); ASSERT_EQ("c", l.front()); | |
| 112 index.GetChildrenPublicId(l, a[3]); ASSERT_EQ(0, l.size()); | |
| 113 index.GetChildrenPublicId(l, a[4]); ASSERT_EQ(0, l.size()); | |
| 114 index.GetChildrenPublicId(l, a[5]); ASSERT_EQ(0, l.size()); | |
| 115 index.GetChildrenPublicId(l, a[6]); ASSERT_EQ(1, l.size()); ASSERT_EQ("f", l.front()); | |
| 116 | |
| 117 index.GetChildrenPublicId(l, a[2]); ASSERT_EQ(2, l.size()); | |
| 118 if (l.front() == "d") | |
| 119 { | |
| 120 ASSERT_EQ("e", l.back()); | |
| 121 } | |
| 122 else | |
| 123 { | |
| 124 ASSERT_EQ("d", l.back()); | |
| 125 ASSERT_EQ("e", l.front()); | |
| 126 } | |
| 127 | |
|
197
530a25320461
removal of text as ids in sqlite db
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
193
diff
changeset
|
128 index.AttachFile(a[4], AttachedFileType_Json, "my json file", 21, 42, CompressionType_Zlib); |
|
530a25320461
removal of text as ids in sqlite db
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
193
diff
changeset
|
129 index.AttachFile(a[4], AttachedFileType_Dicom, "my dicom file", 42); |
|
530a25320461
removal of text as ids in sqlite db
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
193
diff
changeset
|
130 index.AttachFile(a[6], AttachedFileType_Dicom, "world", 44); |
| 183 | 131 index.SetMetadata(a[4], MetadataType_Instance_RemoteAet, "PINNACLE"); |
| 182 | 132 |
| 183 | 133 ASSERT_EQ(21 + 42 + 44, index.GetTotalCompressedSize()); |
| 134 ASSERT_EQ(42 + 42 + 44, index.GetTotalUncompressedSize()); | |
| 181 | 135 |
| 136 DicomMap m; | |
| 137 m.SetValue(0x0010, 0x0010, "PatientName"); | |
| 138 index.SetMainDicomTags(a[3], m); | |
| 139 | |
| 140 int64_t b; | |
| 141 ResourceType t; | |
|
188
090cefdab1d1
fix because of Windows macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
185
diff
changeset
|
142 ASSERT_TRUE(index.LookupResource("g", b, t)); |
| 181 | 143 ASSERT_EQ(7, b); |
| 144 ASSERT_EQ(ResourceType_Study, t); | |
| 145 | |
|
188
090cefdab1d1
fix because of Windows macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
185
diff
changeset
|
146 ASSERT_TRUE(index.LookupMetadata(s, a[4], MetadataType_Instance_RemoteAet)); |
|
090cefdab1d1
fix because of Windows macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
185
diff
changeset
|
147 ASSERT_FALSE(index.LookupMetadata(s, a[4], MetadataType_Instance_IndexInSeries)); |
| 181 | 148 ASSERT_EQ("PINNACLE", s); |
| 149 ASSERT_EQ("PINNACLE", index.GetMetadata(a[4], MetadataType_Instance_RemoteAet)); | |
| 150 ASSERT_EQ("None", index.GetMetadata(a[4], MetadataType_Instance_IndexInSeries, "None")); | |
| 151 | |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
198
diff
changeset
|
152 ASSERT_TRUE(index.LookupGlobalProperty(s, GlobalProperty_FlushSleep)); |
|
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
198
diff
changeset
|
153 ASSERT_FALSE(index.LookupGlobalProperty(s, static_cast<GlobalProperty>(42))); |
| 181 | 154 ASSERT_EQ("World", s); |
|
206
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
198
diff
changeset
|
155 ASSERT_EQ("World", index.GetGlobalProperty(GlobalProperty_FlushSleep)); |
|
4453a010d0db
flush to disk thread
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
198
diff
changeset
|
156 ASSERT_EQ("None", index.GetGlobalProperty(static_cast<GlobalProperty>(42), "None")); |
| 181 | 157 |
|
188
090cefdab1d1
fix because of Windows macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
185
diff
changeset
|
158 uint64_t us, cs; |
| 181 | 159 CompressionType ct; |
|
197
530a25320461
removal of text as ids in sqlite db
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
193
diff
changeset
|
160 ASSERT_TRUE(index.LookupFile(a[4], AttachedFileType_Json, s, cs, us, ct)); |
| 181 | 161 ASSERT_EQ("my json file", s); |
| 183 | 162 ASSERT_EQ(21, cs); |
| 181 | 163 ASSERT_EQ(42, us); |
| 164 ASSERT_EQ(CompressionType_Zlib, ct); | |
| 165 | |
|
188
090cefdab1d1
fix because of Windows macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
185
diff
changeset
|
166 ASSERT_EQ(0u, listener.deletedFiles_.size()); |
| 181 | 167 ASSERT_EQ(7, index.GetTableRecordCount("Resources")); |
| 183 | 168 ASSERT_EQ(3, index.GetTableRecordCount("AttachedFiles")); |
| 181 | 169 ASSERT_EQ(1, index.GetTableRecordCount("Metadata")); |
| 170 ASSERT_EQ(1, index.GetTableRecordCount("MainDicomTags")); | |
| 171 index.DeleteResource(a[0]); | |
| 183 | 172 |
| 173 ASSERT_EQ(2, listener.deletedFiles_.size()); | |
| 185 | 174 ASSERT_FALSE(listener.deletedFiles_.find("my json file") == listener.deletedFiles_.end()); |
| 175 ASSERT_FALSE(listener.deletedFiles_.find("my dicom file") == listener.deletedFiles_.end()); | |
| 183 | 176 |
| 181 | 177 ASSERT_EQ(2, index.GetTableRecordCount("Resources")); |
| 178 ASSERT_EQ(0, index.GetTableRecordCount("Metadata")); | |
| 183 | 179 ASSERT_EQ(1, index.GetTableRecordCount("AttachedFiles")); |
| 180 ASSERT_EQ(0, index.GetTableRecordCount("MainDicomTags")); | |
| 181 index.DeleteResource(a[5]); | |
| 182 ASSERT_EQ(0, index.GetTableRecordCount("Resources")); | |
| 181 | 183 ASSERT_EQ(0, index.GetTableRecordCount("AttachedFiles")); |
| 183 | 184 ASSERT_EQ(1, index.GetTableRecordCount("GlobalProperties")); |
| 185 | |
| 186 ASSERT_EQ(3, listener.deletedFiles_.size()); | |
| 185 | 187 ASSERT_FALSE(listener.deletedFiles_.find("world") == listener.deletedFiles_.end()); |
| 183 | 188 } |
| 189 | |
| 190 | |
| 191 | |
| 192 | |
| 193 TEST(DatabaseWrapper, Upward) | |
| 194 { | |
| 195 ServerIndexListener listener; | |
| 196 DatabaseWrapper index(listener); | |
| 197 | |
| 198 int64_t a[] = { | |
| 199 index.CreateResource("a", ResourceType_Patient), // 0 | |
| 200 index.CreateResource("b", ResourceType_Study), // 1 | |
| 201 index.CreateResource("c", ResourceType_Series), // 2 | |
| 202 index.CreateResource("d", ResourceType_Instance), // 3 | |
| 203 index.CreateResource("e", ResourceType_Instance), // 4 | |
| 204 index.CreateResource("f", ResourceType_Study), // 5 | |
| 205 index.CreateResource("g", ResourceType_Series), // 6 | |
| 206 index.CreateResource("h", ResourceType_Series) // 7 | |
| 207 }; | |
| 208 | |
| 209 index.AttachChild(a[0], a[1]); | |
| 210 index.AttachChild(a[1], a[2]); | |
| 211 index.AttachChild(a[2], a[3]); | |
| 212 index.AttachChild(a[2], a[4]); | |
| 213 index.AttachChild(a[1], a[6]); | |
| 214 index.AttachChild(a[0], a[5]); | |
| 215 index.AttachChild(a[5], a[7]); | |
| 216 | |
|
193
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
217 { |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
218 Json::Value j; |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
219 index.GetChildren(j, a[0]); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
220 ASSERT_EQ(2, j.size()); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
221 ASSERT_TRUE((j[0u] == "b" && j[1u] == "f") || |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
222 (j[1u] == "b" && j[0u] == "f")); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
223 |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
224 index.GetChildren(j, a[1]); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
225 ASSERT_EQ(2, j.size()); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
226 ASSERT_TRUE((j[0u] == "c" && j[1u] == "g") || |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
227 (j[1u] == "c" && j[0u] == "g")); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
228 |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
229 index.GetChildren(j, a[2]); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
230 ASSERT_EQ(2, j.size()); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
231 ASSERT_TRUE((j[0u] == "d" && j[1u] == "e") || |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
232 (j[1u] == "d" && j[0u] == "e")); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
233 |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
234 index.GetChildren(j, a[3]); ASSERT_EQ(0, j.size()); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
235 index.GetChildren(j, a[4]); ASSERT_EQ(0, j.size()); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
236 index.GetChildren(j, a[5]); ASSERT_EQ(1, j.size()); ASSERT_EQ("h", j[0u].asString()); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
237 index.GetChildren(j, a[6]); ASSERT_EQ(0, j.size()); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
238 index.GetChildren(j, a[7]); ASSERT_EQ(0, j.size()); |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
239 } |
|
a1b9d1e1497b
failed attempt to compile with linux standard base
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
240 |
| 183 | 241 listener.Reset(); |
| 242 index.DeleteResource(a[3]); | |
| 243 ASSERT_EQ("c", listener.ancestorId_); | |
| 244 ASSERT_EQ(ResourceType_Series, listener.ancestorType_); | |
| 245 | |
| 246 listener.Reset(); | |
| 247 index.DeleteResource(a[4]); | |
| 248 ASSERT_EQ("b", listener.ancestorId_); | |
| 249 ASSERT_EQ(ResourceType_Study, listener.ancestorType_); | |
| 250 | |
| 251 listener.Reset(); | |
| 252 index.DeleteResource(a[7]); | |
| 253 ASSERT_EQ("a", listener.ancestorId_); | |
| 254 ASSERT_EQ(ResourceType_Patient, listener.ancestorType_); | |
| 255 | |
| 256 listener.Reset(); | |
| 181 | 257 index.DeleteResource(a[6]); |
| 183 | 258 ASSERT_EQ("", listener.ancestorId_); // No more ancestor |
| 181 | 259 } |
| 207 | 260 |
| 261 | |
| 262 | |
| 208 | 263 |
| 264 #include "../Core/HttpServer/FilesystemHttpSender.h" | |
| 265 | |
| 207 | 266 #include "../Core/Toolbox.h" |
| 267 #include "../Core/HttpServer/HttpOutput.h" | |
| 268 #include "../Core/HttpServer/HttpHandler.h" | |
| 269 | |
| 208 | 270 #include "../Core/HttpServer/HttpFileSender.h" |
| 271 | |
| 272 | |
| 207 | 273 namespace Orthanc |
| 274 { | |
| 275 class RestApiPath | |
| 276 { | |
| 277 private: | |
| 278 UriComponents uri_; | |
| 279 bool hasTrailing_; | |
| 280 std::vector<std::string> components_; | |
| 281 | |
| 282 public: | |
| 283 typedef std::map<std::string, std::string> Components; | |
| 284 | |
| 285 RestApiPath(const std::string& uri) | |
| 286 { | |
| 287 Toolbox::SplitUriComponents(uri_, uri); | |
| 288 | |
| 289 if (uri_.size() == 0) | |
| 290 { | |
| 291 return; | |
| 292 } | |
| 293 | |
| 294 if (uri_.back() == "*") | |
| 295 { | |
| 296 hasTrailing_ = true; | |
| 297 uri_.pop_back(); | |
| 298 } | |
| 299 else | |
| 300 { | |
| 301 hasTrailing_ = false; | |
| 302 } | |
| 303 | |
| 304 components_.resize(uri_.size()); | |
| 305 for (size_t i = 0; i < uri_.size(); i++) | |
| 306 { | |
| 307 size_t s = uri_[i].size(); | |
| 308 assert(s > 0); | |
| 309 | |
| 310 if (uri_[i][0] == '{' && | |
| 311 uri_[i][s - 1] == '}') | |
| 312 { | |
| 313 components_[i] = uri_[i].substr(1, s - 2); | |
| 314 uri_[i] = ""; | |
| 315 } | |
| 316 else | |
| 317 { | |
| 318 components_[i] = ""; | |
| 319 } | |
| 320 } | |
| 321 } | |
| 322 | |
| 323 // This version is slower | |
| 324 bool Match(Components& components, | |
| 325 UriComponents& trailing, | |
| 326 const std::string& uriRaw) const | |
| 327 { | |
| 328 UriComponents uri; | |
| 329 Toolbox::SplitUriComponents(uri, uriRaw); | |
| 330 return Match(components, trailing, uri); | |
| 331 } | |
| 332 | |
| 333 bool Match(Components& components, | |
| 334 UriComponents& trailing, | |
| 335 const UriComponents& uri) const | |
| 336 { | |
| 337 if (uri.size() < uri_.size()) | |
| 338 { | |
| 339 return false; | |
| 340 } | |
| 341 | |
| 342 if (!hasTrailing_ && uri.size() > uri_.size()) | |
| 343 { | |
| 344 return false; | |
| 345 } | |
| 346 | |
| 347 components.clear(); | |
| 348 trailing.clear(); | |
| 349 | |
| 350 assert(uri_.size() <= uri.size()); | |
| 351 for (size_t i = 0; i < uri_.size(); i++) | |
| 352 { | |
| 353 if (components_[i].size() == 0) | |
| 354 { | |
| 355 // This URI component is not a free parameter | |
| 356 if (uri_[i] != uri[i]) | |
| 357 { | |
| 358 return false; | |
| 359 } | |
| 360 } | |
| 361 else | |
| 362 { | |
| 363 // This URI component is a free parameter | |
| 364 components[components_[i]] = uri[i]; | |
| 365 } | |
| 366 } | |
| 367 | |
| 368 if (hasTrailing_) | |
| 369 { | |
| 370 trailing.assign(uri.begin() + uri_.size(), uri.end()); | |
| 371 } | |
| 372 | |
| 373 return true; | |
| 374 } | |
| 375 | |
| 376 bool Match(const UriComponents& uri) const | |
| 377 { | |
| 378 Components components; | |
| 379 UriComponents trailing; | |
| 380 return Match(components, trailing, uri); | |
| 381 } | |
| 382 }; | |
| 383 | |
| 384 | |
| 385 class RestApiOutput | |
| 386 { | |
| 387 private: | |
| 388 HttpOutput& output_; | |
| 389 | |
| 390 public: | |
| 391 RestApiOutput(HttpOutput& output) : output_(output) | |
| 392 { | |
| 393 } | |
| 394 | |
| 395 void AnswerFile(HttpFileSender& sender) | |
| 396 { | |
| 397 sender.Send(output_); | |
| 398 } | |
| 399 | |
| 400 void AnswerJson(const Json::Value& value) | |
| 401 { | |
| 402 Json::StyledWriter writer; | |
| 403 std::string s = writer.write(value); | |
| 404 output_.AnswerBufferWithContentType(s, "application/json"); | |
| 405 } | |
| 406 | |
| 407 void AnswerBuffer(const std::string& buffer, | |
| 408 const std::string& contentType) | |
| 409 { | |
| 410 output_.AnswerBufferWithContentType(buffer, contentType); | |
| 411 } | |
| 412 | |
| 413 void Redirect(const char* path) | |
| 414 { | |
| 415 output_.Redirect(path); | |
| 416 } | |
| 417 }; | |
| 418 | |
| 419 | |
| 420 class RestApiSharedCall | |
| 421 { | |
| 422 protected: | |
| 423 RestApiOutput* output_; | |
| 424 IDynamicObject* context_; | |
| 425 const HttpHandler::Arguments* httpHeaders_; | |
| 426 const RestApiPath::Components* uriComponents_; | |
| 427 const UriComponents* trailing_; | |
| 428 | |
| 429 public: | |
| 430 RestApiOutput& GetOutput() | |
| 431 { | |
| 432 return *output_; | |
| 433 } | |
| 434 | |
| 435 IDynamicObject* GetContext() | |
| 436 { | |
| 437 return context_; | |
| 438 } | |
| 439 | |
| 440 const HttpHandler::Arguments& GetHttpHeaders() const | |
| 441 { | |
| 442 return *httpHeaders_; | |
| 443 } | |
| 444 | |
| 445 const RestApiPath::Components& GetUriComponents() const | |
| 446 { | |
| 447 return *uriComponents_; | |
| 448 } | |
| 449 | |
| 450 const UriComponents& GetTrailing() const | |
| 451 { | |
| 452 return *trailing_; | |
| 453 } | |
| 454 | |
| 455 std::string GetUriComponent(const std::string& name, | |
| 456 const std::string& defaultValue) | |
| 457 { | |
| 458 return HttpHandler::GetArgument(*uriComponents_, name, defaultValue); | |
| 459 } | |
| 460 }; | |
| 461 | |
| 462 | |
| 463 class RestApiPutCall : public RestApiSharedCall | |
| 464 { | |
| 465 friend class RestApi; | |
| 466 | |
| 467 private: | |
| 468 const std::string* data_; | |
| 469 | |
| 470 public: | |
| 471 const std::string& GetData() | |
| 472 { | |
| 473 return *data_; | |
| 474 } | |
| 475 }; | |
| 476 | |
| 477 | |
| 478 class RestApiPostCall : public RestApiSharedCall | |
| 479 { | |
| 480 friend class RestApi; | |
| 481 | |
| 482 private: | |
| 483 const std::string* data_; | |
| 484 | |
| 485 public: | |
| 486 const std::string& GetData() | |
| 487 { | |
| 488 return *data_; | |
| 489 } | |
| 490 }; | |
| 491 | |
| 492 | |
| 493 | |
| 494 class RestApiDeleteCall : public RestApiSharedCall | |
| 495 { | |
| 496 friend class RestApi; | |
| 497 }; | |
| 498 | |
| 499 | |
| 500 | |
| 501 | |
| 502 class RestApiGetCall : public RestApiSharedCall | |
| 503 { | |
| 504 friend class RestApi; | |
| 505 | |
| 506 private: | |
| 507 const HttpHandler::Arguments* getArguments_; | |
| 508 | |
| 509 public: | |
| 510 std::string GetArgument(const std::string& name, | |
| 511 const std::string& defaultValue) | |
| 512 { | |
| 513 return HttpHandler::GetArgument(*getArguments_, name, defaultValue); | |
| 514 } | |
| 515 }; | |
| 516 | |
| 517 | |
| 518 | |
| 519 class RestApi : public HttpHandler | |
| 520 { | |
| 521 public: | |
| 522 typedef void (*GetHandler) (RestApiGetCall& call); | |
| 523 | |
| 524 typedef void (*DeleteHandler) (RestApiDeleteCall& call); | |
| 525 | |
| 526 typedef void (*PutHandler) (RestApiPutCall& call); | |
| 527 | |
| 528 typedef void (*PostHandler) (RestApiPostCall& call); | |
| 529 | |
| 530 private: | |
| 531 typedef std::list< std::pair<RestApiPath*, GetHandler> > GetHandlers; | |
| 532 typedef std::list< std::pair<RestApiPath*, PutHandler> > PutHandlers; | |
| 533 typedef std::list< std::pair<RestApiPath*, PostHandler> > PostHandlers; | |
| 534 typedef std::list< std::pair<RestApiPath*, DeleteHandler> > DeleteHandlers; | |
| 535 | |
| 536 // TODO MUTEX BETWEEN CONTEXTS !!! | |
| 537 std::auto_ptr<IDynamicObject> context_; | |
| 538 | |
| 539 GetHandlers getHandlers_; | |
| 540 PutHandlers putHandlers_; | |
| 541 PostHandlers postHandlers_; | |
| 542 DeleteHandlers deleteHandlers_; | |
| 543 | |
| 544 bool IsGetAccepted(const UriComponents& uri) | |
| 545 { | |
| 546 for (GetHandlers::const_iterator it = getHandlers_.begin(); | |
| 547 it != getHandlers_.end(); it++) | |
| 548 { | |
| 549 if (it->first->Match(uri)) | |
| 550 { | |
| 551 return true; | |
| 552 } | |
| 553 } | |
| 554 | |
| 555 return false; | |
| 556 } | |
| 557 | |
| 558 bool IsPutAccepted(const UriComponents& uri) | |
| 559 { | |
| 560 for (PutHandlers::const_iterator it = putHandlers_.begin(); | |
| 561 it != putHandlers_.end(); it++) | |
| 562 { | |
| 563 if (it->first->Match(uri)) | |
| 564 { | |
| 565 return true; | |
| 566 } | |
| 567 } | |
| 568 | |
| 569 return false; | |
| 570 } | |
| 571 | |
| 572 bool IsPostAccepted(const UriComponents& uri) | |
| 573 { | |
| 574 for (PostHandlers::const_iterator it = postHandlers_.begin(); | |
| 575 it != postHandlers_.end(); it++) | |
| 576 { | |
| 577 if (it->first->Match(uri)) | |
| 578 { | |
| 579 return true; | |
| 580 } | |
| 581 } | |
| 582 | |
| 583 return false; | |
| 584 } | |
| 585 | |
| 586 bool IsDeleteAccepted(const UriComponents& uri) | |
| 587 { | |
| 588 for (DeleteHandlers::const_iterator it = deleteHandlers_.begin(); | |
| 589 it != deleteHandlers_.end(); it++) | |
| 590 { | |
| 591 if (it->first->Match(uri)) | |
| 592 { | |
| 593 return true; | |
| 594 } | |
| 595 } | |
| 596 | |
| 597 return false; | |
| 598 } | |
| 599 | |
| 600 void AddMethod(std::string& target, | |
| 601 const std::string& method) const | |
| 602 { | |
| 603 if (target.size() > 0) | |
| 604 target += "," + method; | |
| 605 else | |
| 606 target = method; | |
| 607 } | |
| 608 | |
| 609 std::string GetAcceptedMethods(const UriComponents& uri) | |
| 610 { | |
| 611 std::string s; | |
| 612 | |
| 613 if (IsGetAccepted(uri)) | |
| 614 AddMethod(s, "GET"); | |
| 615 | |
| 616 if (IsPutAccepted(uri)) | |
| 617 AddMethod(s, "PUT"); | |
| 618 | |
| 619 if (IsPostAccepted(uri)) | |
| 620 AddMethod(s, "POST"); | |
| 621 | |
| 622 if (IsDeleteAccepted(uri)) | |
| 623 AddMethod(s, "DELETE"); | |
| 624 | |
| 625 return s; | |
| 626 } | |
| 627 | |
| 628 public: | |
| 629 RestApi() | |
| 630 { | |
| 631 } | |
| 632 | |
| 633 void SetContext(IDynamicObject* context) // This takes the ownership | |
| 634 { | |
| 635 context_.reset(context); | |
| 636 } | |
| 637 | |
| 638 ~RestApi() | |
| 639 { | |
| 640 for (GetHandlers::iterator it = getHandlers_.begin(); | |
| 641 it != getHandlers_.end(); it++) | |
| 642 { | |
| 643 delete it->first; | |
| 644 } | |
| 645 | |
| 646 for (PutHandlers::iterator it = putHandlers_.begin(); | |
| 647 it != putHandlers_.end(); it++) | |
| 648 { | |
| 649 delete it->first; | |
| 650 } | |
| 651 | |
| 652 for (PostHandlers::iterator it = postHandlers_.begin(); | |
| 653 it != postHandlers_.end(); it++) | |
| 654 { | |
| 655 delete it->first; | |
| 656 } | |
| 657 | |
| 658 for (DeleteHandlers::iterator it = deleteHandlers_.begin(); | |
| 659 it != deleteHandlers_.end(); it++) | |
| 660 { | |
| 661 delete it->first; | |
| 662 } | |
| 663 } | |
| 664 | |
| 665 virtual bool IsServedUri(const UriComponents& uri) | |
| 666 { | |
| 667 return (IsGetAccepted(uri) || | |
| 668 IsPutAccepted(uri) || | |
| 669 IsPostAccepted(uri) || | |
| 670 IsDeleteAccepted(uri)); | |
| 671 } | |
| 672 | |
| 673 virtual void Handle(HttpOutput& output, | |
| 674 const std::string& method, | |
| 675 const UriComponents& uri, | |
| 676 const Arguments& headers, | |
| 677 const Arguments& getArguments, | |
| 678 const std::string& postData) | |
| 679 { | |
| 680 bool ok = false; | |
| 681 RestApiOutput restOutput(output); | |
| 682 RestApiPath::Components components; | |
| 683 UriComponents trailing; | |
| 684 | |
| 685 if (method == "GET") | |
| 686 { | |
| 687 for (GetHandlers::const_iterator it = getHandlers_.begin(); | |
| 688 it != getHandlers_.end(); it++) | |
| 689 { | |
| 690 if (it->first->Match(components, trailing, uri)) | |
| 691 { | |
| 692 ok = true; | |
| 693 RestApiGetCall call; | |
| 694 call.output_ = &restOutput; | |
| 695 call.context_ = context_.get(); | |
| 696 call.httpHeaders_ = &headers; | |
| 697 call.uriComponents_ = &components; | |
| 698 call.trailing_ = &trailing; | |
| 699 | |
| 700 call.getArguments_ = &getArguments; | |
| 701 it->second(call); | |
| 702 } | |
| 703 } | |
| 704 } | |
| 705 else if (method == "PUT") | |
| 706 { | |
| 707 for (PutHandlers::const_iterator it = putHandlers_.begin(); | |
| 708 it != putHandlers_.end(); it++) | |
| 709 { | |
| 710 if (it->first->Match(components, trailing, uri)) | |
| 711 { | |
| 712 ok = true; | |
| 713 RestApiPutCall call; | |
| 714 call.output_ = &restOutput; | |
| 715 call.context_ = context_.get(); | |
| 716 call.httpHeaders_ = &headers; | |
| 717 call.uriComponents_ = &components; | |
| 718 call.trailing_ = &trailing; | |
| 719 | |
| 720 call.data_ = &postData; | |
| 721 it->second(call); | |
| 722 } | |
| 723 } | |
| 724 } | |
| 725 else if (method == "POST") | |
| 726 { | |
| 727 for (PostHandlers::const_iterator it = postHandlers_.begin(); | |
| 728 it != postHandlers_.end(); it++) | |
| 729 { | |
| 730 if (it->first->Match(components, trailing, uri)) | |
| 731 { | |
| 732 ok = true; | |
| 733 RestApiPostCall call; | |
| 734 call.output_ = &restOutput; | |
| 735 call.context_ = context_.get(); | |
| 736 call.httpHeaders_ = &headers; | |
| 737 call.uriComponents_ = &components; | |
| 738 call.trailing_ = &trailing; | |
| 739 | |
| 740 call.data_ = &postData; | |
| 741 it->second(call); | |
| 742 } | |
| 743 } | |
| 744 } | |
| 745 else if (method == "DELETE") | |
| 746 { | |
| 747 for (DeleteHandlers::const_iterator it = deleteHandlers_.begin(); | |
| 748 it != deleteHandlers_.end(); it++) | |
| 749 { | |
| 750 if (it->first->Match(components, trailing, uri)) | |
| 751 { | |
| 752 ok = true; | |
| 753 RestApiDeleteCall call; | |
| 754 call.output_ = &restOutput; | |
| 755 call.context_ = context_.get(); | |
| 756 call.httpHeaders_ = &headers; | |
| 757 call.uriComponents_ = &components; | |
| 758 call.trailing_ = &trailing; | |
| 759 it->second(call); | |
| 760 } | |
| 761 } | |
| 762 } | |
| 763 | |
| 764 if (!ok) | |
| 765 { | |
| 766 output.SendMethodNotAllowedError(GetAcceptedMethods(uri)); | |
| 767 } | |
| 768 } | |
| 769 | |
| 770 void Register(const std::string& path, | |
| 771 GetHandler handler) | |
| 772 { | |
| 773 getHandlers_.push_back(std::make_pair(new RestApiPath(path), handler)); | |
| 774 } | |
| 775 | |
| 776 | |
| 777 void Register(const std::string& path, | |
| 778 PutHandler handler) | |
| 779 { | |
| 780 putHandlers_.push_back(std::make_pair(new RestApiPath(path), handler)); | |
| 781 } | |
| 782 | |
| 783 | |
| 784 void Register(const std::string& path, | |
| 785 PostHandler handler) | |
| 786 { | |
| 787 postHandlers_.push_back(std::make_pair(new RestApiPath(path), handler)); | |
| 788 } | |
| 789 | |
| 790 | |
| 791 void Register(const std::string& path, | |
| 792 DeleteHandler handler) | |
| 793 { | |
| 794 deleteHandlers_.push_back(std::make_pair(new RestApiPath(path), handler)); | |
| 795 } | |
| 796 | |
| 797 }; | |
| 798 | |
| 799 } | |
| 800 | |
| 801 | |
| 802 TEST(RestApi, RestApiPath) | |
| 803 { | |
| 804 RestApiPath::Components args; | |
| 805 UriComponents trail; | |
| 806 | |
| 807 { | |
| 808 RestApiPath uri("/coucou/{abc}/d/*"); | |
| 809 ASSERT_TRUE(uri.Match(args, trail, "/coucou/moi/d/e/f/g")); | |
| 810 ASSERT_EQ(1u, args.size()); | |
| 811 ASSERT_EQ(3u, trail.size()); | |
| 812 ASSERT_EQ("moi", args["abc"]); | |
| 813 ASSERT_EQ("e", trail[0]); | |
| 814 ASSERT_EQ("f", trail[1]); | |
| 815 ASSERT_EQ("g", trail[2]); | |
| 816 | |
| 817 ASSERT_FALSE(uri.Match(args, trail, "/coucou/moi/f")); | |
| 818 ASSERT_TRUE(uri.Match(args, trail, "/coucou/moi/d/")); | |
| 819 ASSERT_FALSE(uri.Match(args, trail, "/a/moi/d")); | |
| 820 ASSERT_FALSE(uri.Match(args, trail, "/coucou/moi")); | |
| 821 } | |
| 822 | |
| 823 { | |
| 824 RestApiPath uri("/coucou/{abc}/d"); | |
| 825 ASSERT_FALSE(uri.Match(args, trail, "/coucou/moi/d/e/f/g")); | |
| 826 ASSERT_TRUE(uri.Match(args, trail, "/coucou/moi/d")); | |
| 827 ASSERT_EQ(1u, args.size()); | |
| 828 ASSERT_EQ(0u, trail.size()); | |
| 829 ASSERT_EQ("moi", args["abc"]); | |
| 830 } | |
| 831 | |
| 832 { | |
| 833 RestApiPath uri("/*"); | |
| 834 ASSERT_TRUE(uri.Match(args, trail, "/a/b/c")); | |
| 835 ASSERT_EQ(0u, args.size()); | |
| 836 ASSERT_EQ(3u, trail.size()); | |
| 837 ASSERT_EQ("a", trail[0]); | |
| 838 ASSERT_EQ("b", trail[1]); | |
| 839 ASSERT_EQ("c", trail[2]); | |
| 840 } | |
| 841 } | |
| 842 | |
| 843 | |
| 844 | |
| 845 | |
| 846 #include "../Core/HttpServer/MongooseServer.h" | |
| 847 | |
| 848 struct Tutu : public IDynamicObject | |
| 849 { | |
| 850 static void Toto(RestApiGetCall& call) | |
| 851 { | |
| 852 printf("DONE\n"); | |
| 853 Json::Value a = Json::objectValue; | |
| 854 a["Tutu"] = "Toto"; | |
| 855 a["Youpie"] = call.GetArgument("coucou", "nope"); | |
| 856 a["Toto"] = call.GetUriComponent("test", "nope"); | |
| 857 call.GetOutput().AnswerJson(a); | |
| 858 } | |
| 859 }; | |
| 860 | |
| 861 | |
| 862 | |
| 863 TEST(RestApi, Tutu) | |
| 864 { | |
| 865 MongooseServer httpServer; | |
| 866 httpServer.SetPortNumber(8042); | |
| 867 httpServer.Start(); | |
| 868 | |
| 869 RestApi* api = new RestApi; | |
| 870 httpServer.RegisterHandler(api); | |
| 871 api->Register("/coucou/{test}/a/*", Tutu::Toto); | |
| 872 | |
| 873 httpServer.Start(); | |
| 874 /*LOG(WARNING) << "REST has started"; | |
| 875 Toolbox::ServerBarrier();*/ | |
| 876 } |