Mercurial > hg > orthanc

comparison UnitTests/ServerIndex.cpp @ 209:9960642f0f45

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
abstraction of RestApi
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 28 Nov 2012 17:22:07 +0100
parents de640de989b8
children 0200cd330582
comparison
equal deleted inserted replaced
208:de640de989b8 209:9960642f0f45
255 255
256 listener.Reset(); 256 listener.Reset();
257 index.DeleteResource(a[6]); 257 index.DeleteResource(a[6]);
258 ASSERT_EQ("", listener.ancestorId_); // No more ancestor 258 ASSERT_EQ("", listener.ancestorId_); // No more ancestor
259 } 259 }
260
261
262
263
264 #include "../Core/HttpServer/FilesystemHttpSender.h"
265
266 #include "../Core/Toolbox.h"
267 #include "../Core/HttpServer/HttpOutput.h"
268 #include "../Core/HttpServer/HttpHandler.h"
269
270 #include "../Core/HttpServer/HttpFileSender.h"
271
272
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 }