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 } |