# HG changeset patch # User Sebastien Jodogne # Date 1354116191 -3600 # Node ID 7f74209ea0f87dd21cc329b6b724b41540566a4b # Parent 4453a010d0db25f3d3ddb0c6112264b52e522517 RestApi diff -r 4453a010d0db -r 7f74209ea0f8 Core/HttpServer/HttpHandler.cpp --- a/Core/HttpServer/HttpHandler.cpp Wed Nov 28 12:03:18 2012 +0100 +++ b/Core/HttpServer/HttpHandler.cpp Wed Nov 28 16:23:11 2012 +0100 @@ -76,12 +76,12 @@ - std::string HttpHandler::GetArgument(const Arguments& arguments, + std::string HttpHandler::GetArgument(const Arguments& getArguments, const std::string& name, const std::string& defaultValue) { - Arguments::const_iterator it = arguments.find(name); - if (it == arguments.end()) + Arguments::const_iterator it = getArguments.find(name); + if (it == getArguments.end()) { return defaultValue; } diff -r 4453a010d0db -r 7f74209ea0f8 Core/HttpServer/HttpHandler.h --- a/Core/HttpServer/HttpHandler.h Wed Nov 28 12:03:18 2012 +0100 +++ b/Core/HttpServer/HttpHandler.h Wed Nov 28 16:23:11 2012 +0100 @@ -55,13 +55,13 @@ const std::string& method, const UriComponents& uri, const Arguments& headers, - const Arguments& arguments, + const Arguments& getArguments, const std::string& postData) = 0; static void ParseGetQuery(HttpHandler::Arguments& result, const char* query); - static std::string GetArgument(const Arguments& arguments, + static std::string GetArgument(const Arguments& getArguments, const std::string& name, const std::string& defaultValue); }; diff -r 4453a010d0db -r 7f74209ea0f8 Core/HttpServer/HttpOutput.cpp --- a/Core/HttpServer/HttpOutput.cpp Wed Nov 28 12:03:18 2012 +0100 +++ b/Core/HttpServer/HttpOutput.cpp Wed Nov 28 16:23:11 2012 +0100 @@ -80,6 +80,13 @@ } + void HttpOutput::SendCustomOkHeader(const std::string& customHeader) + { + std::string s = "HTTP/1.1 200 OK\r\n" + customHeader + "\r\n"; + Send(&s[0], s.size()); + } + + void HttpOutput::SendMethodNotAllowedError(const std::string& allowed) { std::string s = diff -r 4453a010d0db -r 7f74209ea0f8 Core/HttpServer/HttpOutput.h --- a/Core/HttpServer/HttpOutput.h Wed Nov 28 12:03:18 2012 +0100 +++ b/Core/HttpServer/HttpOutput.h Wed Nov 28 16:23:11 2012 +0100 @@ -44,11 +44,6 @@ private: void SendHeaderInternal(Orthanc_HttpStatus status); - void SendOkHeader(const char* contentType, - bool hasContentLength, - uint64_t contentLength, - const char* contentFilename); - public: virtual ~HttpOutput() { @@ -58,6 +53,13 @@ void SendOkHeader(const std::string& contentType); + void SendOkHeader(const char* contentType, + bool hasContentLength, + uint64_t contentLength, + const char* contentFilename); + + void SendCustomOkHeader(const std::string& customHeader); + void SendString(const std::string& s); void SendMethodNotAllowedError(const std::string& allowed); diff -r 4453a010d0db -r 7f74209ea0f8 Core/HttpServer/MongooseServer.cpp --- a/Core/HttpServer/MongooseServer.cpp Wed Nov 28 12:03:18 2012 +0100 +++ b/Core/HttpServer/MongooseServer.cpp Wed Nov 28 16:23:11 2012 +0100 @@ -489,7 +489,8 @@ { HttpHandler::ParseGetQuery(arguments, request->query_string); } - else if (!strcmp(request->request_method, "POST")) + else if (!strcmp(request->request_method, "POST") || + !strcmp(request->request_method, "PUT")) { HttpHandler::Arguments::const_iterator ct = headers.find("content-type"); if (ct == headers.end()) diff -r 4453a010d0db -r 7f74209ea0f8 Core/Toolbox.cpp --- a/Core/Toolbox.cpp Wed Nov 28 12:03:18 2012 +0100 +++ b/Core/Toolbox.cpp Wed Nov 28 16:23:11 2012 +0100 @@ -288,6 +288,15 @@ { components.push_back(std::string(&uri[start], end - start)); } + + for (size_t i = 0; i < components.size(); i++) + { + if (components[i].size() == 0) + { + // Empty component, as in: "/coucou//e" + throw OrthancException(ErrorCode_UriSyntax); + } + } } diff -r 4453a010d0db -r 7f74209ea0f8 NEWS --- a/NEWS Wed Nov 28 12:03:18 2012 +0100 +++ b/NEWS Wed Nov 28 16:23:11 2012 +0100 @@ -11,8 +11,7 @@ ------------- * "CompletedSeries" event in the changes API -* Flush to disk thread - +* Thread to continuously flush DB to disk (robustness against reboots) Version 0.2.3 (2012/10/26) diff -r 4453a010d0db -r 7f74209ea0f8 OrthancServer/OrthancRestApi.cpp --- a/OrthancServer/OrthancRestApi.cpp Wed Nov 28 12:03:18 2012 +0100 +++ b/OrthancServer/OrthancRestApi.cpp Wed Nov 28 16:23:11 2012 +0100 @@ -397,7 +397,7 @@ const std::string& method, const UriComponents& uri, const Arguments& headers, - const Arguments& arguments, + const Arguments& getArguments, const std::string& postData) { if (uri.size() == 0) @@ -718,13 +718,13 @@ { const static unsigned int MAX_RESULTS = 100; - //std::string filter = GetArgument(arguments, "filter", ""); + //std::string filter = GetArgument(getArguments, "filter", ""); int64_t since; unsigned int limit; try { - since = boost::lexical_cast(GetArgument(arguments, "since", "0")); - limit = boost::lexical_cast(GetArgument(arguments, "limit", "0")); + since = boost::lexical_cast(GetArgument(getArguments, "since", "0")); + limit = boost::lexical_cast(GetArgument(getArguments, "limit", "0")); } catch (boost::bad_lexical_cast) { diff -r 4453a010d0db -r 7f74209ea0f8 OrthancServer/OrthancRestApi.h --- a/OrthancServer/OrthancRestApi.h Wed Nov 28 12:03:18 2012 +0100 +++ b/OrthancServer/OrthancRestApi.h Wed Nov 28 16:23:11 2012 +0100 @@ -93,7 +93,7 @@ const std::string& method, const UriComponents& uri, const Arguments& headers, - const Arguments& arguments, + const Arguments& getArguments, const std::string& postData); }; } diff -r 4453a010d0db -r 7f74209ea0f8 UnitTests/ServerIndex.cpp --- a/UnitTests/ServerIndex.cpp Wed Nov 28 12:03:18 2012 +0100 +++ b/UnitTests/ServerIndex.cpp Wed Nov 28 16:23:11 2012 +0100 @@ -258,3 +258,750 @@ index.DeleteResource(a[6]); ASSERT_EQ("", listener.ancestorId_); // No more ancestor } + + + +#include "../Core/Toolbox.h" +#include "../Core/HttpServer/HttpOutput.h" +#include "../Core/HttpServer/HttpHandler.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 HttpFileSender + { + private: + std::string contentType_; + std::string filename_; + + void SendHeader(HttpOutput& output) + { + std::string header; + header += "Content-Length: " + boost::lexical_cast(GetFileSize()) + "\r\n"; + + if (contentType_.size() > 0) + { + header += "Content-Type: " + contentType_ + "\r\n"; + } + + if (filename_.size() > 0) + { + header += "Content-Disposition: attachment; filename=\"" + filename_ + "\"\r\n"; + } + + output.SendCustomOkHeader(header); + } + + protected: + virtual uint64_t GetFileSize() = 0; + + virtual bool SendData(HttpOutput& output) = 0; + + public: + virtual ~HttpFileSender() + { + } + + void ResetContentType() + { + contentType_.clear(); + } + + void SetContentType(const std::string& contentType) + { + contentType_ = contentType; + } + + const std::string& GetContentType() const + { + return contentType_; + } + + void ResetFilename() + { + contentType_.clear(); + } + + void SetFilename(const std::string& filename) + { + filename_ = filename; + } + + const std::string& GetFilename() const + { + return filename_; + } + + void Send(HttpOutput& output) + { + SendHeader(output); + + if (!SendData(output)) + { + output.SendHeader(Orthanc_HttpStatus_500_InternalServerError); + } + } + }; + + + class FilesystemHttpSender : public HttpFileSender + { + private: + std::string path_; + + protected: + virtual uint64_t GetFileSize() + { + return Toolbox::GetFileSize(path_); + } + + virtual bool SendData(HttpOutput& output) + { + FILE* fp = fopen(path_.c_str(), "rb"); + if (!fp) + { + return false; + } + + std::vector buffer(1024 * 1024); // Chunks of 1MB + + for (;;) + { + size_t nbytes = fread(&buffer[0], 1, buffer.size(), fp); + if (nbytes == 0) + { + break; + } + else + { + output.Send(&buffer[0], nbytes); + } + } + + fclose(fp); + + return true; + } + + public: + FilesystemHttpSender(const char* path) : path_(path) + { + boost::filesystem::path p(path); + SetFilename(p.filename().string()); + SetContentType(Toolbox::AutodetectMimeType(p.filename().string())); + } + }; + + + 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();*/ +} + + +/** + + output.AnswerBufferWithContentType(s, "application/json"); + output.AnswerFile(storage_, fileUuid, contentType, filename.c_str()); + output.Redirect("app/explorer.html"); + output.SendHeader(Orthanc_HttpStatus_415_UnsupportedMediaType); + output.SendMethodNotAllowedError("GET"); + +**/ diff -r 4453a010d0db -r 7f74209ea0f8 UnitTests/main.cpp --- a/UnitTests/main.cpp Wed Nov 28 12:03:18 2012 +0100 +++ b/UnitTests/main.cpp Wed Nov 28 16:23:11 2012 +0100 @@ -188,6 +188,7 @@ ASSERT_THROW(Toolbox::SplitUriComponents(c, ""), OrthancException); ASSERT_THROW(Toolbox::SplitUriComponents(c, "a"), OrthancException); + ASSERT_THROW(Toolbox::SplitUriComponents(c, "/coucou//coucou"), OrthancException); }