Reorganize folder structure.

example/rest_book_server/CMakeLists.txt

@@ -0,0 +1,6 @@
+set(SRCS book_services.cc book_services.h main.cc)
+
+add_executable(rest_book_server ${SRCS})
+
+target_link_libraries(rest_book_server webcc jsoncpp ${Boost_LIBRARIES})
+target_link_libraries(rest_book_server "${CMAKE_THREAD_LIBS_INIT}")

example/rest_book_server/book_services.cc

@@ -0,0 +1,222 @@
+#include "example/rest_book_server/book_services.h"
+
+#include <iostream>
+#include <list>
+
+#include "boost/thread/thread.hpp"
+#include "json/json.h"
+#include "webcc/logger.h"
+
+// -----------------------------------------------------------------------------
+
+// In-memory test data.
+// There should be some database in a real product.
+
+class Book {
+public:
+  std::string id;
+  std::string title;
+  double price;
+
+  bool IsNull() const {
+    return id.empty();
+  }
+
+  Json::Value ToJson() const {
+    Json::Value root;
+    root["id"] = id;
+    root["title"] = title;
+    root["price"] = price;
+    return root;
+  }
+};
+
+std::ostream& operator<<(std::ostream& os, const Book& book) {
+  os << "{ " << book.id << ", " << book.title << ", " << book.price << " }";
+  return os;
+}
+
+static const Book kNullBook{};
+
+class BookStore {
+public:
+  BookStore() = default;
+
+  const std::list<Book>& books() const {
+    return books_;
+  }
+
+  const Book& GetBook(const std::string& id) const {
+    auto it = FindBook(id);
+    return (it == books_.end() ? kNullBook : *it);
+  }
+
+  bool AddBook(const Book& new_book) {
+    if (FindBook(new_book.id) == books_.end()) {
+      books_.push_back(new_book);
+      return true;
+    }
+    return false;
+  }
+
+  bool UpdateBook(const Book& book) {
+    auto it = FindBook(book.id);
+    if (it != books_.end()) {
+      it->title = book.title;
+      it->price = book.price;
+      return true;
+    }
+    return false;
+  }
+
+  bool DeleteBook(const std::string& id) {
+    auto it = FindBook(id);
+
+    if (it != books_.end()) {
+      books_.erase(it);
+      return true;
+    }
+
+    return false;
+  }
+
+private:
+  std::list<Book>::const_iterator FindBook(const std::string& id) const {
+    return std::find_if(books_.begin(),
+                        books_.end(),
+                        [&id](const Book& book) { return book.id == id; });
+  }
+
+  std::list<Book>::iterator FindBook(const std::string& id) {
+    return std::find_if(books_.begin(),
+                        books_.end(),
+                        [&id](Book& book) { return book.id == id; });
+  }
+
+private:
+  std::list<Book> books_;
+};
+
+static BookStore g_book_store;
+
+// -----------------------------------------------------------------------------
+
+static bool BookFromJson(const std::string& json, Book* book) {
+  Json::Value root;
+  Json::CharReaderBuilder builder;
+  std::stringstream stream(json);
+  std::string errs;
+  if (!Json::parseFromStream(builder, stream, &root, &errs)) {
+    std::cerr << errs << std::endl;
+    return false;
+  }
+
+  book->id = root["id"].asString();
+  book->title = root["title"].asString();
+  book->price = root["price"].asDouble();
+
+  return true;
+}
+
+// Return all books as a JSON array.
+// TODO: Support query parameters.
+bool BookListService::Get(const webcc::UrlQuery& /* query */,
+                          std::string* response_content) {
+  if (sleep_seconds_ > 0) {
+    LOG_INFO("Sleep %d seconds...", sleep_seconds_);
+    boost::this_thread::sleep_for(boost::chrono::seconds(sleep_seconds_));
+  }
+
+  Json::Value root(Json::arrayValue);
+  for (const Book& book : g_book_store.books()) {
+    root.append(book.ToJson());
+  }
+
+  Json::StreamWriterBuilder builder;
+  *response_content = Json::writeString(builder, root);
+
+  return true;
+}
+
+// Add a new book.
+// No response content.
+bool BookListService::Post(const std::string& request_content,
+                           std::string* /* response_content */) {
+  if (sleep_seconds_ > 0) {
+    LOG_INFO("Sleep %d seconds...", sleep_seconds_);
+    boost::this_thread::sleep_for(boost::chrono::seconds(sleep_seconds_));
+  }
+
+  Book book;
+  if (BookFromJson(request_content, &book)) {
+    return g_book_store.AddBook(book);
+  }
+
+  return false;
+}
+
+// -----------------------------------------------------------------------------
+
+bool BookDetailService::Get(const std::vector<std::string>& url_sub_matches,
+                            const webcc::UrlQuery& query,
+                            std::string* response_content) {
+  if (sleep_seconds_ > 0) {
+    LOG_INFO("Sleep %d seconds...", sleep_seconds_);
+    boost::this_thread::sleep_for(boost::chrono::seconds(sleep_seconds_));
+  }
+
+  if (url_sub_matches.size() != 1) {
+    return false;
+  }
+
+  const std::string& book_id = url_sub_matches[0];
+
+  const Book& book = g_book_store.GetBook(book_id);
+  if (!book.IsNull()) {
+    Json::StreamWriterBuilder builder;
+    *response_content = Json::writeString(builder, book.ToJson());
+    return true;
+  }
+
+  return false;
+}
+
+// Update a book.
+bool BookDetailService::Put(const std::vector<std::string>& url_sub_matches,
+                            const std::string& request_content,
+                            std::string* response_content) {
+  if (sleep_seconds_ > 0) {
+    LOG_INFO("Sleep %d seconds...", sleep_seconds_);
+    boost::this_thread::sleep_for(boost::chrono::seconds(sleep_seconds_));
+  }
+
+  if (url_sub_matches.size() != 1) {
+    return false;
+  }
+
+  const std::string& book_id = url_sub_matches[0];
+
+  Book book;
+  if (BookFromJson(request_content, &book)) {
+    book.id = book_id;
+    return g_book_store.UpdateBook(book);
+  }
+
+  return false;
+}
+
+bool BookDetailService::Delete(
+    const std::vector<std::string>& url_sub_matches) {
+  if (sleep_seconds_ > 0) {
+    LOG_INFO("Sleep %d seconds...", sleep_seconds_);
+    boost::this_thread::sleep_for(boost::chrono::seconds(sleep_seconds_));
+  }
+
+  if (url_sub_matches.size() != 1) {
+    return false;
+  }
+
+  const std::string& book_id = url_sub_matches[0];
+
+  return g_book_store.DeleteBook(book_id);
+}

example/rest_book_server/book_services.h

@@ -0,0 +1,61 @@
+#ifndef BOOK_SERVICES_H_
+#define BOOK_SERVICES_H_
+
+#include "webcc/rest_service.h"
+
+// -----------------------------------------------------------------------------
+
+// BookListService handles the HTTP GET and returns the book list based on
+// query parameters specified in the URL.
+// The URL should be like:
+//   - /books
+//   - /books?name={BookName}
+// The query parameters could be regular expressions.
+class BookListService : public webcc::RestListService {
+ public:
+  BookListService(int sleep_seconds) : sleep_seconds_(sleep_seconds) {
+  }
+
+ protected:
+  // Return a list of books based on query parameters.
+  // URL examples:
+  //   - /books
+  //   - /books?name={BookName}
+  bool Get(const webcc::UrlQuery& query,
+           std::string* response_content) override;
+
+  // Create a new book.
+  bool Post(const std::string& request_content,
+            std::string* response_content) override;
+
+ private:
+   // Sleep for the client to test timeout control.
+   int sleep_seconds_ = 0;
+};
+
+// -----------------------------------------------------------------------------
+
+// The URL is like '/books/{BookID}', and the 'url_sub_matches' parameter
+// contains the matched book ID.
+class BookDetailService : public webcc::RestDetailService {
+ public:
+  BookDetailService(int sleep_seconds) : sleep_seconds_(sleep_seconds) {
+  }
+
+ protected:
+  bool Get(const std::vector<std::string>& url_sub_matches,
+           const webcc::UrlQuery& query,
+           std::string* response_content) override;
+
+  bool Put(const std::vector<std::string>& url_sub_matches,
+           const std::string& request_content,
+           std::string* response_content) override;
+
+  bool Delete(const std::vector<std::string>& url_sub_matches) override;
+
+ private:
+  // Sleep for the client to test timeout control.
+  int sleep_seconds_ = 0;
+};
+
+#endif  // BOOK_SERVICE_H_

example/rest_book_server/main.cc

@@ -0,0 +1,65 @@
+#include <iostream>
+
+#include "webcc/logger.h"
+#include "webcc/rest_server.h"
+
+#include "example/rest_book_server/book_services.h"
+
+// In order to run with VLD, please copy the following files to the example
+// output folder from "third_party\win32\bin":
+//   - dbghelp.dll
+//   - Microsoft.DTfW.DHL.manifest
+//   - vld_x86.dll
+#if (defined(WIN32) || defined(_WIN64))
+#if defined(_DEBUG) && defined(WEBCC_ENABLE_VLD)
+#pragma message ("< include vld.h >")
+#include "vld/vld.h"
+#pragma comment(lib, "vld")
+#endif
+#endif
+
+void Help(const char* argv0) {
+  std::cout << "Usage: " << argv0 << " <port> [seconds]" << std::endl;
+  std::cout << "If |seconds| is provided, the server will sleep these seconds "
+               "before sending back each response."
+            << std::endl;
+  std::cout << "  E.g.," << std::endl;
+  std::cout << "    " << argv0 << " 8080" << std::endl;
+  std::cout << "    " << argv0 << " 8080 3" << std::endl;
+}
+
+int main(int argc, char* argv[]) {
+  if (argc < 2) {
+    Help(argv[0]);
+    return 1;
+  }
+
+  WEBCC_LOG_INIT("", webcc::LOG_CONSOLE);
+
+  std::uint16_t port = static_cast<std::uint16_t>(std::atoi(argv[1]));
+
+  int sleep_seconds = 0;
+  if (argc >= 3) {
+    sleep_seconds = std::atoi(argv[2]);
+  }
+
+  std::size_t workers = 2;
+
+  try {
+    webcc::RestServer server(port, workers);
+
+    server.Bind(std::make_shared<BookListService>(sleep_seconds),
+                "/books", false);
+
+    server.Bind(std::make_shared<BookDetailService>(sleep_seconds),
+                "/book/(\\d+)", true);
+
+    server.Run();
+
+  } catch (const std::exception& e) {
+    std::cerr << "Exception: " << e.what() << std::endl;
+    return 1;
+  }
+
+  return 0;
+}