# HG changeset patch # User Sebastien Jodogne # Date 1354119727 -3600 # Node ID 9960642f0f45e192aee3eaec0bfff90690d3e03e # Parent de640de989b85fb27dce7604c0e04d12d48b7a38 abstraction of RestApi diff -r de640de989b8 -r 9960642f0f45 CMakeLists.txt --- a/CMakeLists.txt Wed Nov 28 17:00:46 2012 +0100 +++ b/CMakeLists.txt Wed Nov 28 17:22:07 2012 +0100 @@ -111,6 +111,9 @@ Core/HttpServer/MongooseServer.cpp Core/HttpServer/HttpFileSender.cpp Core/HttpServer/FilesystemHttpSender.cpp + Core/RestApi/RestApiPath.cpp + Core/RestApi/RestApiOutput.cpp + Core/RestApi/RestApi.cpp Core/MultiThreading/BagOfRunnablesBySteps.cpp Core/PngWriter.cpp Core/SQLite/Connection.cpp @@ -163,13 +166,14 @@ include(${CMAKE_SOURCE_DIR}/Resources/CMake/GoogleTestConfiguration.cmake) add_executable(UnitTests ${GTEST_SOURCES} - UnitTests/main.cpp UnitTests/MessageWithDestination.cpp + UnitTests/RestApi.cpp UnitTests/SQLite.cpp UnitTests/SQLiteChromium.cpp + UnitTests/ServerIndex.cpp UnitTests/Versions.cpp UnitTests/Zip.cpp - UnitTests/ServerIndex.cpp + UnitTests/main.cpp ) target_link_libraries(UnitTests ServerLibrary CoreLibrary) endif() diff -r de640de989b8 -r 9960642f0f45 Core/RestApi/RestApi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Core/RestApi/RestApi.cpp Wed Nov 28 17:22:07 2012 +0100 @@ -0,0 +1,276 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012 Medical Physics Department, CHU of Liege, + * Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * In addition, as a special exception, the copyright holders of this + * program give permission to link the code of its release with the + * OpenSSL project's "OpenSSL" library (or with modified versions of it + * that use the same license as the "OpenSSL" library), and distribute + * the linked executables. You must obey the GNU General Public License + * in all respects for all of the code used other than "OpenSSL". If you + * modify file(s) with this exception, you may extend this exception to + * your version of the file(s), but you are not obligated to do so. If + * you do not wish to do so, delete this exception statement from your + * version. If you delete this exception statement from all source files + * in the program, then also delete it here. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#include "RestApi.h" + +namespace Orthanc +{ + bool RestApi::IsGetAccepted(const UriComponents& uri) + { + for (GetHandlers::const_iterator it = getHandlers_.begin(); + it != getHandlers_.end(); it++) + { + if (it->first->Match(uri)) + { + return true; + } + } + + return false; + } + + bool RestApi::IsPutAccepted(const UriComponents& uri) + { + for (PutHandlers::const_iterator it = putHandlers_.begin(); + it != putHandlers_.end(); it++) + { + if (it->first->Match(uri)) + { + return true; + } + } + + return false; + } + + bool RestApi::IsPostAccepted(const UriComponents& uri) + { + for (PostHandlers::const_iterator it = postHandlers_.begin(); + it != postHandlers_.end(); it++) + { + if (it->first->Match(uri)) + { + return true; + } + } + + return false; + } + + bool RestApi::IsDeleteAccepted(const UriComponents& uri) + { + for (DeleteHandlers::const_iterator it = deleteHandlers_.begin(); + it != deleteHandlers_.end(); it++) + { + if (it->first->Match(uri)) + { + return true; + } + } + + return false; + } + + static void AddMethod(std::string& target, + const std::string& method) + { + if (target.size() > 0) + target += "," + method; + else + target = method; + } + + std::string RestApi::GetAcceptedMethods(const UriComponents& uri) + { + std::string s; + + if (IsGetAccepted(uri)) + AddMethod(s, "GET"); + + if (IsPutAccepted(uri)) + AddMethod(s, "PUT"); + + if (IsPostAccepted(uri)) + AddMethod(s, "POST"); + + if (IsDeleteAccepted(uri)) + AddMethod(s, "DELETE"); + + return s; + } + + RestApi::~RestApi() + { + for (GetHandlers::iterator it = getHandlers_.begin(); + it != getHandlers_.end(); it++) + { + delete it->first; + } + + for (PutHandlers::iterator it = putHandlers_.begin(); + it != putHandlers_.end(); it++) + { + delete it->first; + } + + for (PostHandlers::iterator it = postHandlers_.begin(); + it != postHandlers_.end(); it++) + { + delete it->first; + } + + for (DeleteHandlers::iterator it = deleteHandlers_.begin(); + it != deleteHandlers_.end(); it++) + { + delete it->first; + } + } + + bool RestApi::IsServedUri(const UriComponents& uri) + { + return (IsGetAccepted(uri) || + IsPutAccepted(uri) || + IsPostAccepted(uri) || + IsDeleteAccepted(uri)); + } + + void RestApi::Handle(HttpOutput& output, + const std::string& method, + const UriComponents& uri, + const Arguments& headers, + const Arguments& getArguments, + const std::string& postData) + { + bool ok = false; + RestApiOutput restOutput(output); + RestApiPath::Components components; + UriComponents trailing; + + if (method == "GET") + { + for (GetHandlers::const_iterator it = getHandlers_.begin(); + it != getHandlers_.end(); it++) + { + if (it->first->Match(components, trailing, uri)) + { + ok = true; + GetCall call; + call.output_ = &restOutput; + call.context_ = context_.get(); + call.httpHeaders_ = &headers; + call.uriComponents_ = &components; + call.trailing_ = &trailing; + + call.getArguments_ = &getArguments; + it->second(call); + } + } + } + else if (method == "PUT") + { + for (PutHandlers::const_iterator it = putHandlers_.begin(); + it != putHandlers_.end(); it++) + { + if (it->first->Match(components, trailing, uri)) + { + ok = true; + PutCall call; + call.output_ = &restOutput; + call.context_ = context_.get(); + call.httpHeaders_ = &headers; + call.uriComponents_ = &components; + call.trailing_ = &trailing; + + call.data_ = &postData; + it->second(call); + } + } + } + else if (method == "POST") + { + for (PostHandlers::const_iterator it = postHandlers_.begin(); + it != postHandlers_.end(); it++) + { + if (it->first->Match(components, trailing, uri)) + { + ok = true; + PostCall call; + call.output_ = &restOutput; + call.context_ = context_.get(); + call.httpHeaders_ = &headers; + call.uriComponents_ = &components; + call.trailing_ = &trailing; + + call.data_ = &postData; + it->second(call); + } + } + } + else if (method == "DELETE") + { + for (DeleteHandlers::const_iterator it = deleteHandlers_.begin(); + it != deleteHandlers_.end(); it++) + { + if (it->first->Match(components, trailing, uri)) + { + ok = true; + DeleteCall call; + call.output_ = &restOutput; + call.context_ = context_.get(); + call.httpHeaders_ = &headers; + call.uriComponents_ = &components; + call.trailing_ = &trailing; + it->second(call); + } + } + } + + if (!ok) + { + output.SendMethodNotAllowedError(GetAcceptedMethods(uri)); + } + } + + void RestApi::Register(const std::string& path, + GetHandler handler) + { + getHandlers_.push_back(std::make_pair(new RestApiPath(path), handler)); + } + + void RestApi::Register(const std::string& path, + PutHandler handler) + { + putHandlers_.push_back(std::make_pair(new RestApiPath(path), handler)); + } + + void RestApi::Register(const std::string& path, + PostHandler handler) + { + postHandlers_.push_back(std::make_pair(new RestApiPath(path), handler)); + } + + void RestApi::Register(const std::string& path, + DeleteHandler handler) + { + deleteHandlers_.push_back(std::make_pair(new RestApiPath(path), handler)); + } +} diff -r de640de989b8 -r 9960642f0f45 Core/RestApi/RestApi.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Core/RestApi/RestApi.h Wed Nov 28 17:22:07 2012 +0100 @@ -0,0 +1,200 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012 Medical Physics Department, CHU of Liege, + * Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * In addition, as a special exception, the copyright holders of this + * program give permission to link the code of its release with the + * OpenSSL project's "OpenSSL" library (or with modified versions of it + * that use the same license as the "OpenSSL" library), and distribute + * the linked executables. You must obey the GNU General Public License + * in all respects for all of the code used other than "OpenSSL". If you + * modify file(s) with this exception, you may extend this exception to + * your version of the file(s), but you are not obligated to do so. If + * you do not wish to do so, delete this exception statement from your + * version. If you delete this exception statement from all source files + * in the program, then also delete it here. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#pragma once + +#include "../IDynamicObject.h" +#include "../HttpServer/HttpHandler.h" +#include "RestApiPath.h" +#include "RestApiOutput.h" + +namespace Orthanc +{ + class RestApi : public HttpHandler + { + private: + class SharedCall + { + friend class RestApi; + + private: + RestApiOutput* output_; + IDynamicObject* context_; + const HttpHandler::Arguments* httpHeaders_; + const RestApiPath::Components* uriComponents_; + const UriComponents* trailing_; + + public: + RestApiOutput& GetOutput() + { + return *output_; + } + + IDynamicObject* GetContext() + { + return context_; + } + + const HttpHandler::Arguments& GetHttpHeaders() const + { + return *httpHeaders_; + } + + const RestApiPath::Components& GetUriComponents() const + { + return *uriComponents_; + } + + const UriComponents& GetTrailing() const + { + return *trailing_; + } + + std::string GetUriComponent(const std::string& name, + const std::string& defaultValue) + { + return HttpHandler::GetArgument(*uriComponents_, name, defaultValue); + } + }; + + + public: + class GetCall : public SharedCall + { + friend class RestApi; + + private: + const HttpHandler::Arguments* getArguments_; + + public: + std::string GetArgument(const std::string& name, + const std::string& defaultValue) + { + return HttpHandler::GetArgument(*getArguments_, name, defaultValue); + } + }; + + class PutCall : public SharedCall + { + friend class RestApi; + + private: + const std::string* data_; + + public: + const std::string& GetData() + { + return *data_; + } + }; + + class PostCall : public SharedCall + { + friend class RestApi; + + private: + const std::string* data_; + + public: + const std::string& GetData() + { + return *data_; + } + }; + + class DeleteCall : public SharedCall + { + }; + + typedef void (*GetHandler) (GetCall& call); + + typedef void (*DeleteHandler) (DeleteCall& call); + + typedef void (*PutHandler) (PutCall& call); + + typedef void (*PostHandler) (PostCall& call); + + private: + typedef std::list< std::pair > GetHandlers; + typedef std::list< std::pair > PutHandlers; + typedef std::list< std::pair > PostHandlers; + typedef std::list< std::pair > DeleteHandlers; + + // CAUTION: PLEASE INTRODUCE MUTEX BETWEEN CONTEXTS !!! + std::auto_ptr context_; + + GetHandlers getHandlers_; + PutHandlers putHandlers_; + PostHandlers postHandlers_; + DeleteHandlers deleteHandlers_; + + bool IsGetAccepted(const UriComponents& uri); + bool IsPutAccepted(const UriComponents& uri); + bool IsPostAccepted(const UriComponents& uri); + bool IsDeleteAccepted(const UriComponents& uri); + + std::string GetAcceptedMethods(const UriComponents& uri); + + public: + RestApi() + { + } + + void SetContext(IDynamicObject* context) // This takes the ownership + { + context_.reset(context); + } + + ~RestApi(); + + virtual bool IsServedUri(const UriComponents& uri); + + virtual void Handle(HttpOutput& output, + const std::string& method, + const UriComponents& uri, + const Arguments& headers, + const Arguments& getArguments, + const std::string& postData); + + void Register(const std::string& path, + GetHandler handler); + + void Register(const std::string& path, + PutHandler handler); + + void Register(const std::string& path, + PostHandler handler); + + void Register(const std::string& path, + DeleteHandler handler); + }; +} diff -r de640de989b8 -r 9960642f0f45 Core/RestApi/RestApiOutput.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Core/RestApi/RestApiOutput.cpp Wed Nov 28 17:22:07 2012 +0100 @@ -0,0 +1,59 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012 Medical Physics Department, CHU of Liege, + * Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * In addition, as a special exception, the copyright holders of this + * program give permission to link the code of its release with the + * OpenSSL project's "OpenSSL" library (or with modified versions of it + * that use the same license as the "OpenSSL" library), and distribute + * the linked executables. You must obey the GNU General Public License + * in all respects for all of the code used other than "OpenSSL". If you + * modify file(s) with this exception, you may extend this exception to + * your version of the file(s), but you are not obligated to do so. If + * you do not wish to do so, delete this exception statement from your + * version. If you delete this exception statement from all source files + * in the program, then also delete it here. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#include "RestApiOutput.h" + +namespace Orthanc +{ + void RestApiOutput::AnswerFile(HttpFileSender& sender) + { + sender.Send(output_); + } + + void RestApiOutput::AnswerJson(const Json::Value& value) + { + Json::StyledWriter writer; + std::string s = writer.write(value); + output_.AnswerBufferWithContentType(s, "application/json"); + } + + void RestApiOutput::AnswerBuffer(const std::string& buffer, + const std::string& contentType) + { + output_.AnswerBufferWithContentType(buffer, contentType); + } + + void RestApiOutput::Redirect(const char* path) + { + output_.Redirect(path); + } +} diff -r de640de989b8 -r 9960642f0f45 Core/RestApi/RestApiOutput.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Core/RestApi/RestApiOutput.h Wed Nov 28 17:22:07 2012 +0100 @@ -0,0 +1,61 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012 Medical Physics Department, CHU of Liege, + * Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * In addition, as a special exception, the copyright holders of this + * program give permission to link the code of its release with the + * OpenSSL project's "OpenSSL" library (or with modified versions of it + * that use the same license as the "OpenSSL" library), and distribute + * the linked executables. You must obey the GNU General Public License + * in all respects for all of the code used other than "OpenSSL". If you + * modify file(s) with this exception, you may extend this exception to + * your version of the file(s), but you are not obligated to do so. If + * you do not wish to do so, delete this exception statement from your + * version. If you delete this exception statement from all source files + * in the program, then also delete it here. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#pragma once + +#include "../HttpServer/HttpOutput.h" +#include "../HttpServer/HttpFileSender.h" + +#include + +namespace Orthanc +{ + class RestApiOutput + { + private: + HttpOutput& output_; + + public: + RestApiOutput(HttpOutput& output) : output_(output) + { + } + + void AnswerFile(HttpFileSender& sender); + + void AnswerJson(const Json::Value& value); + + void AnswerBuffer(const std::string& buffer, + const std::string& contentType); + + void Redirect(const char* path); + }; +} diff -r de640de989b8 -r 9960642f0f45 Core/RestApi/RestApiPath.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Core/RestApi/RestApiPath.cpp Wed Nov 28 17:22:07 2012 +0100 @@ -0,0 +1,136 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012 Medical Physics Department, CHU of Liege, + * Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * In addition, as a special exception, the copyright holders of this + * program give permission to link the code of its release with the + * OpenSSL project's "OpenSSL" library (or with modified versions of it + * that use the same license as the "OpenSSL" library), and distribute + * the linked executables. You must obey the GNU General Public License + * in all respects for all of the code used other than "OpenSSL". If you + * modify file(s) with this exception, you may extend this exception to + * your version of the file(s), but you are not obligated to do so. If + * you do not wish to do so, delete this exception statement from your + * version. If you delete this exception statement from all source files + * in the program, then also delete it here. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#include "RestApiPath.h" + +#include + +namespace Orthanc +{ + RestApiPath::RestApiPath(const std::string& uri) + { + Toolbox::SplitUriComponents(uri_, uri); + + if (uri_.size() == 0) + { + return; + } + + if (uri_.back() == "*") + { + hasTrailing_ = true; + uri_.pop_back(); + } + else + { + hasTrailing_ = false; + } + + components_.resize(uri_.size()); + for (size_t i = 0; i < uri_.size(); i++) + { + size_t s = uri_[i].size(); + assert(s > 0); + + if (uri_[i][0] == '{' && + uri_[i][s - 1] == '}') + { + components_[i] = uri_[i].substr(1, s - 2); + uri_[i] = ""; + } + else + { + components_[i] = ""; + } + } + } + + bool RestApiPath::Match(Components& components, + UriComponents& trailing, + const std::string& uriRaw) const + { + UriComponents uri; + Toolbox::SplitUriComponents(uri, uriRaw); + return Match(components, trailing, uri); + } + + bool RestApiPath::Match(Components& components, + UriComponents& trailing, + const UriComponents& uri) const + { + if (uri.size() < uri_.size()) + { + return false; + } + + if (!hasTrailing_ && uri.size() > uri_.size()) + { + return false; + } + + components.clear(); + trailing.clear(); + + assert(uri_.size() <= uri.size()); + for (size_t i = 0; i < uri_.size(); i++) + { + if (components_[i].size() == 0) + { + // This URI component is not a free parameter + if (uri_[i] != uri[i]) + { + return false; + } + } + else + { + // This URI component is a free parameter + components[components_[i]] = uri[i]; + } + } + + if (hasTrailing_) + { + trailing.assign(uri.begin() + uri_.size(), uri.end()); + } + + return true; + } + + + bool RestApiPath::Match(const UriComponents& uri) const + { + Components components; + UriComponents trailing; + return Match(components, trailing, uri); + } +} diff -r de640de989b8 -r 9960642f0f45 Core/RestApi/RestApiPath.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Core/RestApi/RestApiPath.h Wed Nov 28 17:22:07 2012 +0100 @@ -0,0 +1,63 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012 Medical Physics Department, CHU of Liege, + * Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * In addition, as a special exception, the copyright holders of this + * program give permission to link the code of its release with the + * OpenSSL project's "OpenSSL" library (or with modified versions of it + * that use the same license as the "OpenSSL" library), and distribute + * the linked executables. You must obey the GNU General Public License + * in all respects for all of the code used other than "OpenSSL". If you + * modify file(s) with this exception, you may extend this exception to + * your version of the file(s), but you are not obligated to do so. If + * you do not wish to do so, delete this exception statement from your + * version. If you delete this exception statement from all source files + * in the program, then also delete it here. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#pragma once + +#include "../Toolbox.h" +#include + +namespace Orthanc +{ + class RestApiPath + { + private: + UriComponents uri_; + bool hasTrailing_; + std::vector components_; + + public: + typedef std::map Components; + + RestApiPath(const std::string& uri); + + // This version is slower + bool Match(Components& components, + UriComponents& trailing, + const std::string& uriRaw) const; + + bool Match(Components& components, + UriComponents& trailing, + const UriComponents& uri) const; + + bool Match(const UriComponents& uri) const; + }; +} diff -r de640de989b8 -r 9960642f0f45 UnitTests/RestApi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/UnitTests/RestApi.cpp Wed Nov 28 17:22:07 2012 +0100 @@ -0,0 +1,84 @@ +#include "gtest/gtest.h" + +#include +#include + +#include "../Core/RestApi/RestApi.h" + +using namespace Orthanc; + +TEST(RestApi, RestApiPath) +{ + RestApiPath::Components args; + UriComponents trail; + + { + RestApiPath uri("/coucou/{abc}/d/*"); + ASSERT_TRUE(uri.Match(args, trail, "/coucou/moi/d/e/f/g")); + ASSERT_EQ(1u, args.size()); + ASSERT_EQ(3u, trail.size()); + ASSERT_EQ("moi", args["abc"]); + ASSERT_EQ("e", trail[0]); + ASSERT_EQ("f", trail[1]); + ASSERT_EQ("g", trail[2]); + + ASSERT_FALSE(uri.Match(args, trail, "/coucou/moi/f")); + ASSERT_TRUE(uri.Match(args, trail, "/coucou/moi/d/")); + ASSERT_FALSE(uri.Match(args, trail, "/a/moi/d")); + ASSERT_FALSE(uri.Match(args, trail, "/coucou/moi")); + } + + { + RestApiPath uri("/coucou/{abc}/d"); + ASSERT_FALSE(uri.Match(args, trail, "/coucou/moi/d/e/f/g")); + ASSERT_TRUE(uri.Match(args, trail, "/coucou/moi/d")); + ASSERT_EQ(1u, args.size()); + ASSERT_EQ(0u, trail.size()); + ASSERT_EQ("moi", args["abc"]); + } + + { + RestApiPath uri("/*"); + ASSERT_TRUE(uri.Match(args, trail, "/a/b/c")); + ASSERT_EQ(0u, args.size()); + ASSERT_EQ(3u, trail.size()); + ASSERT_EQ("a", trail[0]); + ASSERT_EQ("b", trail[1]); + ASSERT_EQ("c", trail[2]); + } +} + + + + +#include "../Core/HttpServer/MongooseServer.h" + +struct Tutu : public IDynamicObject +{ + static void Toto(RestApi::GetCall& call) + { + printf("DONE\n"); + Json::Value a = Json::objectValue; + a["Tutu"] = "Toto"; + a["Youpie"] = call.GetArgument("coucou", "nope"); + a["Toto"] = call.GetUriComponent("test", "nope"); + call.GetOutput().AnswerJson(a); + } +}; + + + +TEST(RestApi, Tutu) +{ + MongooseServer httpServer; + httpServer.SetPortNumber(8042); + httpServer.Start(); + + RestApi* api = new RestApi; + httpServer.RegisterHandler(api); + api->Register("/coucou/{test}/a/*", Tutu::Toto); + + httpServer.Start(); + /*LOG(WARNING) << "REST has started"; + Toolbox::ServerBarrier();*/ +} diff -r de640de989b8 -r 9960642f0f45 UnitTests/ServerIndex.cpp --- a/UnitTests/ServerIndex.cpp Wed Nov 28 17:00:46 2012 +0100 +++ b/UnitTests/ServerIndex.cpp Wed Nov 28 17:22:07 2012 +0100 @@ -257,620 +257,3 @@ index.DeleteResource(a[6]); ASSERT_EQ("", listener.ancestorId_); // No more ancestor } - - - - -#include "../Core/HttpServer/FilesystemHttpSender.h" - -#include "../Core/Toolbox.h" -#include "../Core/HttpServer/HttpOutput.h" -#include "../Core/HttpServer/HttpHandler.h" - -#include "../Core/HttpServer/HttpFileSender.h" - - -namespace Orthanc -{ - class RestApiPath - { - private: - UriComponents uri_; - bool hasTrailing_; - std::vector components_; - - public: - typedef std::map Components; - - RestApiPath(const std::string& uri) - { - Toolbox::SplitUriComponents(uri_, uri); - - if (uri_.size() == 0) - { - return; - } - - if (uri_.back() == "*") - { - hasTrailing_ = true; - uri_.pop_back(); - } - else - { - hasTrailing_ = false; - } - - components_.resize(uri_.size()); - for (size_t i = 0; i < uri_.size(); i++) - { - size_t s = uri_[i].size(); - assert(s > 0); - - if (uri_[i][0] == '{' && - uri_[i][s - 1] == '}') - { - components_[i] = uri_[i].substr(1, s - 2); - uri_[i] = ""; - } - else - { - components_[i] = ""; - } - } - } - - // This version is slower - bool Match(Components& components, - UriComponents& trailing, - const std::string& uriRaw) const - { - UriComponents uri; - Toolbox::SplitUriComponents(uri, uriRaw); - return Match(components, trailing, uri); - } - - bool Match(Components& components, - UriComponents& trailing, - const UriComponents& uri) const - { - if (uri.size() < uri_.size()) - { - return false; - } - - if (!hasTrailing_ && uri.size() > uri_.size()) - { - return false; - } - - components.clear(); - trailing.clear(); - - assert(uri_.size() <= uri.size()); - for (size_t i = 0; i < uri_.size(); i++) - { - if (components_[i].size() == 0) - { - // This URI component is not a free parameter - if (uri_[i] != uri[i]) - { - return false; - } - } - else - { - // This URI component is a free parameter - components[components_[i]] = uri[i]; - } - } - - if (hasTrailing_) - { - trailing.assign(uri.begin() + uri_.size(), uri.end()); - } - - return true; - } - - bool Match(const UriComponents& uri) const - { - Components components; - UriComponents trailing; - return Match(components, trailing, uri); - } - }; - - - class RestApiOutput - { - private: - HttpOutput& output_; - - public: - RestApiOutput(HttpOutput& output) : output_(output) - { - } - - void AnswerFile(HttpFileSender& sender) - { - sender.Send(output_); - } - - void AnswerJson(const Json::Value& value) - { - Json::StyledWriter writer; - std::string s = writer.write(value); - output_.AnswerBufferWithContentType(s, "application/json"); - } - - void AnswerBuffer(const std::string& buffer, - const std::string& contentType) - { - output_.AnswerBufferWithContentType(buffer, contentType); - } - - void Redirect(const char* path) - { - output_.Redirect(path); - } - }; - - - class RestApiSharedCall - { - protected: - RestApiOutput* output_; - IDynamicObject* context_; - const HttpHandler::Arguments* httpHeaders_; - const RestApiPath::Components* uriComponents_; - const UriComponents* trailing_; - - public: - RestApiOutput& GetOutput() - { - return *output_; - } - - IDynamicObject* GetContext() - { - return context_; - } - - const HttpHandler::Arguments& GetHttpHeaders() const - { - return *httpHeaders_; - } - - const RestApiPath::Components& GetUriComponents() const - { - return *uriComponents_; - } - - const UriComponents& GetTrailing() const - { - return *trailing_; - } - - std::string GetUriComponent(const std::string& name, - const std::string& defaultValue) - { - return HttpHandler::GetArgument(*uriComponents_, name, defaultValue); - } - }; - - - class RestApiPutCall : public RestApiSharedCall - { - friend class RestApi; - - private: - const std::string* data_; - - public: - const std::string& GetData() - { - return *data_; - } - }; - - - class RestApiPostCall : public RestApiSharedCall - { - friend class RestApi; - - private: - const std::string* data_; - - public: - const std::string& GetData() - { - return *data_; - } - }; - - - - class RestApiDeleteCall : public RestApiSharedCall - { - friend class RestApi; - }; - - - - - class RestApiGetCall : public RestApiSharedCall - { - friend class RestApi; - - private: - const HttpHandler::Arguments* getArguments_; - - public: - std::string GetArgument(const std::string& name, - const std::string& defaultValue) - { - return HttpHandler::GetArgument(*getArguments_, name, defaultValue); - } - }; - - - - class RestApi : public HttpHandler - { - public: - typedef void (*GetHandler) (RestApiGetCall& call); - - typedef void (*DeleteHandler) (RestApiDeleteCall& call); - - typedef void (*PutHandler) (RestApiPutCall& call); - - typedef void (*PostHandler) (RestApiPostCall& call); - - private: - typedef std::list< std::pair > GetHandlers; - typedef std::list< std::pair > PutHandlers; - typedef std::list< std::pair > PostHandlers; - typedef std::list< std::pair > DeleteHandlers; - - // TODO MUTEX BETWEEN CONTEXTS !!! - std::auto_ptr context_; - - GetHandlers getHandlers_; - PutHandlers putHandlers_; - PostHandlers postHandlers_; - DeleteHandlers deleteHandlers_; - - bool IsGetAccepted(const UriComponents& uri) - { - for (GetHandlers::const_iterator it = getHandlers_.begin(); - it != getHandlers_.end(); it++) - { - if (it->first->Match(uri)) - { - return true; - } - } - - return false; - } - - bool IsPutAccepted(const UriComponents& uri) - { - for (PutHandlers::const_iterator it = putHandlers_.begin(); - it != putHandlers_.end(); it++) - { - if (it->first->Match(uri)) - { - return true; - } - } - - return false; - } - - bool IsPostAccepted(const UriComponents& uri) - { - for (PostHandlers::const_iterator it = postHandlers_.begin(); - it != postHandlers_.end(); it++) - { - if (it->first->Match(uri)) - { - return true; - } - } - - return false; - } - - bool IsDeleteAccepted(const UriComponents& uri) - { - for (DeleteHandlers::const_iterator it = deleteHandlers_.begin(); - it != deleteHandlers_.end(); it++) - { - if (it->first->Match(uri)) - { - return true; - } - } - - return false; - } - - void AddMethod(std::string& target, - const std::string& method) const - { - if (target.size() > 0) - target += "," + method; - else - target = method; - } - - std::string GetAcceptedMethods(const UriComponents& uri) - { - std::string s; - - if (IsGetAccepted(uri)) - AddMethod(s, "GET"); - - if (IsPutAccepted(uri)) - AddMethod(s, "PUT"); - - if (IsPostAccepted(uri)) - AddMethod(s, "POST"); - - if (IsDeleteAccepted(uri)) - AddMethod(s, "DELETE"); - - return s; - } - - public: - RestApi() - { - } - - void SetContext(IDynamicObject* context) // This takes the ownership - { - context_.reset(context); - } - - ~RestApi() - { - for (GetHandlers::iterator it = getHandlers_.begin(); - it != getHandlers_.end(); it++) - { - delete it->first; - } - - for (PutHandlers::iterator it = putHandlers_.begin(); - it != putHandlers_.end(); it++) - { - delete it->first; - } - - for (PostHandlers::iterator it = postHandlers_.begin(); - it != postHandlers_.end(); it++) - { - delete it->first; - } - - for (DeleteHandlers::iterator it = deleteHandlers_.begin(); - it != deleteHandlers_.end(); it++) - { - delete it->first; - } - } - - virtual bool IsServedUri(const UriComponents& uri) - { - return (IsGetAccepted(uri) || - IsPutAccepted(uri) || - IsPostAccepted(uri) || - IsDeleteAccepted(uri)); - } - - virtual void Handle(HttpOutput& output, - const std::string& method, - const UriComponents& uri, - const Arguments& headers, - const Arguments& getArguments, - const std::string& postData) - { - bool ok = false; - RestApiOutput restOutput(output); - RestApiPath::Components components; - UriComponents trailing; - - if (method == "GET") - { - for (GetHandlers::const_iterator it = getHandlers_.begin(); - it != getHandlers_.end(); it++) - { - if (it->first->Match(components, trailing, uri)) - { - ok = true; - RestApiGetCall call; - call.output_ = &restOutput; - call.context_ = context_.get(); - call.httpHeaders_ = &headers; - call.uriComponents_ = &components; - call.trailing_ = &trailing; - - call.getArguments_ = &getArguments; - it->second(call); - } - } - } - else if (method == "PUT") - { - for (PutHandlers::const_iterator it = putHandlers_.begin(); - it != putHandlers_.end(); it++) - { - if (it->first->Match(components, trailing, uri)) - { - ok = true; - RestApiPutCall call; - call.output_ = &restOutput; - call.context_ = context_.get(); - call.httpHeaders_ = &headers; - call.uriComponents_ = &components; - call.trailing_ = &trailing; - - call.data_ = &postData; - it->second(call); - } - } - } - else if (method == "POST") - { - for (PostHandlers::const_iterator it = postHandlers_.begin(); - it != postHandlers_.end(); it++) - { - if (it->first->Match(components, trailing, uri)) - { - ok = true; - RestApiPostCall call; - call.output_ = &restOutput; - call.context_ = context_.get(); - call.httpHeaders_ = &headers; - call.uriComponents_ = &components; - call.trailing_ = &trailing; - - call.data_ = &postData; - it->second(call); - } - } - } - else if (method == "DELETE") - { - for (DeleteHandlers::const_iterator it = deleteHandlers_.begin(); - it != deleteHandlers_.end(); it++) - { - if (it->first->Match(components, trailing, uri)) - { - ok = true; - RestApiDeleteCall call; - call.output_ = &restOutput; - call.context_ = context_.get(); - call.httpHeaders_ = &headers; - call.uriComponents_ = &components; - call.trailing_ = &trailing; - it->second(call); - } - } - } - - if (!ok) - { - output.SendMethodNotAllowedError(GetAcceptedMethods(uri)); - } - } - - void Register(const std::string& path, - GetHandler handler) - { - getHandlers_.push_back(std::make_pair(new RestApiPath(path), handler)); - } - - - void Register(const std::string& path, - PutHandler handler) - { - putHandlers_.push_back(std::make_pair(new RestApiPath(path), handler)); - } - - - void Register(const std::string& path, - PostHandler handler) - { - postHandlers_.push_back(std::make_pair(new RestApiPath(path), handler)); - } - - - void Register(const std::string& path, - DeleteHandler handler) - { - deleteHandlers_.push_back(std::make_pair(new RestApiPath(path), handler)); - } - - }; - -} - - -TEST(RestApi, RestApiPath) -{ - RestApiPath::Components args; - UriComponents trail; - - { - RestApiPath uri("/coucou/{abc}/d/*"); - ASSERT_TRUE(uri.Match(args, trail, "/coucou/moi/d/e/f/g")); - ASSERT_EQ(1u, args.size()); - ASSERT_EQ(3u, trail.size()); - ASSERT_EQ("moi", args["abc"]); - ASSERT_EQ("e", trail[0]); - ASSERT_EQ("f", trail[1]); - ASSERT_EQ("g", trail[2]); - - ASSERT_FALSE(uri.Match(args, trail, "/coucou/moi/f")); - ASSERT_TRUE(uri.Match(args, trail, "/coucou/moi/d/")); - ASSERT_FALSE(uri.Match(args, trail, "/a/moi/d")); - ASSERT_FALSE(uri.Match(args, trail, "/coucou/moi")); - } - - { - RestApiPath uri("/coucou/{abc}/d"); - ASSERT_FALSE(uri.Match(args, trail, "/coucou/moi/d/e/f/g")); - ASSERT_TRUE(uri.Match(args, trail, "/coucou/moi/d")); - ASSERT_EQ(1u, args.size()); - ASSERT_EQ(0u, trail.size()); - ASSERT_EQ("moi", args["abc"]); - } - - { - RestApiPath uri("/*"); - ASSERT_TRUE(uri.Match(args, trail, "/a/b/c")); - ASSERT_EQ(0u, args.size()); - ASSERT_EQ(3u, trail.size()); - ASSERT_EQ("a", trail[0]); - ASSERT_EQ("b", trail[1]); - ASSERT_EQ("c", trail[2]); - } -} - - - - -#include "../Core/HttpServer/MongooseServer.h" - -struct Tutu : public IDynamicObject -{ - static void Toto(RestApiGetCall& call) - { - printf("DONE\n"); - Json::Value a = Json::objectValue; - a["Tutu"] = "Toto"; - a["Youpie"] = call.GetArgument("coucou", "nope"); - a["Toto"] = call.GetUriComponent("test", "nope"); - call.GetOutput().AnswerJson(a); - } -}; - - - -TEST(RestApi, Tutu) -{ - MongooseServer httpServer; - httpServer.SetPortNumber(8042); - httpServer.Start(); - - RestApi* api = new RestApi; - httpServer.RegisterHandler(api); - api->Register("/coucou/{test}/a/*", Tutu::Toto); - - httpServer.Start(); - /*LOG(WARNING) << "REST has started"; - Toolbox::ServerBarrier();*/ -}