├── example
    ├── data
    │   ├── ROOT
    │   ├── nginx
    │   │   ├── ok.php
    │   │   ├── phpinfo.php
    │   │   ├── error.php
    │   │   ├── nginx.html
    │   │   ├── sql.php
    │   │   ├── session.php
    │   │   └── api.php
    │   └── www
    │   │   ├── index.html
    │   │   └── rorona2.jpg
    ├── sql.cc
    ├── example.cc
    ├── benchmark_test.sh
    ├── handler.h
    ├── config
    │   ├── fcgi.conf
    │   └── mime.types
    ├── proxy.cc
    ├── handler.cc
    ├── BUILD
    └── run.sh
├── nineserver
    ├── handler
    │   ├── data
    │   │   ├── ROOT
    │   │   └── default
    │   │   │   └── favicon.ico
    │   ├── system
    │   │   ├── null.cc
    │   │   ├── system.h
    │   │   ├── sleep.cc
    │   │   ├── quit.cc
    │   │   ├── BUILD
    │   │   ├── session.cc
    │   │   ├── db.cc
    │   │   ├── stats.cc
    │   │   ├── info.cc
    │   │   └── system.cc
    │   ├── logging.h
    │   ├── resource_pool.h
    │   ├── resource_pool.cc
    │   ├── logging.cc
    │   ├── BUILD
    │   ├── base_handler_test.cc
    │   └── base_handler.h
    ├── json.cc
    ├── util.cc
    ├── signal.h
    ├── http
    │   ├── html.h
    │   ├── stream
    │   │   ├── string_stream.cc
    │   │   ├── string_stream.h
    │   │   ├── standalone_stream.h
    │   │   ├── BUILD
    │   │   ├── string_stream_test.cc
    │   │   ├── http_stream.h
    │   │   └── standalone_stream.cc
    │   ├── proxy.h
    │   ├── util.h
    │   ├── url.h
    │   ├── html_test.cc
    │   ├── proxy.cc
    │   ├── proxy_main.cc
    │   ├── http_parameters.h
    │   ├── util_test.cc
    │   ├── url.cc
    │   ├── http_contents_test.cc
    │   ├── session_test.cc
    │   ├── http_parameters.cc
    │   ├── session.cc
    │   ├── BUILD
    │   ├── session.h
    │   ├── http_contents.h
    │   ├── http_parameters_test.cc
    │   └── util.cc
    ├── arena
    │   ├── arena_string_piece.cc
    │   ├── arena_test.cc
    │   ├── arena.cc
    │   ├── arena_interface.cc
    │   ├── arena_interface.h
    │   ├── arena.h
    │   ├── BUILD
    │   ├── arena_buffer.cc
    │   ├── arena_buffer_test.cc
    │   ├── arena_interface_test.cc
    │   ├── arena_string_piece.h
    │   └── arena_buffer.h
    ├── main.cc
    ├── tools
    │   ├── BUILD
    │   ├── free_port_main.cc
    │   └── embed_main.cc
    ├── json11
    │   ├── BUILD
    │   ├── LICENSE.txt
    │   └── README.md
    ├── json.h
    ├── benchmark
    │   ├── BUILD
    │   ├── benchmark.h
    │   ├── benchmark_test.cc
    │   └── benchmark.cc
    ├── test
    │   ├── BUILD
    │   ├── handler.cc
    │   └── scenario_test.sh
    ├── hash.h
    ├── io
    │   ├── string_io.cc
    │   ├── string_io.h
    │   ├── descriptor_io.h
    │   ├── BUILD
    │   ├── generic_io.h
    │   ├── string_io_test.cc
    │   ├── descriptor_io.cc
    │   └── generic_io.cc
    ├── sql
    │   ├── BUILD
    │   ├── main.cc
    │   ├── mysql_test.cc
    │   ├── mysql.h
    │   └── mysql.cc
    ├── util.h
    ├── hash_main.cc
    ├── signal.cc
    ├── base64.h
    ├── common_test.cc
    ├── base64_test.cc
    ├── base64.cc
    ├── common.cc
    ├── hash.cc
    ├── json_test.cc
    ├── BUILD
    └── common.h
├── bin
    ├── imosh_test_generate.sh
    ├── BUILD
    └── imosh_test.bzl
├── README.md
├── .gitignore
└── WORKSPACE


/example/data/ROOT:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/nineserver/handler/data/ROOT:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/example/data/nginx/ok.php:
--------------------------------------------------------------------------------
1 | OK
2 | 


--------------------------------------------------------------------------------
/nineserver/json.cc:
--------------------------------------------------------------------------------
1 | #include "nineserver/json.h"
2 | 


--------------------------------------------------------------------------------
/example/data/nginx/phpinfo.php:
--------------------------------------------------------------------------------
1 | <?php
2 | phpinfo();
3 | 


--------------------------------------------------------------------------------
/example/data/nginx/error.php:
--------------------------------------------------------------------------------
1 | <?php
2 | error_log("This is an error.");
3 | 


--------------------------------------------------------------------------------
/example/data/nginx/nginx.html:
--------------------------------------------------------------------------------
1 | <html>
2 | <body>
3 | Hello, nginx!
4 | </body>
5 | </html>
6 | 


--------------------------------------------------------------------------------
/example/data/www/index.html:
--------------------------------------------------------------------------------
1 | <html>
2 | <body>
3 | Hello, world!
4 | </body>
5 | </html>
6 | 


--------------------------------------------------------------------------------
/example/data/www/rorona2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/imos/nineserver/HEAD/example/data/www/rorona2.jpg


--------------------------------------------------------------------------------
/nineserver/util.cc:
--------------------------------------------------------------------------------
1 | // Dummy function to avoid Mac OSX linker issue.
2 | void util_util_h_dummy__() {}
3 | 


--------------------------------------------------------------------------------
/bin/imosh_test_generate.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | cat <<EOM
4 | #!/bin/bash
5 | 
6 | bin/imosh '$1'
7 | EOM
8 | 


--------------------------------------------------------------------------------
/nineserver/handler/data/default/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/imos/nineserver/HEAD/nineserver/handler/data/default/favicon.ico


--------------------------------------------------------------------------------
/example/data/nginx/sql.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | require_once('api.php');
4 | 
5 | header('Content-Type: text/plain');
6 | var_dump(FetchAssoc('/sql'));
7 | 


--------------------------------------------------------------------------------
/nineserver/signal.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | #include <functional>
3 | 
4 | void AddExitHandler(const std::function<void()>& handler);
5 | void RunExitHandlers();
6 | 


--------------------------------------------------------------------------------
/nineserver/http/html.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | #include <string>
3 | 
4 | #include "base/base.h"
5 | 
6 | string EscapeHtml(StringPiece input);
7 | string UnescapeHtml(StringPiece input);
8 | 


--------------------------------------------------------------------------------
/nineserver/http/stream/string_stream.cc:
--------------------------------------------------------------------------------
1 | #include "base/base.h"
2 | #include "nineserver/http/stream/string_stream.h"
3 | 
4 | const string& StringStream::GetOutput() { return io_.output(); }
5 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # nineserver
2 | HTTP server to develop a lightweight web app in C++ easily.  This is designed for visualization in C++ with browser.  Pontentially, this has security issues, so this must be open to external network.
3 | 


--------------------------------------------------------------------------------
/nineserver/arena/arena_string_piece.cc:
--------------------------------------------------------------------------------
1 | #include "nineserver/arena/arena_string_piece.h"
2 | 
3 | #include "base/base.h"
4 | 
5 | ArenaStringPiece operator"" _a(const char* str, std::size_t length) {
6 |   return ArenaStringPiece(str, length);
7 | }
8 | 


--------------------------------------------------------------------------------
/nineserver/arena/arena_test.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/arena/arena.h"
 2 | 
 3 | #include "base/testing.h"
 4 | 
 5 | TEST(ArenaTest, NewString) {
 6 |   Arena arena;
 7 |   string* value = arena.New<string>("foo");
 8 |   EXPECT_EQ("foo", *value);
 9 | }
10 | 


--------------------------------------------------------------------------------
/nineserver/main.cc:
--------------------------------------------------------------------------------
 1 | #include <signal.h>
 2 | 
 3 | #include "base/base.h"
 4 | 
 5 | int HandlerMain(int argc, char **argv);
 6 | 
 7 | int main(int argc, char **argv) {
 8 |   ParseCommandLineFlags(&argc, &argv);
 9 |   signal(SIGPIPE, SIG_IGN);
10 |   return HandlerMain(argc, argv);
11 | }
12 | 


--------------------------------------------------------------------------------
/example/sql.cc:
--------------------------------------------------------------------------------
 1 | #include "handler.h"
 2 | 
 3 | namespace {
 4 | 
 5 | bool SqlHandler(Handler* handler) {
 6 |   Json json = MySQL::SelectAll("SHOW PROCESSLIST");
 7 |   handler->Print(JsonEncode(json));
 8 |   return true;
 9 | }
10 | REGISTER_HANDLER(SqlHandler, "/sql$", SqlHandler);
11 | 
12 | }  // namespace
13 | 


--------------------------------------------------------------------------------
/bin/BUILD:
--------------------------------------------------------------------------------
 1 | licenses(["notice"])
 2 | 
 3 | package(default_visibility = ["//visibility:public"])
 4 | 
 5 | filegroup(
 6 |     name = "bin",
 7 |     srcs = [
 8 |         "imosh",
 9 |         "imosh_test_generate.sh",
10 |     ],
11 | )
12 | 
13 | sh_binary(
14 |     name = "imosh_test_generate",
15 |     srcs = ["imosh_test_generate.sh"],
16 | )
17 | 


--------------------------------------------------------------------------------
/nineserver/arena/arena.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/arena/arena.h"
 2 | 
 3 | #include "base/base.h"
 4 | 
 5 | Arena::~Arena() { DeleteAll(); }
 6 | 
 7 | void Arena::DeleteAll() {
 8 |   string_deleters_.clear();
 9 |   for (const auto& deleter : deleters_) {
10 |     deleter();
11 |   }
12 |   deleters_.clear();
13 |   arena_buffer_.DeleteAll();
14 | }
15 | 


--------------------------------------------------------------------------------
/nineserver/tools/BUILD:
--------------------------------------------------------------------------------
 1 | licenses(["notice"])
 2 | 
 3 | package(default_visibility = ["//visibility:public"])
 4 | 
 5 | cc_binary(
 6 |     name = "embed",
 7 |     srcs = ["embed_main.cc"],
 8 |     deps = ["//external:base"],
 9 | )
10 | 
11 | cc_binary(
12 |     name = "free_port",
13 |     srcs = ["free_port_main.cc"],
14 |     deps = ["//external:base"],
15 | )
16 | 


--------------------------------------------------------------------------------
/nineserver/json11/BUILD:
--------------------------------------------------------------------------------
 1 | licenses(["notice"])
 2 | 
 3 | package(default_visibility = ["//visibility:public"])
 4 | 
 5 | cc_library(
 6 |     name = "json11",
 7 |     srcs = ["json11.cpp"],
 8 |     hdrs = ["json11.hpp"],
 9 |     deps = ["//external:base"],
10 | )
11 | 
12 | cc_test(
13 |     name = "test",
14 |     srcs = ["test.cpp"],
15 |     deps = [":json11"],
16 | )
17 | 


--------------------------------------------------------------------------------
/nineserver/handler/system/null.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/handler/system/system.h"
 2 | 
 3 | bool NullHandler(BaseHandler* handler) {
 4 |   handler->MutableResponse()->Print("OK\n"_a);
 5 |   handler->MutableResponse()->SetHeader(
 6 |       "Content-Type"_a, "text/plain; charset=UTF-8"_a);
 7 |   return true;
 8 | }
 9 | REGISTER_HANDLER(handler, SYSTEM_HANDLER_PREFIX "/null$", NullHandler);
10 | 


--------------------------------------------------------------------------------
/nineserver/handler/system/system.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "nineserver/handler/base_handler.h"
 3 | 
 4 | #define SYSTEM_HANDLER_PREFIX "/_"
 5 | 
 6 | class SystemHandlerTemplate {
 7 |  public:
 8 |   SystemHandlerTemplate(StringPiece title, BaseHandler* handler);
 9 |   ~SystemHandlerTemplate();
10 | 
11 |   void Header(StringPiece title);
12 | 
13 |  private:
14 |   BaseHandler* handler_;
15 | };
16 | 


--------------------------------------------------------------------------------
/nineserver/handler/system/sleep.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/handler/system/system.h"
 2 | 
 3 | bool SleepHandler(BaseHandler* handler) {
 4 |   handler->MutableResponse()->SetHeader(
 5 |       "Content-Type"_a, "text/plain; charset=UTF-8"_a);
 6 |   handler->MutableResponse()->Print("OK\n"_a);
 7 |   sleep(1);
 8 |   return true;
 9 | }
10 | REGISTER_HANDLER(handler, SYSTEM_HANDLER_PREFIX "/sleep$", SleepHandler);
11 | 


--------------------------------------------------------------------------------
/nineserver/json.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | #include <type_traits>
 4 | 
 5 | #define PICOJSON_USE_INT64
 6 | #include "base/base.h"
 7 | #include "nineserver/common.h"
 8 | #include "nineserver/json11/json11.hpp"
 9 | 
10 | using Json = json11::Json;
11 | 
12 | template<class T>
13 | string JsonEncode(const T& value, bool prettify = false) {
14 |   return Json(value).dump(prettify ? 0 : -1);
15 | }
16 | 


--------------------------------------------------------------------------------
/nineserver/handler/system/quit.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/handler/system/system.h"
 2 | 
 3 | bool QuitHandler(BaseHandler* handler) {
 4 |   handler->MutableResponse()->SetHeader(
 5 |       "Content-Type"_a, "text/plain; charset=UTF-8"_a);
 6 |   handler->MutableResponse()->Print("OK\n"_a);
 7 |   handler->Destroy();
 8 |   exit(0);
 9 |   return true;
10 | }
11 | REGISTER_HANDLER(handler, SYSTEM_HANDLER_PREFIX "/quit$", QuitHandler);
12 | 


--------------------------------------------------------------------------------
/example/data/nginx/session.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once('api.php');
 4 | 
 5 | header('Content-Type', 'text/plain; charset=UTF-8');
 6 | LoadSession();
 7 | 
 8 | ob_start();
 9 | print_r($_SESSION);
10 | 
11 | $_SESSION['md5'] = md5($_SESSION['md5']);
12 | $_SESSION['counter']++;
13 | $_SESSION['time'] = date('Y-m-d H:i:s');
14 | $_SESSION['object'] = ['array' => [1, 2, 3], 'object' => ['a' => 'b']];
15 | 
16 | print_r($_SESSION);
17 | StoreSession();
18 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files
 2 | *.slo
 3 | *.lo
 4 | *.o
 5 | *.obj
 6 | 
 7 | # Precompiled Headers
 8 | *.gch
 9 | *.pch
10 | 
11 | # Compiled Dynamic libraries
12 | *.so
13 | *.dylib
14 | *.dll
15 | 
16 | # Fortran module files
17 | *.mod
18 | *.smod
19 | 
20 | # Compiled Static libraries
21 | *.lai
22 | *.la
23 | *.a
24 | *.lib
25 | 
26 | # Executables
27 | *.exe
28 | *.out
29 | *.app
30 | 
31 | # Bazel files
32 | bazel-*
33 | 
34 | # Mac OSX files
35 | .DS_Store
36 | 


--------------------------------------------------------------------------------
/nineserver/http/proxy.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | 
 4 | #include "base/base.h"
 5 | #include "nineserver/common.h"
 6 | #include "nineserver/http/http_contents.h"
 7 | #include "nineserver/io/descriptor_io.h"
 8 | 
 9 | class Proxy {
10 |  public:
11 |   Proxy();
12 |   ~Proxy();
13 | 
14 |   void Init(StringPiece address);
15 | 
16 |   bool Send(HttpContents* request, HttpContents* response);
17 | 
18 |  private:
19 |   string address_;
20 |   DescriptorIO io_;
21 | };
22 | 


--------------------------------------------------------------------------------
/nineserver/handler/system/BUILD:
--------------------------------------------------------------------------------
 1 | licenses(["notice"])
 2 | 
 3 | package(default_visibility = ["//visibility:public"])
 4 | 
 5 | cc_library(
 6 |     name = "system",
 7 |     srcs = glob(["*.cc"]),
 8 |     hdrs = ["system.h"],
 9 |     deps = [
10 |         "//external:base",
11 |         "//nineserver/handler:base_handler",
12 |         "//nineserver/handler:logging",
13 |         "//nineserver/http:html",
14 |         "//nineserver/sql:mysql",
15 |     ],
16 |     alwayslink = 1,
17 | )
18 | 


--------------------------------------------------------------------------------
/example/example.cc:
--------------------------------------------------------------------------------
 1 | #include "handler.h"
 2 | 
 3 | struct ExampleData {
 4 |   int counter = 0;
 5 | };
 6 | 
 7 | bool ExampleHandler(Handler* handler) {
 8 |   auto session = handler->MutableSession();
 9 |   auto lock = session->Lock();
10 |   auto* data = session->Mutable<ExampleData>();
11 |   data->counter++;
12 |   handler->Print("You visited "_a,
13 |                  handler->ArenaStrCat(data->counter), " times!"_a);
14 |   return true;
15 | }
16 | REGISTER_HANDLER(handler, "/example$", ExampleHandler);
17 | 


--------------------------------------------------------------------------------
/nineserver/benchmark/BUILD:
--------------------------------------------------------------------------------
 1 | licenses(["notice"])
 2 | 
 3 | package(default_visibility = ["//visibility:public"])
 4 | 
 5 | cc_library(
 6 |     name = "benchmark",
 7 |     srcs = ["benchmark.cc"],
 8 |     hdrs = ["benchmark.h"],
 9 |     deps = [
10 |         "//external:base",
11 |     ],
12 | )
13 | 
14 | cc_test(
15 |     name = "benchmark_test",
16 |     srcs = ["benchmark_test.cc"],
17 |     deps = [
18 |         ":benchmark",
19 |         "//external:testing_main",
20 |     ],
21 |     tags = ["benchmark"],
22 | )
23 | 


--------------------------------------------------------------------------------
/nineserver/test/BUILD:
--------------------------------------------------------------------------------
 1 | licenses(["notice"])
 2 | 
 3 | package(default_visibility = ["//visibility:public"])
 4 | 
 5 | cc_binary(
 6 |     name = "main",
 7 |     srcs = ["handler.cc", "//nineserver:main"],
 8 |     deps = [
 9 |         "//external:base",
10 |         "//nineserver/handler",
11 |         "//nineserver/http:proxy",
12 |     ],
13 | )
14 | 
15 | sh_test(
16 |     name = "scenario_test",
17 |     srcs = ["scenario_test.sh"],
18 |     data = [
19 |         ":main",
20 |         "//nineserver/tools:free_port",
21 |     ],
22 | )
23 | 


--------------------------------------------------------------------------------
/nineserver/benchmark/benchmark.h:
--------------------------------------------------------------------------------
 1 | #include <functional>
 2 | 
 3 | #include "base/base.h"
 4 | 
 5 | class BenchmarkState {
 6 |  public:
 7 |   BenchmarkState(const string& name) : name_(name) {}
 8 | 
 9 |   bool KeepRunning();
10 | 
11 |  private:
12 |   void PrintStats();
13 |   static double GetTime();
14 | 
15 |   string name_;
16 |   double start_time_;
17 |   int64 iteration_ = 0;
18 |   int64 iteration_to_check_ = 1;
19 |   vector<pair<int64, double>> results_;
20 | };
21 | 
22 | void Benchmark(const string& name, std::function<void()> target);
23 | 


--------------------------------------------------------------------------------
/nineserver/http/util.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <time.h>
 3 | #include <string>
 4 | #include <map>
 5 | #include <unordered_map>
 6 | 
 7 | #include "base/base.h"
 8 | #include "nineserver/arena/arena_string_piece.h"
 9 | 
10 | string ToHttpDateTime(time_t time);
11 | time_t FromHttpDateTime(const string& http_date_time);
12 | 
13 | const map<StringPiece, string>& GetMimeTypes();
14 | ArenaStringPiece GetMimeType(StringPiece extension);
15 | 
16 | void SplitHeader(StringPiece header, StringPiece* key, StringPiece* value,
17 |                  StringPiece* trailing);
18 | 


--------------------------------------------------------------------------------
/nineserver/handler/logging.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <map>
 3 | 
 4 | #include "base/base.h"
 5 | 
 6 | class Logging {
 7 |  public:
 8 |   struct Field {
 9 |     string key;
10 |     string name;
11 |     string unit;
12 |     int divisor;
13 |   };
14 | 
15 |   static void Record(StringPiece path, StringPiece key, int64 value);
16 |   static map<string, map<string, int64>> GetStats();
17 | 
18 |   static void RegisterField(
19 |       StringPiece key, StringPiece name,
20 |       StringPiece unit = StringPiece(), int divisor = 1);
21 |   static vector<Field> GetFields();
22 | };
23 | 


--------------------------------------------------------------------------------
/nineserver/http/stream/string_stream.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "base/base.h"
 3 | #include "nineserver/http/stream/http_stream.h"
 4 | #include "nineserver/io/string_io.h"
 5 | 
 6 | class StringStream : public Stream {
 7 |  public:
 8 |   explicit StringStream() {}
 9 |   ~StringStream() override {}
10 | 
11 |   template<typename T>
12 |   void SetInput(T data) { io_.InitStringIO(data); }
13 |   const string& GetOutput();
14 | 
15 |   const GenericIO& GetIO() const override { return io_; }
16 |   GenericIO* MutableIO() override { return &io_; }
17 | 
18 |  private:
19 |   StringIO io_;
20 | };
21 | 


--------------------------------------------------------------------------------
/nineserver/http/url.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | 
 4 | #include "base/base.h"
 5 | #include "nineserver/arena/arena_buffer.h"
 6 | 
 7 | string UrlEncode(StringPiece value);
 8 | // TODO(P2): Deprecate this function.
 9 | string UrlDecode(StringPiece url);
10 | 
11 | // Decodes URL-encoded string.  Decodes any %## encoding in the given string.
12 | // Plus symbols ('+') are decoded to a space character.
13 | void UrlDecode(StringPiece url, BufferInterface* buffer);
14 | 
15 | void UrlEncode(StringPiece data, BufferInterface* buffer);
16 | 
17 | map<string, string> QueryDecode(StringPiece query);
18 | 


--------------------------------------------------------------------------------
/WORKSPACE:
--------------------------------------------------------------------------------
 1 | http_archive(
 2 |     name = "gbase",
 3 |     url = "https://github.com/imos/gbase/releases/download/v0.8.4/gbase.zip",
 4 |     sha256 = "a4020f78f43962cf13ec85753809ee28749c7c6243c46337f5c441b364e98090",
 5 | )
 6 | 
 7 | bind(
 8 |     name = "base",
 9 |     actual = "@gbase//base"
10 | )
11 | 
12 | bind(
13 |     name = "testing",
14 |     actual = "@gbase//base:testing"
15 | )
16 | 
17 | bind(
18 |     name = "testing_main",
19 |     actual = "@gbase//base:testing_main"
20 | )
21 | 
22 | git_repository(
23 |     name = "cctz",
24 |     remote = "https://github.com/google/cctz",
25 |     tag = "v2.0",
26 | )
27 | 


--------------------------------------------------------------------------------
/bin/imosh_test.bzl:
--------------------------------------------------------------------------------
 1 | def imosh_test(
 2 |     name,
 3 |     srcs=[],
 4 |     data=[],
 5 |     **kargs):
 6 |   if len(srcs) != 1:
 7 |     fail("Exactly one source file must be given.")
 8 |   native.genrule(
 9 |       name = name + "_genrule_sh",
10 |       srcs = ["//bin:imosh_test_generate"],
11 |       outs = [name + "_genrule.sh"],
12 |       cmd = "$(BINDIR)/bin/imosh_test_generate " +
13 |             PACKAGE_NAME + "/" + srcs[0] + " >$@",
14 |   )
15 |   native.sh_test(
16 |       name = name,
17 |       srcs = [name + "_genrule.sh"],
18 |       data = [":" + srcs[0]] + data + ["//bin:imosh"],
19 |       **kargs)
20 | 


--------------------------------------------------------------------------------
/nineserver/http/html_test.cc:
--------------------------------------------------------------------------------
 1 | #include "base/testing.h"
 2 | #include "nineserver/http/html.h"
 3 | 
 4 | TEST(HtmlTest, EscapeHtml) {
 5 |   EXPECT_EQ("&lt;a href=&quot;foo&quot;&gt;&amp;amp; a&apos;b&lt;/a&gt;",
 6 |             EscapeHtml(R"(<a href="foo">&amp; a'b</a>)"));
 7 |   EXPECT_EQ("", EscapeHtml(""));
 8 |   EXPECT_EQ("foo", EscapeHtml("foo"));
 9 |   EXPECT_EQ("あいうえお", EscapeHtml("あいうえお"));
10 | }
11 | 
12 | TEST(HtmlTest, UnescapeHtml) {
13 |   EXPECT_EQ("<foo>", UnescapeHtml("&lt;foo&gt;"));
14 |   EXPECT_EQ("<<<", UnescapeHtml("&#60;&#x3c;&lt;"));
15 |   EXPECT_EQ("∞ ∞ ∞", UnescapeHtml("&infin; &#8734; &#x221E;"));
16 | }
17 | 


--------------------------------------------------------------------------------
/nineserver/hash.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <openssl/evp.h>
 3 | 
 4 | #include "base/base.h"
 5 | #include "nineserver/arena/arena_buffer.h"
 6 | 
 7 | void Md5(StringPiece data, bool binary, BufferInterface* buffer);
 8 | string Md5(StringPiece data, bool binary = false);
 9 | void Sha1(StringPiece data, bool binary, BufferInterface* buffer);
10 | string Sha1(StringPiece data, bool binary = false);
11 | void Sha256(StringPiece data, bool binary, BufferInterface* buffer);
12 | string Sha256(StringPiece data, bool binary = false);
13 | void Sha512(StringPiece data, bool binary, BufferInterface* buffer);
14 | string Sha512(StringPiece data, bool binary = false);
15 | 


--------------------------------------------------------------------------------
/nineserver/http/proxy.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/http/proxy.h"
 2 | 
 3 | Proxy::Proxy() {}
 4 | Proxy::~Proxy() {}
 5 | 
 6 | void Proxy::Init(StringPiece address) {
 7 |   address_ = address.ToString();
 8 | }
 9 | 
10 | bool Proxy::Send(HttpContents* request, HttpContents* response) {
11 |   for (int fallback = 0; fallback < 2; fallback++) {
12 |     response->Clear();
13 |     if (io_.IsDestroyed()) {
14 |       io_.InitDescriptorIO(address_);
15 |     }
16 |     if (!request->Write(&io_) ||
17 |         request->IsDestroyed() || !response->Read(&io_)) {
18 |       io_.Destroy();
19 |       continue;
20 |     }
21 |     return true;
22 |   }
23 |   return false;
24 | }
25 | 


--------------------------------------------------------------------------------
/nineserver/io/string_io.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/io/string_io.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #include "base/base.h"
 6 | 
 7 | int StringIO::ReadIO(char* buffer, int length) {
 8 |   int position = 0;
 9 |   for (; position < length && position_ < input_.size();
10 |        position++, position_++) {
11 |     buffer[position] = input_[position_];
12 |   }
13 |   return position;
14 | }
15 | 
16 | bool StringIO::WriteIO(const vector<StringPiece>& data) {
17 |   if (IsDestroyed()) { return false; }
18 | 
19 |   for (StringPiece buffer : data) {
20 |     output_.append(buffer.data(), buffer.size());
21 |   }
22 |   return true;
23 | }
24 | 
25 | void StringIO::CloseIO() {}
26 | 


--------------------------------------------------------------------------------
/nineserver/handler/resource_pool.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <functional>
 3 | #include <map>
 4 | 
 5 | #include "base/base.h"
 6 | #include "nineserver/arena/arena_string_piece.h"
 7 | #include "nineserver/http/stream/http_stream.h"
 8 | #include "third_party/glog/base/googleinit.h"
 9 | 
10 | class ResourcePool {
11 |  public:
12 |   static void Register(
13 |       const map<StringPiece, StringPiece>& additional_resources);
14 | 
15 |   static const StringPiece* GetOrNull(StringPiece key);
16 | 
17 |   static const map<StringPiece, StringPiece>& Get();
18 | };
19 | 
20 | #define REGISTER_RESOURCE(body) \
21 |     REGISTER_MODULE_INITIALIZER(resource, ResourcePool::Register(body));
22 | 


--------------------------------------------------------------------------------
/example/benchmark_test.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | set -e -u
 4 | 
 5 | PORT="$(./nineserver/tools/free_port)"
 6 | TMPFILE="${TMPDIR:-/tmp}/scenario-${PORT}"
 7 | 
 8 | ./*/main --port="${PORT}" --alsologtostderr &
 9 | 
10 | sleep 0.1
11 | echo 'Benchmark result:' $(
12 |     for i in `seq 500`; do
13 |       echo $(
14 |           ab -n 500 -c 10 -k "http://127.0.0.1:${PORT}/_/null" 2>/dev/null |
15 |           grep Requests | cut -d: -f2 | cut -d. -f1
16 |       )
17 |     done | sort -n | tail -n 1) 'QPS'
18 | 
19 | ################################################################################
20 | # Quit the server.
21 | ################################################################################
22 | curl --silent "http://127.0.0.1:${PORT}/_/quit" >/dev/null
23 | 
24 | wait
25 | 


--------------------------------------------------------------------------------
/nineserver/sql/BUILD:
--------------------------------------------------------------------------------
 1 | licenses(["notice"])
 2 | 
 3 | package(default_visibility = ["//visibility:public"])
 4 | 
 5 | cc_binary(
 6 |     name = "main",
 7 |     srcs = ["main.cc"],
 8 |     deps = [
 9 |         ":mysql",
10 |         "//external:base",
11 |     ],
12 |     linkopts = ["-lmysqlclient"],
13 | )
14 | 
15 | cc_library(
16 |     name = "mysql",
17 |     srcs = ["mysql.cc"],
18 |     hdrs = ["mysql.h"],
19 |     deps = [
20 |         "//external:base",
21 |         "//nineserver/arena:arena_buffer",
22 |         "//nineserver:json",
23 |     ],
24 |     linkopts = ["-lmysqlclient"],
25 | )
26 | 
27 | cc_test(
28 |     name = "mysql_test",
29 |     srcs = ["mysql_test.cc"],
30 |     deps = [
31 |         ":mysql",
32 |         "//external:testing_main",
33 |     ],
34 | )
35 | 


--------------------------------------------------------------------------------
/nineserver/util.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "nineserver/arena/arena.h"
 3 | #include "nineserver/arena/arena_buffer.h"
 4 | #include "nineserver/arena/arena_interface.h"
 5 | #include "nineserver/arena/arena_string_piece.h"
 6 | #include "nineserver/common.h"
 7 | #include "nineserver/handler/base_handler.h"
 8 | #include "nineserver/hash.h"
 9 | #include "nineserver/http/html.h"
10 | #include "nineserver/http/http_contents.h"
11 | #include "nineserver/http/http_parameters.h"
12 | #include "nineserver/http/proxy.h"
13 | #include "nineserver/http/proxy.h"
14 | #include "nineserver/http/util.h"
15 | #include "nineserver/io/descriptor_io.h"
16 | #include "nineserver/io/generic_io.h"
17 | #include "nineserver/json.h"
18 | #include "nineserver/signal.h"
19 | #include "nineserver/sql/mysql.h"
20 | 


--------------------------------------------------------------------------------
/nineserver/http/proxy_main.cc:
--------------------------------------------------------------------------------
 1 | #include "base/base.h"
 2 | #include "nineserver/arena/arena.h"
 3 | #include "nineserver/http/http_contents.h"
 4 | #include "nineserver/http/proxy.h"
 5 | #include "nineserver/io/descriptor_io.h"
 6 | 
 7 | int main(int argc, char **argv) {
 8 |   ParseCommandLineFlags(&argc, &argv);
 9 |   Arena arena;
10 |   DescriptorIO stdin;
11 |   stdin.InitDescriptorIO(0);
12 |   HttpContents request;
13 |   request.Init(&arena);
14 |   CHECK(request.Read(&stdin));
15 |   LOG(INFO) << request.ToJson().dump();
16 | 
17 |   Proxy proxy;
18 |   proxy.Init("tcp://216.239.36.21:80");
19 | 
20 |   HttpContents response;
21 |   response.Init(&arena);
22 |   proxy.Send(&request, &response);
23 | 
24 |   DescriptorIO stdout;
25 |   stdout.InitDescriptorIO(1);
26 |   CHECK(response.Write(&stdout));
27 |   return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/nineserver/hash_main.cc:
--------------------------------------------------------------------------------
 1 | #include <openssl/evp.h>
 2 | 
 3 | #include "nineserver/hash.h"
 4 | 
 5 | DEFINE_string(algorithm, "sha256", "Algorithm.");
 6 | 
 7 | int main(int argc, char **argv) {
 8 |   ParseCommandLineFlags(&argc, &argv);
 9 |   if (argc < 2) {
10 |     fprintf(stderr, "Usage: hash_main --algorithm=<algorithm> string\n");
11 |     OpenSSL_add_all_algorithms();
12 |     exit(1);
13 |   }
14 |   StringBuffer buffer;
15 |   if (FLAGS_algorithm == "md5") {
16 |     Md5(argv[1], false, &buffer);
17 |   } else if (FLAGS_algorithm == "sha1") {
18 |     Sha1(argv[1], false, &buffer);
19 |   } else if (FLAGS_algorithm == "sha256") {
20 |     Sha256(argv[1], false, &buffer);
21 |   } else {
22 |     LOG(FATAL) << "Unknown algorithm: " << FLAGS_algorithm;
23 |   }
24 |   printf("%s\n", buffer.get()->c_str());
25 |   return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/example/handler.h:
--------------------------------------------------------------------------------
 1 | // Only one HandlerFactory is created, and one Handler is created per thread.
 2 | // Global objects must be passed from HandlerFactory, and thread-local data
 3 | // (e.g. cache) should be stored in Handler.  Handler and HandlerFactory are
 4 | // reused and not destructed while server is running.
 5 | #pragma once
 6 | #include "base/base.h"
 7 | #include "nineserver/util.h"
 8 | 
 9 | class Handler : public BaseHandler {
10 |  public:
11 |   Handler();
12 |   ~Handler() override {}
13 | 
14 |   // Called when a request is ready to process.
15 |   bool Run() override;
16 | 
17 |  private:
18 |   Proxy proxy_;
19 | };
20 | 
21 | class HandlerFactory : public BaseHandlerFactory {
22 |  public:
23 |   HandlerFactory() {}
24 |   ~HandlerFactory() override {}
25 | 
26 |   BaseHandler* NewHandler() override { return new Handler(); }
27 | };
28 | 
29 | int HandlerMain(int argc, char** argv);
30 | 


--------------------------------------------------------------------------------
/example/config/fcgi.conf:
--------------------------------------------------------------------------------
 1 | fastcgi_param GATEWAY_INTERFACE CGI/1.1;
 2 | fastcgi_param SERVER_SOFTWARE   nginx;
 3 | fastcgi_param QUERY_STRING      $query_string;
 4 | fastcgi_param REQUEST_METHOD    $request_method;
 5 | fastcgi_param CONTENT_TYPE      $content_type;
 6 | fastcgi_param CONTENT_LENGTH    $content_length;
 7 | fastcgi_param SCRIPT_FILENAME   $document_root$fastcgi_script_name;
 8 | fastcgi_param SCRIPT_NAME       $fastcgi_script_name;
 9 | fastcgi_param REQUEST_URI       $request_uri;
10 | fastcgi_param DOCUMENT_URI      $document_uri;
11 | fastcgi_param DOCUMENT_ROOT     $document_root;
12 | fastcgi_param SERVER_PROTOCOL   $server_protocol;
13 | fastcgi_param REMOTE_ADDR       $remote_addr;
14 | fastcgi_param REMOTE_PORT       $remote_port;
15 | fastcgi_param SERVER_ADDR       $server_addr;
16 | fastcgi_param SERVER_PORT       $server_port;
17 | fastcgi_param SERVER_NAME       $server_name;
18 | fastcgi_index index.php;
19 | 


--------------------------------------------------------------------------------
/nineserver/signal.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/signal.h"
 2 | 
 3 | #include <mutex>
 4 | #include <vector>
 5 | 
 6 | #include "base/base.h"
 7 | 
 8 | namespace {
 9 | 
10 | std::mutex handler_mutex;
11 | vector<std::function<void()>>* handlers;
12 | 
13 | }  // namespace
14 | 
15 | void AddExitHandler(const std::function<void()>& handler) {
16 |   std::lock_guard<std::mutex> lock(handler_mutex);
17 |   if (handlers == nullptr) {
18 |     handlers = new vector<std::function<void()>>();
19 |     handlers->reserve(128);
20 |   }
21 |   handlers->push_back(handler);
22 | }
23 | 
24 | void RunExitHandlers() {
25 |   vector<std::function<void()>>* exit_handlers;
26 |   {
27 |     std::lock_guard<std::mutex> lock(handler_mutex);
28 |     if (handlers == nullptr) { return; }
29 |     exit_handlers = handlers;
30 |     handlers = nullptr;
31 |   }
32 |   for (auto it = exit_handlers->rbegin(); it != exit_handlers->rend(); it++) {
33 |     (*it)();
34 |   }
35 | }
36 | 


--------------------------------------------------------------------------------
/nineserver/tools/free_port_main.cc:
--------------------------------------------------------------------------------
 1 | #include <arpa/inet.h>
 2 | #include <stdio.h>
 3 | #include <sys/socket.h>
 4 | #include <algorithm>
 5 | #include <string>
 6 | #include <vector>
 7 | 
 8 | #include "base/base.h"
 9 | 
10 | #define CHECK_SYS(...) CHECK((__VA_ARGS__) >= 0) << strerror(errno)
11 | 
12 | int main(int argc, char **argv) {
13 |   ParseCommandLineFlags(&argc, &argv);
14 |   int fd = socket(PF_INET, SOCK_STREAM, 0);
15 |   CHECK_SYS(fd);
16 | 
17 |   struct sockaddr_in server_addr = {};
18 |   server_addr.sin_family = AF_INET;
19 |   server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
20 |   server_addr.sin_port = htons(0);
21 |   int enable = 1;
22 |   CHECK_SYS(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable)));
23 |   CHECK_SYS(::bind(fd, (sockaddr*)&server_addr, sizeof(server_addr)));
24 |   socklen_t addrlen = sizeof(server_addr);
25 |   CHECK_SYS(getsockname(fd, (sockaddr*)&server_addr, &addrlen));
26 |   printf("%d\n", ntohs(server_addr.sin_port));
27 |   return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/example/proxy.cc:
--------------------------------------------------------------------------------
 1 | #include "handler.h"
 2 | 
 3 | bool ProxyHandler(Handler* handler) {
 4 |   Proxy proxy;
 5 |   proxy.Init("tcp://216.239.34.21:80");  // imoz.jp
 6 |   StringPiece header = handler->MutableRequest()->GetHeader(""_a);
 7 |   StringPiece method, uri;
 8 |   SplitToStringPieces(header, ' ', &method, &uri, nullptr);
 9 |   if (uri.starts_with("/proxy"_a)) {
10 |     uri.remove_prefix("/proxy"_a.size());
11 |   }
12 |   handler->MutableRequest()->SetHeader(
13 |       ""_a, StrCat(method, " ", uri, " HTTP/1.1"));
14 |   handler->MutableRequest()->SetHeader("Host"_a, "imoz.jp"_a);
15 |   handler->MutableRequest()->SetHeader("Connection"_a, "close"_a);
16 |   if (!proxy.Send(handler->MutableRequest(), handler->MutableResponse())) {
17 |     handler->SetHeader(""_a, "HTTP/1.1 404 Not Found"_a);
18 |     handler->SetHeader("Content-Type"_a, "text/html; charset=UTF8"_a);
19 |     handler->Print("Not found");
20 |     return true;
21 |   }
22 |   return true;
23 | }
24 | REGISTER_HANDLER(handler, "/proxy/", ProxyHandler);
25 | 


--------------------------------------------------------------------------------
/nineserver/base64.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "base/base.h"
 3 | #include "nineserver/arena/arena_buffer.h"
 4 | 
 5 | class Base64 {
 6 |  public:
 7 |   enum Option {
 8 |     NONE = 0,
 9 |     URL = 1,
10 |     PADDING = 2,
11 |   };
12 | 
13 |   static void Encode(StringPiece data, int option, BufferInterface* buffer);
14 | 
15 |   static string Encode(StringPiece data, int option = PADDING) {
16 |     StringBuffer string_buffer;
17 |     Encode(data, option, &string_buffer);
18 |     return std::move(*string_buffer.get());
19 |   }
20 | 
21 |   static string UrlEncode(StringPiece data, int option = URL) {
22 |     StringBuffer string_buffer;
23 |     Encode(data, option, &string_buffer);
24 |     return std::move(*string_buffer.get());
25 |   }
26 | 
27 |   static void Decode(StringPiece data, int option, BufferInterface* buffer);
28 | 
29 |   static string Decode(StringPiece data, int option = NONE) {
30 |     StringBuffer string_buffer;
31 |     Decode(data, option, &string_buffer);
32 |     return std::move(*string_buffer.get());
33 |   }
34 | };
35 | 


--------------------------------------------------------------------------------
/nineserver/io/string_io.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | 
 4 | #include "base/base.h"
 5 | #include "nineserver/arena/arena.h"
 6 | #include "nineserver/io/generic_io.h"
 7 | 
 8 | class StringIO : public GenericIO {
 9 |  public:
10 |   explicit StringIO() {}
11 |   ~StringIO() override { Destroy(); }
12 | 
13 |   void InitStringIO(ArenaStringPiece input) {
14 |     position_ = 0;
15 |     input_ = input;
16 |     output_.clear();
17 |     Init();
18 |   }
19 | 
20 |   void InitStringIO(StringPiece input) {
21 |     input_string_ = input.ToString();
22 |     InitStringIO(ArenaStringPiece(StringPiece(input_string_)));
23 |   }
24 | 
25 |   StringPiece input() const { return input_; }
26 |   const string& output() const { return output_; }
27 | 
28 |   int ReadIO(char* buffer, int length) override;
29 |   bool WriteIO(const vector<StringPiece>& data) override;
30 |   void CloseIO() override;
31 | 
32 |  private:
33 |   int position_;
34 |   StringPiece input_;
35 |   string input_string_;
36 |   string output_;
37 | 
38 |   DISALLOW_COPY_AND_ASSIGN(StringIO);
39 | };
40 | 


--------------------------------------------------------------------------------
/nineserver/benchmark/benchmark_test.cc:
--------------------------------------------------------------------------------
 1 | #include <mutex>
 2 | #include <thread>
 3 | 
 4 | #include "base/testing.h"
 5 | #include "nineserver/benchmark/benchmark.h"
 6 | 
 7 | TEST(BenchmarkTest, DoNothing) {
 8 |   Benchmark("DoNothing", []() {});
 9 | }
10 | 
11 | TEST(BenchmarkTest, Increment) {
12 |   int a;
13 |   Benchmark("Increment", [&a]() {
14 |     a++;
15 |   });
16 | }
17 | 
18 | TEST(BenchmarkTest, AllocateString) {
19 |   Benchmark("AllocateString", []() {
20 |     string s;
21 |     s = "foobar";
22 |   });
23 | }
24 | 
25 | TEST(BenchmarkTest, Nanosleep) {
26 |   struct timespec req, rem;
27 |   req.tv_sec = 0;
28 |   req.tv_nsec = 1;
29 |   Benchmark("Nanosleep", [&req, &rem]() {
30 |     nanosleep(&req, &rem);
31 |   });
32 | }
33 | 
34 | TEST(BenchmarkTest, ThreadYield) {
35 |   Benchmark("Yield", []() {
36 |     std::this_thread::yield();
37 |   });
38 | }
39 | 
40 | TEST(BenchmarkTest, Mutex) {
41 |   std::mutex m;
42 |   Benchmark("LockAndUnlock", [&m]() {
43 |     m.lock();
44 |     m.unlock();
45 |   });
46 |   Benchmark("TryLock", [&m]() {
47 |     m.try_lock();
48 |   });
49 | }
50 | 


--------------------------------------------------------------------------------
/nineserver/arena/arena_interface.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/arena/arena_interface.h"
 2 | 
 3 | #include "base/base.h"
 4 | #include "nineserver/arena/arena.h"
 5 | 
 6 | ArenaStringPiece ArenaInterface::ArenaStringPrintf(const char* format, ...) {
 7 |   va_list ap;
 8 |   va_start(ap, format);
 9 |   ArenaBuffer* buffer = MutableArena()->NextBuffer();
10 |   while (true) {
11 |     buffer->resize(buffer->capacity());
12 |     va_list backup_ap;
13 |     va_copy(backup_ap, ap);
14 |     int output = vsnprintf(buffer->data(), buffer->size(), format, backup_ap);
15 |     va_end(backup_ap);
16 |     if (output < 0) {
17 |       buffer->clear();
18 |       LOG(ERROR) << "Failed to call vsnprintf: " << strerror(errno);
19 |       break;
20 |     }
21 |     if (output < buffer->size()) {
22 |       buffer->resize(output);
23 |       break;
24 |     }
25 |     buffer->clear();
26 |     if (buffer->capacity() > 128 * 1024) {
27 |       LOG(ERROR) << "Too big to ArenaStringPrintf.";
28 |       break;
29 |     }
30 |     buffer->reserve(buffer->capacity() * 2);
31 |   }
32 |   va_end(ap);
33 |   return *buffer;
34 | }
35 | 


--------------------------------------------------------------------------------
/nineserver/test/handler.cc:
--------------------------------------------------------------------------------
 1 | #include "base/base.h"
 2 | #include "nineserver/handler/base_handler.h"
 3 | #include "nineserver/http/proxy.h"
 4 | 
 5 | DEFINE_string(proxy, "tcp://127.0.0.1:8080", "Address to proxy request.");
 6 | DEFINE_string(proxy_host, "localhost:8080", "Host name for proxy.");
 7 | 
 8 | namespace {
 9 | 
10 | class Handler : public BaseHandler {
11 |  public:
12 |   Handler() {
13 |     proxy_.Init(FLAGS_proxy);
14 |   }
15 |   ~Handler() override {}
16 | 
17 |   bool Run() override {
18 |     MutableRequest()->SetHeader(
19 |         "Host"_a, ArenaStringPiece(StringPiece(FLAGS_proxy_host)));
20 |     return proxy_.Send(MutableRequest(), MutableResponse());
21 |   }
22 | 
23 |  private:
24 |   Proxy proxy_;
25 | };
26 | 
27 | class HandlerFactory : public BaseHandlerFactory {
28 |  public:
29 |   HandlerFactory() {}
30 |   ~HandlerFactory() override {}
31 | 
32 |   BaseHandler* NewHandler() override { return new BaseHandler(); }
33 | };
34 | 
35 | }  // namespace
36 | 
37 | int HandlerMain(int argc, char **argv) {
38 |   HandlerFactory handler_factory;
39 |   handler_factory.Run();
40 |   return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/nineserver/handler/resource_pool.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/handler/resource_pool.h"
 2 | 
 3 | #include <functional>
 4 | #include <map>
 5 | #include <mutex>
 6 | #include <string>
 7 | #include <type_traits>
 8 | 
 9 | #include "base/base.h"
10 | 
11 | namespace {
12 | 
13 | map<StringPiece, StringPiece>* resources = nullptr;
14 | std::mutex resources_mutex;
15 | 
16 | }  // namespace
17 | 
18 | void ResourcePool::Register(
19 |     const map<StringPiece, StringPiece>& additional_resources) {
20 |   std::lock_guard<std::mutex> resources_guard(resources_mutex);
21 |   if (resources == nullptr) {
22 |     resources = new std::decay<decltype(*resources)>::type();
23 |   }
24 |   for (const auto& key_and_value : additional_resources) {
25 |     (*resources)[key_and_value.first] = key_and_value.second;
26 |   }
27 | }
28 | 
29 | const StringPiece* ResourcePool::GetOrNull(StringPiece key) {
30 |   return FindOrNull(*resources, key);
31 | }
32 | 
33 | const map<StringPiece, StringPiece>& ResourcePool::Get() {
34 |   return *resources;
35 | }
36 | 
37 | // Avoid resources == nullptr.
38 | REGISTER_RESOURCE((map<StringPiece, StringPiece>({})));
39 | 


--------------------------------------------------------------------------------
/example/handler.cc:
--------------------------------------------------------------------------------
 1 | // Only one HandlerFactory is created, and one Handler is created per thread.
 2 | // Global objects must be passed from HandlerFactory, and thread-local data
 3 | // (e.g. cache) should be stored in Handler.  Handler and HandlerFactory are
 4 | // reused and not destructed while server is running.
 5 | #include "handler.h"
 6 | 
 7 | #include "base/base.h"
 8 | #include "nineserver/util.h"
 9 | 
10 | DEFINE_string(proxy, "tcp://127.0.0.1:8080", "Address to proxy request.");
11 | DEFINE_string(proxy_host, "localhost:8080", "Host name for proxy.");
12 | DECLARE_int32(port);
13 | 
14 | Handler::Handler() {
15 |     proxy_.Init(FLAGS_proxy);
16 | }
17 | 
18 | // Called when a request is ready to process.
19 | bool Handler::Run() {
20 |   MutableRequest()->SetHeader(
21 |       "Host"_a, ArenaStringPiece(StringPiece(FLAGS_proxy_host)));
22 |   MutableRequest()->SetHeader(
23 |       "X-Nineserver-Port"_a, ArenaStrCat(FLAGS_port));
24 |   return proxy_.Send(MutableRequest(), MutableResponse());
25 | }
26 | 
27 | int HandlerMain(int argc, char** argv) {
28 |   HandlerFactory handler_factory;
29 |   handler_factory.Run();
30 |   return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/nineserver/json11/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2013 Dropbox, Inc.
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/nineserver/http/stream/standalone_stream.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <atomic>
 3 | #include <map>
 4 | #include <string>
 5 | 
 6 | #include "base/base.h"
 7 | #include "nineserver/arena/arena.h"
 8 | #include "nineserver/http/http_contents.h"
 9 | #include "nineserver/http/http_parameters.h"
10 | #include "nineserver/http/stream/http_stream.h"
11 | #include "nineserver/http/url.h"
12 | #include "nineserver/io/descriptor_io.h"
13 | 
14 | class StandaloneStream : public Stream {
15 |  public:
16 |   ~StandaloneStream() override {};
17 | 
18 |   static StandaloneStream* New(int index);
19 | 
20 |   static void StartThreads(const std::function<void(Stream*)>& action,
21 |                            vector<std::thread>* threads);
22 | 
23 | 
24 |   const GenericIO& GetIO() const override { return io_; }
25 |   GenericIO* MutableIO() override { return &io_; }
26 | 
27 |   bool Init() override;
28 |   bool Read() override;
29 |   void Destroy() override;
30 |   bool MayRelease() override;
31 | 
32 |  private:
33 |   explicit StandaloneStream(int index) : index_(index) {}
34 | 
35 |   static std::atomic<int> keep_alive_count_;
36 | 
37 |   int index_ = 0;
38 |   DescriptorIO io_;
39 | };
40 | 


--------------------------------------------------------------------------------
/nineserver/arena/arena_interface.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <stdarg.h>
 3 | 
 4 | #include "base/base.h"
 5 | #include "nineserver/arena/arena.h"
 6 | #include "nineserver/arena/arena_buffer.h"
 7 | 
 8 | class ArenaInterface {
 9 |  public:
10 |   template<typename... Args>
11 |   inline ArenaStringPiece ArenaStrCat(const Args&... args) {
12 |     ArenaBuffer* buffer = MutableArena()->NextBuffer();
13 |     buffer->StrCat(args...);
14 |     return *buffer;
15 |   }
16 | 
17 |   ArenaStringPiece ArenaStringPrintf(const char* format, ...)
18 |       // Tell the compiler to do printf format string checking.
19 |       PRINTF_ATTRIBUTE(2, 3);
20 | 
21 |   inline ArenaStringPiece ToArenaStringPiece(string&& content) {
22 |     return ArenaStringPiece(StringPiece(
23 |         *MutableArena()->New<string>(std::move(content))));
24 |   }
25 |   inline ArenaStringPiece ToArenaStringPiece(ArenaStringPiece&& content)
26 |       { return content; }
27 |   inline ArenaStringPiece ToArenaStringPiece(const ArenaStringPiece& content) 
28 |       { return content; }
29 | 
30 |   inline ArenaBuffer* NextBuffer() { return MutableArena()->NextBuffer(); }
31 | 
32 |  protected:
33 |   virtual Arena* MutableArena() = 0;
34 | };
35 | 


--------------------------------------------------------------------------------
/nineserver/io/descriptor_io.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <sys/uio.h>
 3 | #include <unistd.h>
 4 | #include <string>
 5 | 
 6 | #include "base/base.h"
 7 | #include "nineserver/common.h"
 8 | #include "nineserver/io/generic_io.h"
 9 | 
10 | class DescriptorIO : public GenericIO {
11 |  public:
12 |   DescriptorIO() {}
13 |   ~DescriptorIO() override { Destroy(); }
14 | 
15 |   void InitDescriptorIO(StringPiece address);
16 | 
17 |   void InitDescriptorIO(int descriptor) {
18 |     descriptor_ = descriptor;
19 |     InitializeVectorWithCapacity(&write_pointers_, 1, 1024);
20 |     Init();
21 |   }
22 | 
23 |   int GetDescriptor() const { return descriptor_; }
24 | 
25 |   int ReleaseDescriptor() {
26 |     DCHECK(Empty()) << "Buffer must be empty to release descriptor.";
27 |     int released_descriptor = descriptor_;
28 |     descriptor_ = -1;
29 |     Destroy();
30 |     return released_descriptor;
31 |   }
32 | 
33 |   int ReadIO(char* buffer, int length) override;
34 |   bool WriteIO(const vector<StringPiece>& data) override;
35 |   void CloseIO() override;
36 | 
37 |  private:
38 |   int descriptor_ = -1;
39 |   vector<struct iovec> write_pointers_;
40 | 
41 |   DISALLOW_COPY_AND_ASSIGN(DescriptorIO);
42 | };
43 | 


--------------------------------------------------------------------------------
/nineserver/io/BUILD:
--------------------------------------------------------------------------------
 1 | licenses(["notice"])
 2 | 
 3 | package(default_visibility = ["//visibility:public"])
 4 | 
 5 | # Base library.
 6 | cc_library(
 7 |     name = "generic_io",
 8 |     srcs = ["generic_io.cc"],
 9 |     hdrs = ["generic_io.h"],
10 |     deps = [
11 |         "//external:base",
12 |         "//nineserver/arena:arena_buffer",
13 |         "//nineserver:common",
14 |     ],
15 | )
16 | 
17 | cc_library(
18 |     name = "descriptor_io",
19 |     srcs = ["descriptor_io.cc"],
20 |     hdrs = ["descriptor_io.h"],
21 |     deps = [
22 |         ":generic_io",
23 |         "//external:base",
24 |         "//nineserver:common",
25 |     ],
26 | )
27 | 
28 | cc_library(
29 |     name = "string_io",
30 |     srcs = ["string_io.cc"],
31 |     hdrs = ["string_io.h"],
32 |     deps = [
33 |         ":generic_io",
34 |         "//external:base",
35 |         "//nineserver/arena",
36 |         "//nineserver:common",
37 |     ],
38 | )
39 | 
40 | cc_test(
41 |     name = "string_io_test",
42 |     srcs = ["string_io_test.cc"],
43 |     deps = [
44 |         ":string_io",
45 |         "//external:testing_main",
46 |         "//nineserver/arena:arena",
47 |         "//nineserver/arena:arena_buffer",
48 |     ],
49 | )
50 | 


--------------------------------------------------------------------------------
/nineserver/arena/arena.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <functional>
 3 | #include <string>
 4 | #include <type_traits>
 5 | #include <vector>
 6 | 
 7 | #include "base/base.h"
 8 | #include "nineserver/arena/arena_buffer.h"
 9 | #include "nineserver/common.h"
10 | 
11 | class Arena {
12 |  public:
13 |   Arena() {}
14 |   Arena(Arena&& arena) { *this = std::move(arena); }
15 |   Arena& operator=(Arena&& arena) {
16 |     string_deleters_ = std::move(arena.string_deleters_);
17 |     deleters_ = std::move(arena.deleters_);
18 |     return *this;
19 |   }
20 |   ~Arena();
21 | 
22 |   void DeleteAll();
23 | 
24 |   template<class T, class... Args>
25 |   T* New(Args... args) {
26 |     T* pointer = new T(std::forward<Args>(args)...);
27 |     AddDeleter(pointer);
28 |     return pointer;
29 |   }
30 | 
31 |   ArenaBuffer* NextBuffer() {
32 |     arena_buffer_.Init();
33 |     return &arena_buffer_;
34 |   }
35 | 
36 |  private:
37 |   template<class T>
38 |   std::enable_if<!std::is_same<T, string>::value, void> AddDeleter(T* pointer) {
39 |     deleters_.push_back([pointer]() { delete pointer; });
40 |   }
41 | 
42 |   void AddDeleter(string* pointer) {
43 |     string_deleters_.push_back(std::unique_ptr<string>(pointer));
44 |   }
45 | 
46 |   vector<std::unique_ptr<string>> string_deleters_;
47 |   vector<std::function<void()>> deleters_;
48 |   ArenaBuffer arena_buffer_;
49 | 
50 |   DISALLOW_COPY_AND_ASSIGN(Arena);
51 | };
52 | 


--------------------------------------------------------------------------------
/nineserver/sql/main.cc:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <mysql/mysql.h>
 4 | 
 5 | #include "base/base.h"
 6 | #include "nineserver/sql/mysql.h"
 7 | 
 8 | DEFINE_string(query, "SELECT 1", "Query.");
 9 | 
10 | int main(int argc, char **argv) {
11 |   ParseCommandLineFlags(&argc, &argv);
12 |   CHECK(MySQL::Connect() != nullptr);
13 |   string query;
14 |   for (int i = 1; i < argc; i++) {
15 |     if (i != 1) { query.push_back(' '); }
16 |     query.append(argv[i]);
17 |   }
18 |   QueryResult query_result = MySQL::SelectAll(query);
19 |   if (query_result.arena_buffer != nullptr) {
20 |     LOG(INFO) << "Usage: " << query_result.arena_buffer->usage();
21 |   }
22 |   LOG(INFO) << "Num rows: " << query_result.num_rows;
23 |   LOG(INFO) << "Num fields: " << query_result.num_fields;
24 |   printf("(");
25 |   for (int x = 0; x < query_result.num_fields; x++) {
26 |     if (x != 0) { printf(", "); }
27 |     printf("`%s`", query_result.Field(x).ToString().c_str());
28 |   }
29 |   printf(") VALUES\n");
30 |   for (int y = 0; y < query_result.num_rows; y++) {
31 |     if (y != 0) { puts(", "); }
32 |     printf("(");
33 |     for (int x = 0; x < query_result.num_fields; x++) {
34 |       if (x != 0) { printf(", "); }
35 |       if (QueryResult::IsNull(query_result.Get(y, x))) {
36 |         printf("NULL");
37 |       } else {
38 |         printf("\"%s\"", MySQL::Escape(query_result.Get(y, x)).c_str());
39 |       }
40 |     }
41 |     printf(")");
42 |   }
43 |   puts("");
44 | }
45 | 


--------------------------------------------------------------------------------
/nineserver/io/generic_io.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | 
 4 | #include "base/base.h"
 5 | #include "nineserver/arena/arena_buffer.h"
 6 | 
 7 | // I/O interface.
 8 | //
 9 | // Life-cycle:
10 | // 1. Call a custom Init.
11 | // 2. Do Read/Write.
12 | // 3. Call Destroy.
13 | //
14 | // CAVEAT: all methods are not thread-safe.
15 | class GenericIO {
16 |  public:
17 |   GenericIO() : write_buffer_(1) {}
18 |   virtual ~GenericIO() {
19 |     DCHECK(IsDestroyed())
20 |         << "Implementation must call Destroy() in its destructor.";
21 |   }
22 | 
23 |   // Returns true iff character(s) are appended.
24 |   bool ReadLine(BufferInterface* output);
25 |   int ReadN(int length, BufferInterface* output);
26 |   int ReadCharacter();
27 |   bool IsEof();
28 |   bool Write(StringPiece data);
29 |   bool Write(const vector<StringPiece>& data);
30 |   void Destroy();
31 |   bool IsDestroyed() const;
32 |   bool Empty() const;
33 | 
34 |  protected:
35 |   // CAVEAT: Implementation must implement custom Init(s).  They must call Init.
36 |   void Init();
37 | 
38 |   virtual bool WriteIO(const vector<StringPiece>& data) = 0;
39 |   virtual int ReadIO(char* buffer, int length) = 0;
40 |   virtual void CloseIO() = 0;
41 | 
42 |  private:
43 |   bool ReadBuffer();
44 | 
45 |   bool is_destroyed_ = true;
46 |   int buffer_start_;
47 |   int buffer_end_;
48 |   char buffer_[4096];
49 |   // Buffer for Write(StringPiece) not to allocate vector.
50 |   vector<StringPiece> write_buffer_;
51 | 
52 |   DISALLOW_COPY_AND_ASSIGN(GenericIO);
53 | };
54 | 


--------------------------------------------------------------------------------
/example/BUILD:
--------------------------------------------------------------------------------
 1 | licenses(["notice"])
 2 | 
 3 | package(default_visibility = ["//visibility:public"])
 4 | 
 5 | filegroup(
 6 |     name = "data",
 7 |     srcs = glob(["data/**"]),
 8 | )
 9 | 
10 | filegroup(
11 |     name = "config",
12 |     srcs = glob(["config/**"]),
13 | )
14 | 
15 | cc_library(
16 |     name = "embed",
17 |     srcs = ["embed_data.cc"],
18 |     deps = [
19 |         "//external:base",
20 |         "//nineserver/handler:resource_pool",
21 |     ],
22 |     alwayslink = 1,
23 | )
24 | 
25 | genrule(
26 |     name = "embed_data",
27 |     srcs = [":data"],
28 |     outs = ["embed_data.cc"],
29 |     tools = ["//nineserver/tools:embed"],
30 |     cmd = "$(location //nineserver/tools:embed) $(locations :data) > $(OUTS)",
31 | )
32 | 
33 | cc_library(
34 |     name = "library",
35 |     srcs = glob(["*.cc"], exclude=["main.cc"]),
36 |     hdrs = glob(["*.h"]),
37 |     deps = [
38 |         ":embed",
39 |         "//external:base",
40 |         "//nineserver:util",
41 |     ],
42 |     alwayslink = 1,
43 | )
44 | 
45 | cc_binary(
46 |     name = "main",
47 |     srcs = ["//nineserver:main"],
48 |     deps = [
49 |         ":library",
50 |         "//external:base",
51 |     ],
52 | )
53 | 
54 | sh_binary(
55 |     name = "run",
56 |     srcs = ["run.sh"],
57 |     data = [
58 |         ":config",
59 |         ":data",
60 |         ":main",
61 |         "//bin:imosh",
62 |     ],
63 | )
64 | 
65 | sh_test(
66 |     name = "benchmark_test",
67 |     srcs = ["benchmark_test.sh"],
68 |     data = [
69 |         ":main",
70 |         "//nineserver/tools:free_port",
71 |     ],
72 |     tags = ["manual"],
73 | )
74 | 


--------------------------------------------------------------------------------
/nineserver/common_test.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/common.h"
 2 | 
 3 | #include <unordered_set>
 4 | 
 5 | #include "base/testing.h"
 6 | 
 7 | TEST(CommonTest, CaseInsensitiveEqual) {
 8 |   EXPECT_TRUE(CaseInsensitiveEqual("abc", "abc"));
 9 |   EXPECT_TRUE(CaseInsensitiveEqual("abc", "Abc"));
10 |   EXPECT_FALSE(CaseInsensitiveEqual("abc", ""));
11 |   EXPECT_FALSE(CaseInsensitiveEqual("", "abc"));
12 |   EXPECT_TRUE(CaseInsensitiveEqual("", ""));
13 |   EXPECT_FALSE(CaseInsensitiveEqual("abc", "cde"));
14 | }
15 | 
16 | TEST(CommonTest, CaseInsensitiveStringPiece) {
17 |   std::unordered_set<StringPiece, CaseInsensitiveStringPiece,
18 |                      CaseInsensitiveStringPiece> values;
19 |   values.insert("abc");
20 |   EXPECT_EQ(1, values.size());
21 |   values.insert("cdf");
22 |   EXPECT_EQ(2, values.size());
23 |   values.insert("ABC");
24 |   EXPECT_EQ(2, values.size());
25 | }
26 | 
27 | TEST(CommonTest, SplitToStringPieces) {
28 |   StringPiece output[3];
29 |   EXPECT_TRUE(SplitToStringPieces(
30 |       "foo, bar,, baz", ", ", &output[0], &output[1], &output[2]));
31 |   EXPECT_EQ("foo", output[0]);
32 |   EXPECT_EQ("bar,", output[1]);
33 |   EXPECT_EQ("baz", output[2]);
34 | 
35 |   EXPECT_FALSE(SplitToStringPieces(
36 |       "foo, bar", ", ", &output[0], &output[1], &output[2]));
37 | }
38 | 
39 | TEST(CommonTest, ReverseSplitToStringPieces) {
40 |   StringPiece output[3];
41 |   EXPECT_TRUE(ReverseSplitToStringPieces(
42 |       "hoge, foo, bar,, baz", ", ", &output[0], &output[1], &output[2]));
43 |   EXPECT_EQ("hoge, foo", output[0]);
44 |   EXPECT_EQ("bar,", output[1]);
45 |   EXPECT_EQ("baz", output[2]);
46 | }
47 | 


--------------------------------------------------------------------------------
/nineserver/json11/README.md:
--------------------------------------------------------------------------------
 1 | json11
 2 | ------
 3 | 
 4 | json11 is a tiny JSON library for C++11, providing JSON parsing and serialization.
 5 | 
 6 | The core object provided by the library is json11::Json. A Json object represents any JSON
 7 | value: null, bool, number (int or double), string (std::string), array (std::vector), or
 8 | object (std::map).
 9 | 
10 | Json objects act like values. They can be assigned, copied, moved, compared for equality or
11 | order, and so on. There are also helper methods Json::dump, to serialize a Json to a string, and
12 | Json::parse (static) to parse a std::string as a Json object.
13 | 
14 | It's easy to make a JSON object with C++11's new initializer syntax:
15 | 
16 |     Json my_json = Json::object {
17 |         { "key1", "value1" },
18 |         { "key2", false },
19 |         { "key3", Json::array { 1, 2, 3 } },
20 |     };
21 |     std::string json_str = my_json.dump();
22 | 
23 | There are also implicit constructors that allow standard and user-defined types to be
24 | automatically converted to JSON. For example:
25 | 
26 |     class Point {
27 |     public:
28 |         int x;
29 |         int y;
30 |         Point (int x, int y) : x(x), y(y) {}
31 |         Json to_json() const { return Json::array { x, y }; }
32 |     };
33 | 
34 |     std::vector<Point> points = { { 1, 2 }, { 10, 20 }, { 100, 200 } };
35 |     std::string points_json = Json(points).dump();
36 | 
37 | JSON values can have their values queried and inspected:
38 | 
39 |     Json json = Json::array { Json::object { { "k", "v" } } };
40 |     std::string str = json[0]["k"].string_value();
41 | 
42 | More documentation is still to come. For now, see json11.hpp.
43 | 


--------------------------------------------------------------------------------
/nineserver/http/stream/BUILD:
--------------------------------------------------------------------------------
 1 | licenses(["notice"])
 2 | 
 3 | package(default_visibility = ["//visibility:public"])
 4 | 
 5 | cc_library(
 6 |     name = "http_stream",
 7 |     srcs = ["http_stream.cc"],
 8 |     hdrs = ["http_stream.h"],
 9 |     deps = [
10 |         "//external:base",
11 |         "//nineserver/arena",
12 |         "//nineserver/http:http_contents",
13 |         "//nineserver/http:http_parameters",
14 |         "//nineserver/http:util",
15 |         "//nineserver/http:url",
16 |         "//nineserver:base64",
17 |         "//nineserver:common",
18 |         "//nineserver:json",
19 |     ],
20 | )
21 | 
22 | cc_library(
23 |     name = "standalone_stream",
24 |     srcs = ["standalone_stream.cc"],
25 |     hdrs = ["standalone_stream.h"],
26 |     deps = [
27 |         ":http_stream",
28 |         "//external:base",
29 |         "//nineserver/arena",
30 |         "//nineserver/http:http_contents",
31 |         "//nineserver/http:http_parameters",
32 |         "//nineserver/http:url",
33 |         "//nineserver/http:util",
34 |         "//nineserver/io:descriptor_io",
35 |         "//nineserver:common",
36 |         "//nineserver:signal",
37 |     ],
38 | )
39 | 
40 | cc_library(
41 |     name = "string_stream",
42 |     srcs = ["string_stream.cc"],
43 |     hdrs = ["string_stream.h"],
44 |     deps = [
45 |         ":http_stream",
46 |         "//external:base",
47 |         "//nineserver/io:string_io",
48 |     ],
49 | )
50 | 
51 | cc_test(
52 |     name = "string_stream_test",
53 |     srcs = ["string_stream_test.cc"],
54 |     deps = [
55 |         ":string_stream",
56 |         "//external:testing_main",
57 |         "//nineserver/benchmark",
58 |     ],
59 |     tags = ["benchmark"],
60 | )
61 | 


--------------------------------------------------------------------------------
/nineserver/handler/system/session.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/handler/logging.h"
 2 | #include "nineserver/handler/system/system.h"
 3 | #include "nineserver/http/html.h"
 4 | 
 5 | namespace {
 6 | 
 7 | bool SessionHandler(BaseHandler* handler) {
 8 |   SystemHandlerTemplate handler_template("Session Information", handler);
 9 |   handler_template.Header("Session Information");
10 |   handler->Print(
11 |       R"(<h3>Update session</h3>)");
12 | 
13 |   if (handler->ENV("REQUEST_METHOD"_a) == "POST"_a) {
14 |     ArenaStringPiece data = handler->POST("data"_a);
15 |     string error;
16 |     Json new_session = Json::parse(data.ToString(), error);
17 |     if (!error.empty()) {
18 |       handler->Print(
19 |           R"(<div class="alert alert-danger"><strong>Syntax Error!</strong> )",
20 |           EscapeHtml(error), "</div>");
21 |     } else {
22 |       handler->SetSessionData(new_session);
23 |       handler->Print(
24 |           R"(<div class="alert alert-success"><strong>Success!</strong> )",
25 |           "Session was successfully updated.</div>");
26 |     }
27 |   }
28 | 
29 |   handler->Print(
30 |       R"(<form action="#" method="POST">)"
31 |       R"(<textarea name="data" )"
32 |       R"(style="width:100%;height:200px;font-family:monospace;">)",
33 |       EscapeHtml(JsonEncode(handler->SESSION(), true)),
34 |       R"(</textarea><br><input type="submit" value="Update"></form>)");
35 |   handler->Print(
36 |       R"(<h3>Current Session data</h3><pre class="prettyprint lang-js">)"_a,
37 |       EscapeHtml(JsonEncode(handler->SESSION(), true)), "</pre>"_a);
38 | 
39 |   return true;
40 | }
41 | REGISTER_HANDLER(
42 |     SessionHandler, SYSTEM_HANDLER_PREFIX "/session$", SessionHandler);
43 | 
44 | }  // namespace
45 | 


--------------------------------------------------------------------------------
/nineserver/base64_test.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/base64.h"
 2 | 
 3 | #include "base/testing.h"
 4 | 
 5 | TEST(Base64Test, Encode) {
 6 |   EXPECT_EQ("", Base64::Encode(""));
 7 |   EXPECT_EQ("YQ==", Base64::Encode("a"));
 8 |   EXPECT_EQ("YWI=", Base64::Encode("ab"));
 9 |   EXPECT_EQ("YWJj", Base64::Encode("abc"));
10 |   EXPECT_EQ("AA==", Base64::Encode("\0"_a));
11 |   EXPECT_EQ("AAA=", Base64::Encode("\0\0"_a));
12 |   EXPECT_EQ("AAAA", Base64::Encode("\0\0\0"_a));
13 |   EXPECT_EQ("YWJjZA==", Base64::Encode("abcd"));
14 |   EXPECT_EQ("YWI+", Base64::Encode("ab>"));
15 |   EXPECT_EQ("YWI/", Base64::Encode("ab?"));
16 | }
17 | 
18 | TEST(Base64Test, UrlEncode) {
19 |   EXPECT_EQ("", Base64::UrlEncode(""));
20 |   EXPECT_EQ("YQ", Base64::UrlEncode("a"));
21 |   EXPECT_EQ("YWI", Base64::UrlEncode("ab"));
22 |   EXPECT_EQ("YWJj", Base64::UrlEncode("abc"));
23 |   EXPECT_EQ("YWJjZA", Base64::UrlEncode("abcd"));
24 |   EXPECT_EQ("YWI-", Base64::UrlEncode("ab>"));
25 |   EXPECT_EQ("YWI_", Base64::UrlEncode("ab?"));
26 | }
27 | 
28 | TEST(Base64Test, UrlDecode) {
29 |   EXPECT_EQ("", Base64::Decode(""));
30 |   EXPECT_EQ("a", Base64::Decode("YQ=="));
31 |   EXPECT_EQ("ab", Base64::Decode("YWI="));
32 |   EXPECT_EQ("abc", Base64::Decode("YWJj"));
33 |   EXPECT_EQ("abcd", Base64::Decode("YWJjZA=="));
34 | 
35 |   EXPECT_EQ("a", Base64::Decode("YQ"));
36 |   EXPECT_EQ("ab", Base64::Decode("YWI"));
37 |   EXPECT_EQ("abcd", Base64::Decode("YWJjZA"));
38 | 
39 |   EXPECT_EQ("\0"_a, Base64::Decode("AA=="));
40 |   EXPECT_EQ("\0\0"_a, Base64::Decode("AAA="));
41 |   EXPECT_EQ("\0\0\0"_a, Base64::Decode("AAAA"));
42 | 
43 |   EXPECT_EQ("ab>", Base64::Decode("YWI+"));
44 |   EXPECT_EQ("ab?", Base64::Decode("YWI/"));
45 |   EXPECT_EQ("ab>", Base64::Decode("YWI-"));
46 |   EXPECT_EQ("ab?", Base64::Decode("YWI_"));
47 | }
48 | 


--------------------------------------------------------------------------------
/nineserver/io/string_io_test.cc:
--------------------------------------------------------------------------------
 1 | #include "base/testing.h"
 2 | #include "nineserver/arena/arena.h"
 3 | #include "nineserver/arena/arena_buffer.h"
 4 | #include "nineserver/io/string_io.h"
 5 | 
 6 | TEST(StringIOTest, SimpleScenario) {
 7 |   StringIO string_io;
 8 |   ASSERT_TRUE(string_io.IsDestroyed());
 9 |   string_io.InitStringIO("foo\nbar\nbaz"_a);
10 |   StringBuffer line;
11 |   EXPECT_TRUE(string_io.ReadLine(&line));
12 |   ASSERT_EQ("foo\n", line);
13 |   EXPECT_TRUE(string_io.ReadLine(&line));
14 |   ASSERT_EQ("foo\nbar\n", line);
15 |   EXPECT_TRUE(string_io.ReadLine(&line));
16 |   ASSERT_EQ("foo\nbar\nbaz", line);
17 |   EXPECT_FALSE(string_io.ReadLine(&line));
18 | 
19 |   EXPECT_TRUE(string_io.Write("hoge"));
20 |   ASSERT_EQ("hoge", string_io.output());
21 |   EXPECT_TRUE(string_io.Write("piyo"));
22 |   ASSERT_EQ("hogepiyo", string_io.output());
23 |   string_io.Destroy();
24 |   EXPECT_FALSE(string_io.Write("fuga"));
25 |   ASSERT_EQ("hogepiyo", string_io.output());
26 | }
27 | 
28 | TEST(StringIOTest, ReadN) {
29 |   {
30 |     StringIO string_io;
31 |     string_io.InitStringIO("12345"_a);
32 |     StringBuffer buffer;
33 |     // Consume exactly.
34 |     EXPECT_TRUE(string_io.ReadN(5, &buffer));
35 |     ASSERT_EQ("12345", buffer);
36 |     EXPECT_FALSE(string_io.ReadN(0, &buffer));
37 |     EXPECT_FALSE(string_io.ReadN(1, &buffer));
38 |   }
39 | 
40 |   {
41 |     StringIO string_io;
42 |     string_io.InitStringIO("12345"_a);
43 |     StringBuffer buffer;
44 |     // Reads partially.
45 |     EXPECT_TRUE(string_io.ReadN(3, &buffer));
46 |     ASSERT_EQ("123", buffer);
47 |     // Input shortage.
48 |     EXPECT_TRUE(string_io.ReadN(3, &buffer));
49 |     ASSERT_EQ("12345", buffer);
50 |     EXPECT_FALSE(string_io.ReadN(0, &buffer));
51 |     EXPECT_FALSE(string_io.ReadN(1, &buffer));
52 |   }
53 | }
54 | 


--------------------------------------------------------------------------------
/nineserver/http/http_parameters.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <time.h>
 3 | #include <string>
 4 | #include <map>
 5 | #include <unordered_map>
 6 | 
 7 | #include "base/base.h"
 8 | #include "nineserver/arena/arena.h"
 9 | #include "nineserver/common.h"
10 | #include "nineserver/io/generic_io.h"
11 | #include "nineserver/json.h"
12 | 
13 | // Container for a small number of key-value pairs.  This accepts multiple keys.
14 | class HttpParameters {
15 |  public:
16 |   typedef vector<pair<StringPiece, StringPiece>> Parameters;
17 | 
18 |   HttpParameters() {}
19 | 
20 |   // Adds key=value even if duplicated.
21 |   void Add(ArenaStringPiece key, ArenaStringPiece value);
22 |   // Sets key to value.  Removes existings.
23 |   void Set(ArenaStringPiece key, ArenaStringPiece value);
24 |   // Removes all values for key.
25 |   void Remove(StringPiece key);
26 |   // Gets a value with default_value.
27 |   ArenaStringPiece Get(
28 |       StringPiece key,
29 |       ArenaStringPiece default_value = ArenaStringPiece()) const;
30 |   // Returns all values.
31 |   const vector<pair<StringPiece, StringPiece>>& GetValues() const;
32 |   // Removes all values.
33 |   void Clear();
34 |   // Returns true iff empty.
35 |   bool IsEmpty() const { return parameters_.empty(); }
36 |   // Sorts values.
37 |   void Sort();
38 |   bool IsSorted() const;
39 |   // Returns JSON object.
40 |   Json ToJson() const;
41 | 
42 |   Parameters::iterator begin() { return parameters_.begin(); }
43 |   Parameters::iterator end() { return parameters_.end(); }
44 |   Parameters::const_iterator begin() const { return parameters_.begin(); }
45 |   Parameters::const_iterator end() const { return parameters_.end(); }
46 | 
47 | 
48 |  private:
49 |   bool is_sorted_ = true;
50 |   vector<pair<StringPiece, StringPiece>> parameters_;
51 | 
52 |   DISALLOW_COPY_AND_ASSIGN(HttpParameters);
53 | };
54 | 


--------------------------------------------------------------------------------
/nineserver/arena/BUILD:
--------------------------------------------------------------------------------
 1 | licenses(["notice"])
 2 | 
 3 | package(default_visibility = ["//visibility:public"])
 4 | 
 5 | cc_library(
 6 |     name = "arena",
 7 |     srcs = ["arena.cc"],
 8 |     hdrs = ["arena.h"],
 9 |     deps = [
10 |         ":arena_buffer",
11 |         "//external:base",
12 |         "//nineserver:common",
13 |     ],
14 | )
15 | 
16 | cc_test(
17 |     name = "arena_test",
18 |     srcs = ["arena_test.cc"],
19 |     deps = [
20 |         ":arena",
21 |         "//external:testing_main",
22 |     ],
23 | )
24 | 
25 | cc_library(
26 |     name = "arena_buffer",
27 |     srcs = ["arena_buffer.cc"],
28 |     hdrs = ["arena_buffer.h"],
29 |     deps = [
30 |         ":arena_string_piece",
31 |         "//external:base",
32 |         "//nineserver:common",
33 |     ],
34 | )
35 | 
36 | cc_test(
37 |     name = "arena_buffer_test",
38 |     srcs = ["arena_buffer_test.cc"],
39 |     deps = [
40 |         ":arena_buffer",
41 |         "//external:testing_main",
42 |         "//nineserver/benchmark",
43 |     ],
44 |     tags = ["benchmark"],
45 | )
46 | 
47 | cc_library(
48 |     name = "arena_interface",
49 |     srcs = ["arena_interface.cc"],
50 |     hdrs = ["arena_interface.h"],
51 |     deps = [
52 |         ":arena",
53 |         ":arena_buffer",
54 |         "//external:base",
55 |         "//nineserver:common",
56 |     ],
57 | )
58 | 
59 | cc_test(
60 |     name = "arena_interface_test",
61 |     srcs = ["arena_interface_test.cc"],
62 |     deps = [
63 |         ":arena_interface",
64 |         "//external:testing_main",
65 |         "//nineserver/benchmark",
66 |     ],
67 |     tags = ["benchmark"],
68 | )
69 | 
70 | cc_library(
71 |     name = "arena_string_piece",
72 |     srcs = ["arena_string_piece.cc"],
73 |     hdrs = ["arena_string_piece.h"],
74 |     deps = [
75 |         "//external:base",
76 |         "//nineserver:common",
77 |     ],
78 | )
79 | 


--------------------------------------------------------------------------------
/nineserver/base64.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/base64.h"
 2 | 
 3 | void Base64::Encode(StringPiece data, int option, BufferInterface* buffer) {
 4 |   constexpr int kShift[] = {10, 4, 6, 8};
 5 |   constexpr char kBase64[] =
 6 |       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 7 |   constexpr char kUrlBase64[] =
 8 |       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 9 |   const char* pattern = (option & URL) ? kUrlBase64 : kBase64;
10 |   int base64_length = (data.size() + 2) / 3 * 4;
11 |   buffer->reserve(buffer->size() + base64_length);
12 |   for (int i = 0; i < base64_length; i++) {
13 |     int index = i - (i + 3) / 4;
14 |     if (index >= data.size()) {
15 |       if (!(option & URL) && (option & PADDING)) { buffer->push_back('='); }
16 |       continue;
17 |     }
18 |     int value = ((((data[index] & 255L) << 8) |
19 |                  ((index + 1 < data.size() ? data[index + 1] : 0) & 255L))
20 |                  >> kShift[i % 4]) & 63;
21 |     DCHECK_LE(0, value);
22 |     DCHECK_GE(63, value);
23 |     buffer->push_back(pattern[value]);
24 |   }
25 | }
26 | 
27 | void Base64::Decode(StringPiece data, int option, BufferInterface* buffer) {
28 |   constexpr int kShift[] = {0, 4, 2, 0};
29 |   int code = 0;
30 |   buffer->reserve(data.size() * 3 / 4);
31 |   for (int i = 0; i < data.size(); i++) {
32 |     char c = data[i];
33 |     code <<= 6;
34 |     if ('A' <= c && c <= 'Z') {
35 |       code += c - 'A';
36 |     } else if ('a' <= c && c <= 'z') {
37 |       code += c - 'a' + 26;
38 |     } else if ('0' <= c && c <= '9') {
39 |       code += c - '0' + 52;
40 |     } else if (c == '+' || c == '-') {
41 |       code += 62;
42 |     } else if (c == '/' || c == '_') {
43 |       code += 63;
44 |     } else if (c == '=') {
45 |       break;
46 |     }
47 |     if (i % 4 > 0) {
48 |       buffer->push_back(code >> kShift[i % 4]);
49 |     }
50 |   }
51 | }
52 | 


--------------------------------------------------------------------------------
/nineserver/arena/arena_buffer.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/arena/arena_buffer.h"
 2 | 
 3 | #include "base/base.h"
 4 | 
 5 | DEFINE_int32(arena_buffer_size, 16 * 1024, "Initial arena buffer size.");
 6 | 
 7 | ArenaBuffer::ArenaBuffer() {
 8 |   buffers_.emplace_back(FLAGS_arena_buffer_size);
 9 | }
10 | 
11 | void ArenaBuffer::DeleteAll() {
12 |   buffers_.erase(buffers_.begin() + 1, buffers_.end());
13 |   buffers_[0].size_ = 0;
14 |   usage_ = 0;
15 | }
16 | 
17 | void ArenaBuffer::Init() { size_ = 0; }
18 | 
19 | void ArenaBuffer::clear() { resize(0); }
20 | 
21 | void ArenaBuffer::push_back(char c) {
22 |   resize(size() + 1);
23 |   buffers_.back().data_[buffers_.back().size_ - 1] = c;
24 | }
25 | 
26 | void ArenaBuffer::resize(int64 size) {
27 |   reserve(size);
28 |   buffers_.back().size_ += size - size_;
29 |   size_ = size;
30 | }
31 | 
32 | void ArenaBuffer::append(StringPiece str) {
33 |   resize(size() + str.size());
34 |   memcpy(buffers_.back().data_.get() + buffers_.back().size_ - str.size(),
35 |          str.data(), str.size());
36 | }
37 | 
38 | void ArenaBuffer::reserve(int64 size) {
39 |   if (capacity() < size) {
40 |     AddBuffer(size);
41 |   }
42 | }
43 | 
44 | int64 ArenaBuffer::capacity() const {
45 |   return buffers_.back().capacity_ - buffers_.back().size_ + size_;
46 | }
47 | 
48 | int64 ArenaBuffer::usage() const {
49 |   return usage_ + buffers_.back().size_;
50 | }
51 | 
52 | void ArenaBuffer::AddBuffer(int length) {
53 |   DVLOG(10) << "ArenaBuffer::AddBuffer(" << length << ")";
54 |   if (length < buffers_.back().capacity_ * 2) {
55 |     length = buffers_.back().capacity_ * 2;
56 |   }
57 |   usage_ += buffers_.back().capacity_;
58 |   length = (length + 8191) / 8192 * 8192;
59 |   StringPiece original = *this;
60 |   buffers_.emplace_back(length);
61 |   DCHECK_LE(original.size(), length);
62 |   buffers_.back().size_ = original.size();
63 |   memcpy(buffers_.back().data_.get(), original.data(), original.size());
64 | }
65 | 


--------------------------------------------------------------------------------
/nineserver/arena/arena_buffer_test.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/arena/arena_buffer.h"
 2 | 
 3 | #include "base/testing.h"
 4 | #include "nineserver/benchmark/benchmark.h"
 5 | 
 6 | DECLARE_int32(arena_buffer_size);
 7 | 
 8 | class ArenaBufferTest : public testing::Test {
 9 |  public:
10 |   ArenaBufferTest() {
11 |     FLAGS_arena_buffer_size = 128;
12 |   }
13 | };
14 | 
15 | TEST(ArenaBufferTest, SimpleScenario) {
16 |   Benchmark("SimpleScenario", []() {
17 |     ArenaBuffer arena_buffer;
18 |     arena_buffer.append("foo");
19 |     arena_buffer.append("bar");
20 |     StringPiece piece1 = arena_buffer;
21 |     arena_buffer.Init();
22 |     arena_buffer.append("hoge");
23 |     arena_buffer.append("piyo");
24 |     StringPiece piece2 = arena_buffer;
25 |     arena_buffer.Init();
26 |     arena_buffer.push_back('1');
27 |     arena_buffer.append("23");
28 |     arena_buffer.resize(2);
29 |     arena_buffer.append("456");
30 |     StringPiece piece3 = arena_buffer;
31 |     EXPECT_EQ("foobar", piece1);
32 |     EXPECT_EQ("hogepiyo", piece2);
33 |     EXPECT_EQ("12456", piece3);
34 |     EXPECT_EQ('4', piece3[2]);
35 | 
36 |     arena_buffer.DeleteAll();
37 |     arena_buffer.append("bar");
38 |     arena_buffer.append("baz");
39 |     // NOTE: First piece should be overwritten because of DeleteAll.
40 |     EXPECT_EQ("barbaz", piece1);
41 |   });
42 | }
43 | 
44 | TEST(ArenaBufferTest, LargeString) {
45 |   Benchmark("LargeString", []() {
46 |     ArenaBuffer arena_buffer;
47 |     for (int i = 0; i < 10000; i++) {
48 |       arena_buffer.append("foo");
49 |     }
50 |     for (int i = 0; i < 10000; i++) {
51 |       arena_buffer.append("bar");
52 |     }
53 |     StringPiece piece = arena_buffer;
54 |     EXPECT_EQ(60000, arena_buffer.size());
55 |     arena_buffer.Init();
56 |     EXPECT_EQ(0, arena_buffer.size());
57 |     EXPECT_EQ(60000, piece.size());
58 |     EXPECT_EQ("foofoo", piece.substr(0, 6));
59 |     EXPECT_EQ("barbar", piece.substr(piece.size() - 6));
60 |   });
61 | }
62 | 


--------------------------------------------------------------------------------
/nineserver/common.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/common.h"
 2 | 
 3 | #include <sys/time.h>
 4 | #include <sys/types.h> 
 5 | #include <time.h>
 6 | #include <unistd.h>
 7 | #include "base/base.h"
 8 | 
 9 | #ifdef __MACH__
10 | #include <mach/clock.h>
11 | #include <mach/mach.h>
12 | #endif
13 | 
14 | bool CaseInsensitiveEqual(StringPiece l, StringPiece r) {
15 |   if (l.size() != r.size()) { return false; }
16 |   return strncasecmp(l.data(), r.data(), l.size()) == 0;
17 | }
18 | 
19 | double GetThreadClock() {
20 | #ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
21 |   thread_port_t thread = mach_thread_self();
22 |   mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
23 |   thread_basic_info_data_t info;
24 |   CHECK_EQ(thread_info(thread, THREAD_BASIC_INFO, (thread_info_t)&info, &count),
25 |            KERN_SUCCESS);
26 |   mach_port_deallocate(mach_task_self(), thread);
27 |   return info.user_time.seconds + info.system_time.seconds +
28 |          (info.user_time.microseconds + info.system_time.microseconds) * 1e-6;
29 |   // clock_serv_t cclock;
30 |   // mach_timespec_t mts;
31 |   // host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
32 |   // clock_get_time(cclock, &mts);
33 |   // mach_port_deallocate(mach_task_self(), cclock);
34 |   // clock.tv_sec = mts.tv_sec;
35 |   // clock.tv_nsec = mts.tv_nsec;
36 | #else
37 |   struct timespec clock;
38 |   clock_gettime(CLOCK_THREAD_CPUTIME_ID, &clock);
39 |   return clock.tv_sec + clock.tv_nsec * 1e-9;
40 | #endif
41 | }
42 | 
43 | double GetCurrentTime() {
44 |   struct timeval tv;
45 |   gettimeofday(&tv, nullptr);
46 |   return tv.tv_sec + tv.tv_usec * 1e-6;
47 | }
48 | 
49 | int64 Rand() {
50 |   thread_local uint32 x = GetCurrentTime() * 1e6;
51 |   thread_local uint32 y = getpid();
52 |   thread_local uint32 z = 521288629;
53 |   thread_local uint32 w = 88675123;
54 |   unsigned long t = (x ^ (x << 11));
55 |   x = y; y = z; z = w;
56 |   return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
57 | }
58 | 


--------------------------------------------------------------------------------
/nineserver/handler/logging.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/handler/logging.h"
 2 | 
 3 | #include <map>
 4 | #include <mutex>
 5 | #include <string>
 6 | #include <tuple>
 7 | 
 8 | #include "base/base.h"
 9 | 
10 | class LoggingStorage {
11 |  public:
12 |   static LoggingStorage* Get() {
13 |     static LoggingStorage* logging_storage = new LoggingStorage();
14 |     return logging_storage;
15 |   }
16 | 
17 |   void Record(StringPiece path, StringPiece key, int64 value) {
18 |     DVLOG(10) << "Logging " << path << ":" << key << "=" << value;
19 |     std::lock_guard<std::mutex> data_guard(data_mutex_);
20 |     stats_[path.ToString()][key.ToString()] += value;
21 |   }
22 | 
23 |   map<string, map<string, int64>> GetStats() {
24 |     std::lock_guard<std::mutex> data_guard(data_mutex_);
25 |     return stats_;
26 |   }
27 | 
28 |   void RegisterField(
29 |       StringPiece key, StringPiece name, StringPiece unit, int divisor) {
30 |     std::lock_guard<std::mutex> data_guard(data_mutex_);
31 |     fields_.push_back({
32 |         .key = key.ToString(),
33 |         .name = name.ToString(),
34 |         .unit = unit.ToString(),
35 |         .divisor = divisor});
36 |   }
37 | 
38 |   vector<Logging::Field> GetFields() {
39 |     std::lock_guard<std::mutex> data_guard(data_mutex_);
40 |     return fields_;
41 |   }
42 | 
43 |  private:
44 |   std::mutex data_mutex_;
45 |   map<string, map<string, int64>> stats_;
46 |   vector<Logging::Field> fields_;
47 | };
48 | 
49 | void Logging::Record(StringPiece path, StringPiece key, int64 value) {
50 |   LoggingStorage::Get()->Record(path, key, value);
51 | }
52 | 
53 | map<string, map<string, int64>> Logging::GetStats() {
54 |   return LoggingStorage::Get()->GetStats();
55 | }
56 | 
57 | void Logging::RegisterField(
58 |     StringPiece key, StringPiece name, StringPiece unit, int divisor) {
59 |   LoggingStorage::Get()->RegisterField(key, name, unit, divisor);
60 | }
61 | 
62 | vector<Logging::Field> Logging::GetFields() {
63 |   return LoggingStorage::Get()->GetFields();
64 | }
65 | 


--------------------------------------------------------------------------------
/nineserver/arena/arena_interface_test.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/arena/arena_interface.h"
 2 | 
 3 | #include "base/testing.h"
 4 | #include "nineserver/benchmark/benchmark.h"
 5 | 
 6 | DECLARE_int32(arena_buffer_size);
 7 | 
 8 | class ArenaImplForTest : public ArenaInterface {
 9 |  public:
10 |   int64 GetUsage() { return arena_.NextBuffer()->usage(); }
11 | 
12 |  private:
13 |   Arena* MutableArena() override { return &arena_; }
14 | 
15 |   Arena arena_;
16 | };
17 | 
18 | class ArenaInterfaceTest : public testing::Test {
19 |  public:
20 |   ArenaInterfaceTest() {
21 |     FLAGS_arena_buffer_size = 16 * 1024;
22 |   }
23 | };
24 | 
25 | TEST_F(ArenaInterfaceTest, ArenaStrCat) {
26 |   {
27 |     FLAGS_arena_buffer_size = 4;
28 |     ArenaImplForTest arena_impl;
29 |     int counter = 0;
30 |     Benchmark("4", [&]() {
31 |       ASSERT_EQ("12foo34"_a, arena_impl.ArenaStrCat(12, "foo"_a, 34));
32 |       counter++;
33 |     });
34 |     EXPECT_EQ(7, (arena_impl.GetUsage() + 4 * 7) / (counter + 4));
35 |   }
36 |   {
37 |     FLAGS_arena_buffer_size = 4096;
38 |     ArenaImplForTest arena_impl;
39 |     int counter = 0;
40 |     Benchmark("4096", [&]() {
41 |       ASSERT_EQ("12foo34"_a, arena_impl.ArenaStrCat(12, "foo"_a, 34));
42 |       counter++;
43 |     });
44 |     EXPECT_EQ(7, arena_impl.GetUsage() / counter);
45 |   }
46 | }
47 | 
48 | TEST_F(ArenaInterfaceTest, ArenaStringPrintf) {
49 |   {
50 |     FLAGS_arena_buffer_size = 4;
51 |     ArenaImplForTest arena_impl;
52 |     int counter = 0;
53 |     Benchmark("4", [&]() {
54 |       ASSERT_EQ("1234567"_a, arena_impl.ArenaStringPrintf("%d", 1234567));
55 |       counter++;
56 |     });
57 |     EXPECT_EQ(7, (arena_impl.GetUsage() + 4 * 7) / (counter + 4));
58 |   }
59 |   {
60 |     FLAGS_arena_buffer_size = 4096;
61 |     ArenaImplForTest arena_impl;
62 |     int counter = 0;
63 |     Benchmark("4096", [&]() {
64 |       ASSERT_EQ("1234567"_a, arena_impl.ArenaStringPrintf("%d", 1234567));
65 |       counter++;
66 |     });
67 |     EXPECT_EQ(7, arena_impl.GetUsage() / counter);
68 |   }
69 | }
70 | 


--------------------------------------------------------------------------------
/nineserver/benchmark/benchmark.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/benchmark/benchmark.h"
 2 | 
 3 | #include <sys/time.h>
 4 | 
 5 | DEFINE_double(benchmark_duration, 0, "Duration to benchmark.");
 6 | 
 7 | bool BenchmarkState::KeepRunning() {
 8 |   iteration_++;
 9 |   if (iteration_to_check_ == iteration_) {
10 |     if (iteration_to_check_ == 1) {
11 |       iteration_to_check_ = 2;
12 |       start_time_ = GetTime();
13 |       results_.reserve(100);
14 |       results_.emplace_back(iteration_, start_time_);
15 |       return true;
16 |     }
17 |     double current_time = GetTime();
18 |     if (current_time - start_time_ < 0.1 &&
19 |         current_time - start_time_ < FLAGS_benchmark_duration) {
20 |       if (current_time - start_time_ < 0.01) {
21 |         iteration_to_check_ = iteration_ * 8;
22 |       } else {
23 |         iteration_to_check_ = iteration_ * 2;
24 |       }
25 |     } else {
26 |       results_.emplace_back(iteration_, current_time);
27 |       iteration_to_check_ =
28 |           iteration_ + round(iteration_ / (current_time - start_time_) / 10);
29 |       if (iteration_to_check_ <= iteration_) {
30 |         iteration_to_check_ = iteration_ + 1;
31 |       }
32 |       if (current_time - start_time_ > FLAGS_benchmark_duration) {
33 |         PrintStats();
34 |         return false;
35 |       }
36 |     }
37 |   }
38 |   return true;
39 | }
40 | 
41 | void BenchmarkState::PrintStats() {
42 |   double best_qps = 0;
43 |   for (int i = 1; i < results_.size(); i++) {
44 |     best_qps = max(best_qps, (results_[i].first - results_[i - 1].first) /
45 |                              (results_[i].second - results_[i - 1].second));
46 |   }
47 |   printf("%32s: % 16.2f ns\n", name_.c_str(), 1e9 / best_qps);
48 | }
49 | 
50 | double BenchmarkState::GetTime() {
51 |   struct timeval tv;
52 |   gettimeofday(&tv, nullptr);
53 |   return tv.tv_sec + tv.tv_usec * 1e-6;
54 | }
55 | 
56 | void Benchmark(const string& name, std::function<void()> target) {
57 |   BenchmarkState state(name);
58 |   while (state.KeepRunning()) {
59 |     target();
60 |   }
61 | }
62 | 


--------------------------------------------------------------------------------
/nineserver/http/stream/string_stream_test.cc:
--------------------------------------------------------------------------------
 1 | #include "base/testing.h"
 2 | #include "nineserver/benchmark/benchmark.h"
 3 | #include "nineserver/http/stream/string_stream.h"
 4 | 
 5 | class StringStreamTest : public testing::Test {
 6 |  public:
 7 |   StringStreamTest() {}
 8 | 
 9 |   StringPiece GetUri() {
10 |     return stream_.GetRequest().GetEnvironments().Get("REQUEST_URI");
11 |   }
12 | 
13 |   StringStream stream_;
14 | };
15 | 
16 | TEST_F(StringStreamTest, Get) {
17 |   Benchmark("NoKeepAlive", [this]() {
18 |     stream_.SetInput(
19 |         "GET /uri HTTP/1.1\r\n"
20 |         "Host: localhost\r\n"
21 |         "Connection: keep-alive\r\n"
22 |         "\r\n"_a);
23 |     stream_.Init();
24 |     ASSERT_TRUE(stream_.Start());
25 |     ASSERT_EQ("/uri", GetUri());
26 |     ASSERT_FALSE(stream_.Start());
27 |     stream_.Destroy();
28 |   });
29 |   Benchmark("KeepAliveAndCut", [this]() {
30 |     stream_.SetInput(
31 |         "GET /uri HTTP/1.1\r\n"
32 |         "Host: localhost\r\n"
33 |         "Connection: keep-alive\r\n"
34 |         "\r\n"_a);
35 |     stream_.Init();
36 |     stream_.SetKeepAlive();
37 |     ASSERT_TRUE(stream_.Start());
38 |     ASSERT_EQ("/uri", GetUri());
39 |     ASSERT_FALSE(stream_.Start());
40 |     stream_.Destroy();
41 |   });
42 |   Benchmark("KeepAlive", [this]() {
43 |     stream_.SetInput(
44 |         "GET /first HTTP/1.1\r\n"
45 |         "Host: localhost\r\n"
46 |         "Connection: keep-alive\r\n"
47 |         "\r\n"
48 |         "GET /second HTTP/1.1\r\n"
49 |         "Host: localhost\r\n"
50 |         "Connection: keep-alive\r\n"
51 |         "\r\n"
52 |         "GET /third HTTP/1.1\r\n"
53 |         "Host: localhost\r\n"
54 |         "Connection: keep-alive\r\n"
55 |         "\r\n"_a);
56 |     stream_.Init();
57 |     stream_.SetKeepAlive();
58 |     ASSERT_TRUE(stream_.Start());
59 |     ASSERT_EQ("/first", GetUri());
60 |     ASSERT_TRUE(stream_.Start());
61 |     ASSERT_EQ("/second", GetUri());
62 |     ASSERT_TRUE(stream_.Start());
63 |     ASSERT_EQ("/third", GetUri());
64 |     ASSERT_FALSE(stream_.Start());
65 |     stream_.Destroy();
66 |   });
67 | }
68 | 


--------------------------------------------------------------------------------
/nineserver/handler/BUILD:
--------------------------------------------------------------------------------
 1 | licenses(["notice"])
 2 | 
 3 | package(default_visibility = ["//visibility:public"])
 4 | 
 5 | filegroup(
 6 |     name = "data",
 7 |     srcs = glob(["data/**"]),
 8 | )
 9 | 
10 | cc_library(
11 |     name = "handler",
12 |     deps = [
13 |         ":base_handler",
14 |         "//nineserver/handler/system",
15 |     ],
16 | ),
17 | 
18 | cc_library(
19 |     name = "base_handler",
20 |     srcs = ["base_handler.cc"],
21 |     hdrs = ["base_handler.h"],
22 |     deps = [
23 |         ":embed",
24 |         ":logging",
25 |         ":resource_pool",
26 |         "//external:base",
27 |         "//nineserver/arena:arena_interface",
28 |         "//nineserver/http/stream:http_stream",
29 |         "//nineserver/http/stream:standalone_stream",
30 |         "//nineserver/http:session",
31 |         "//nineserver/http:util",
32 |         "//nineserver:common",
33 |         "//nineserver:signal",
34 |     ],
35 | )
36 | 
37 | cc_test(
38 |     name = "base_handler_test",
39 |     srcs = ["base_handler_test.cc"],
40 |     deps = [
41 |         ":base_handler",
42 |         "//external:testing_main",
43 |         "//nineserver/benchmark",
44 |         "//nineserver/handler/system",
45 |         "//nineserver/http/stream:string_stream",
46 |     ],
47 |     tags = ["benchmark"],
48 | )
49 | 
50 | cc_library(
51 |     name = "embed",
52 |     srcs = ["embed_data.cc"],
53 |     deps = [
54 |         "//external:base",
55 |         "//nineserver/handler:resource_pool",
56 |     ],
57 |     alwayslink = 1,
58 | )
59 | 
60 | genrule(
61 |     name = "embed_data",
62 |     srcs = [":data"],
63 |     outs = ["embed_data.cc"],
64 |     tools = ["//nineserver/tools:embed"],
65 |     cmd = "$(location //nineserver/tools:embed) $(locations :data) > $(OUTS)",
66 | )
67 | 
68 | cc_library(
69 |     name = "logging",
70 |     srcs = ["logging.cc"],
71 |     hdrs = ["logging.h"],
72 |     deps = [
73 |         "//external:base",
74 |     ],
75 | )
76 | 
77 | cc_library(
78 |     name = "resource_pool",
79 |     srcs = ["resource_pool.cc"],
80 |     hdrs = ["resource_pool.h"],
81 |     deps = [
82 |         "//external:base",
83 |         "//nineserver/http/stream:http_stream",
84 |     ],
85 | )
86 | 


--------------------------------------------------------------------------------
/nineserver/http/util_test.cc:
--------------------------------------------------------------------------------
 1 | #include "base/testing.h"
 2 | #include "nineserver/http/util.h"
 3 | 
 4 | TEST(HttpTest, ToHttpDateTime) {
 5 |   EXPECT_EQ("Sat, 02 Jan 2016 03:04:05 GMT",
 6 |             ToHttpDateTime(static_cast<time_t>(1451703845)));
 7 | }
 8 | 
 9 | TEST(HttpTest, FromHttpDateTime) {
10 |   EXPECT_EQ(1451703845, FromHttpDateTime("Sat, 02 Jan 2016 03:04:05 UTC"));
11 |   EXPECT_EQ(1451671445, FromHttpDateTime("Sat, 02 Jan 2016 03:04:05 JST"));
12 |   EXPECT_EQ(1451732645, FromHttpDateTime("Sat, 02 Jan 2016 03:04:05 PDT"));
13 |   EXPECT_EQ(1451721845, FromHttpDateTime("Sat, 02 Jan 2016 03:04:05 EDT"));
14 |   EXPECT_EQ(0, FromHttpDateTime("Sat, 02 Jan 2016 03:04:05 XXX"));
15 | }
16 | 
17 | TEST(HttpTest, SplitHeader) {
18 |   {
19 |     StringPiece header = R"(attachment; filename="hogehoge.txt")";
20 |     StringPiece key, value, trailing;
21 |     SplitHeader(header, &key, &value, &header);
22 |     EXPECT_EQ("", key);
23 |     EXPECT_EQ("attachment", value);
24 |     EXPECT_EQ(R"( filename="hogehoge.txt")", header);
25 |   }
26 | 
27 |   {
28 |     StringPiece header = R"(filename="hogehoge.txt"; attachment)";
29 |     StringPiece key, value, trailing;
30 |     SplitHeader(header, &key, &value, &header);
31 |     EXPECT_EQ("filename", key);
32 |     EXPECT_EQ("hogehoge.txt", value);
33 |     EXPECT_EQ(R"( attachment)", header);
34 |   }
35 | 
36 |   {
37 |     StringPiece header = R"(attachment)";
38 |     StringPiece key, value, trailing;
39 |     SplitHeader(header, &key, &value, &header);
40 |     EXPECT_EQ("", key);
41 |     EXPECT_EQ("attachment", value);
42 |     EXPECT_EQ("", header);
43 |   }
44 | 
45 |   {
46 |     StringPiece header = R"(filename="hogehoge.txt")";
47 |     StringPiece key, value, trailing;
48 |     SplitHeader(header, &key, &value, &header);
49 |     EXPECT_EQ("filename", key);
50 |     EXPECT_EQ("hogehoge.txt", value);
51 |     EXPECT_EQ("", header);
52 |   }
53 | 
54 |   {
55 |     StringPiece header = R"(filename="hoge;hoge.txt")";
56 |     StringPiece key, value, trailing;
57 |     SplitHeader(header, &key, &value, &header);
58 |     EXPECT_EQ("filename", key);
59 |     EXPECT_EQ("hoge;hoge.txt", value);
60 |     EXPECT_EQ("", header);
61 |   }
62 | }
63 | 


--------------------------------------------------------------------------------
/nineserver/http/url.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/http/url.h"
 2 | 
 3 | namespace {
 4 | 
 5 | int FromHex(char c) {
 6 |   if ('0' <= c && c <= '9') {
 7 |     return c - '0';
 8 |   }
 9 |   if ('a' <= c && c <= 'f') {
10 |     return static_cast<int>(c - 'a') + 10;
11 |   }
12 |   if ('A' <= c && c <= 'F') {
13 |     return static_cast<int>(c - 'A') + 10;
14 |   }
15 |   return 0;
16 | }
17 | 
18 | char ToHex(int digit) {
19 |   DCHECK_GE(digit, 0);
20 |   DCHECK_LE(digit, 15);
21 |   if (digit < 10) {
22 |     return '0' + digit;
23 |   }
24 |   return 'A' + (digit - 10);
25 | }
26 | 
27 | }  // namespace
28 | 
29 | string UrlEncode(StringPiece value) {
30 |   string result;
31 |   result.reserve(value.size() * 2);
32 |   for (int i = 0; i < value.size(); i++) {
33 |     // Unresrved characters in RFC 3986.
34 |     if (isalnum(value[i]) || value[i] == '.' || value[i] == '~' ||
35 |         value[i] == '-' || value[i] == '_') {
36 |       result.append(1, value[i]);
37 |     } else {
38 |       result.append(StringPrintf("%%%02x", value[i]));
39 |     }
40 |   }
41 |   return result;
42 | }
43 | 
44 | string UrlDecode(StringPiece url) {
45 |   StringBuffer buffer;
46 |   UrlDecode(url, &buffer);
47 |   return buffer;
48 | }
49 | 
50 | void UrlDecode(StringPiece url, BufferInterface* buffer) {
51 |   for (int i = 0; i < url.size(); i++) {
52 |     if (url[i] == '%' && i + 2 < url.size() &&
53 |         isxdigit(url[i + 1]) && isxdigit(url[i + 2])) {
54 |       buffer->push_back(FromHex(url[i + 1]) * 16 + FromHex(url[i + 2]));
55 |       i += 2;
56 |     } else if (url[i] == '+') {
57 |       buffer->push_back(' ');
58 |     } else {
59 |       buffer->push_back(url[i]);
60 |     }
61 |   }
62 | }
63 | 
64 | void UrlEncode(StringPiece data, BufferInterface* buffer) {
65 |   for (int i = 0; i < data.size(); i++) {
66 |     if (isalnum(data[i]) ||
67 |         data[i] == '-' || data[i] == '_' || data[i] == '.') {
68 |       buffer->push_back(data[i]);
69 |     } else {
70 |       buffer->push_back('%');
71 |       buffer->push_back(ToHex((data[i] >> 4) & 15));
72 |       buffer->push_back(ToHex(data[i] & 15));
73 |     }
74 |   }
75 | }
76 | 
77 | map<string, string> QueryDecode(StringPiece query) {
78 |   map<string, string> result;
79 |   for (StringPiece parameter : strings::Split(query, "&")) {
80 |     vector<StringPiece> pieces =
81 |         strings::Split(parameter, strings::delimiter::Limit("=", 1));
82 |     if (pieces.size() != 2) continue;
83 |     result.emplace(UrlDecode(pieces[0]), UrlDecode(pieces[1]));
84 |   }
85 |   return result;
86 | }
87 | 


--------------------------------------------------------------------------------
/nineserver/hash.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/hash.h"
 2 | 
 3 | #include <openssl/evp.h>
 4 | 
 5 | #include "base/base.h"
 6 | #include "nineserver/arena/arena_buffer.h"
 7 | 
 8 | namespace {
 9 | 
10 | char ToHex(int digit) {
11 |   DCHECK_GE(digit, 0);
12 |   DCHECK_LE(digit, 15);
13 |   if (digit < 10) {
14 |     return '0' + digit;
15 |   }
16 |   return 'a' + (digit - 10);
17 | }
18 | 
19 | void AppendHash(StringPiece hash, bool binary, BufferInterface* buffer) {
20 |   if (binary) {
21 |     buffer->append(hash);
22 |     return;
23 |   }
24 |   for (int i = 0; i < hash.size(); i++) {
25 |     buffer->push_back(ToHex((hash[i] >> 4) & 15));
26 |     buffer->push_back(ToHex(hash[i] & 15));
27 |   }
28 | }
29 | 
30 | }  // namespace
31 | 
32 | void Hash(const EVP_MD& md, StringPiece data, bool binary,
33 |           BufferInterface* buffer) {
34 |   char hash[EVP_MAX_MD_SIZE];
35 |   EVP_MD_CTX ctx;
36 |   EVP_MD_CTX_init(&ctx);
37 |   EVP_DigestInit_ex(&ctx, &md, nullptr);
38 |   EVP_DigestUpdate(&ctx, data.data(), data.size());
39 |   unsigned int length;
40 |   EVP_DigestFinal_ex(&ctx, reinterpret_cast<unsigned char*>(hash), &length);
41 |   EVP_MD_CTX_cleanup(&ctx);
42 |   AppendHash(StringPiece(hash, length), binary, buffer);
43 | }
44 | 
45 | void Md5(StringPiece data, bool binary, BufferInterface* buffer) {
46 |   static const EVP_MD* md = EVP_md5();
47 |   Hash(*md, data, binary, buffer);
48 | }
49 | 
50 | string Md5(StringPiece data, bool binary) {
51 |   StringBuffer buffer;
52 |   Md5(data, binary, &buffer);
53 |   return std::move(*buffer.get());
54 | }
55 | 
56 | void Sha1(StringPiece data, bool binary, BufferInterface* buffer) {
57 |   static const EVP_MD* md = EVP_sha1();
58 |   Hash(*md, data, binary, buffer);
59 | }
60 | 
61 | string Sha1(StringPiece data, bool binary) {
62 |   StringBuffer buffer;
63 |   Sha1(data, binary, &buffer);
64 |   return std::move(*buffer.get());
65 | }
66 | 
67 | void Sha256(StringPiece data, bool binary, BufferInterface* buffer) {
68 |   static const EVP_MD* md = EVP_sha256();
69 |   Hash(*md, data, binary, buffer);
70 | }
71 | 
72 | string Sha256(StringPiece data, bool binary) {
73 |   StringBuffer buffer;
74 |   Sha256(data, binary, &buffer);
75 |   return std::move(*buffer.get());
76 | }
77 | 
78 | void Sha512(StringPiece data, bool binary, BufferInterface* buffer) {
79 |   static const EVP_MD* md = EVP_sha512();
80 |   Hash(*md, data, binary, buffer);
81 | }
82 | 
83 | string Sha512(StringPiece data, bool binary) {
84 |   StringBuffer buffer;
85 |   Sha512(data, binary, &buffer);
86 |   return std::move(*buffer.get());
87 | }
88 | 


--------------------------------------------------------------------------------
/nineserver/handler/system/db.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/handler/system/system.h"
 2 | #include "nineserver/http/html.h"
 3 | #include "nineserver/sql/mysql.h"
 4 | 
 5 | namespace {
 6 | 
 7 | void ShowInnoDBStatus(BaseHandler* handler) {
 8 |   QueryResult result = MySQL::SelectAll("SHOW ENGINE INNODB STATUS");
 9 |   handler->Print(R"(<h3>InnoDB Status</h3>)");
10 |   for (int row_index = 0; row_index < result.num_rows; row_index++) {
11 |     for (int field_id = 0; field_id < result.num_fields; field_id++) {
12 |       if (result.Field(field_id) != "Status"_a) continue;
13 |       handler->Print(R"(<pre class="prettyprint lang-js">)",
14 |                      EscapeHtml(result.Get(row_index, field_id)), R"(</pre>)");
15 |     }
16 |   }
17 | }
18 | 
19 | void ShowVariables(BaseHandler* handler) {
20 |   QueryResult result = MySQL::SelectAll("SHOW VARIABLES");
21 |   handler->Print(R"(<h3>Variables</h3>)");
22 |   handler->Print(
23 |       R"(<div class="table-responsive"><table class="table table-striped">)");
24 |   handler->Print("<thead><tr><th>Key</th><th>Value</th></tr></thead>");
25 |   for (int row_index = 0; row_index < result.num_rows; row_index++) {
26 |     handler->Print("<tr>");
27 |     for (int field_id = 0; field_id < result.num_fields; field_id++) {
28 |       handler->Print(
29 |           "<td>", EscapeHtml(result.Get(row_index, field_id)), "</td>");
30 |     }
31 |     handler->Print("</tr>");
32 |   }
33 |   handler->Print("</table></div>");
34 | }
35 | 
36 | void ShowStatus(BaseHandler* handler) {
37 |   QueryResult result = MySQL::SelectAll("SHOW STATUS");
38 |   handler->Print(R"(<h3>Status</h3>)");
39 |   handler->Print(
40 |       R"(<div class="table-responsive"><table class="table table-striped">)");
41 |   handler->Print("<thead><tr><th>Key</th><th>Value</th></tr></thead>");
42 |   for (int row_index = 0; row_index < result.num_rows; row_index++) {
43 |     handler->Print("<tr>");
44 |     for (int field_id = 0; field_id < result.num_fields; field_id++) {
45 |       handler->Print(
46 |           "<td>", EscapeHtml(result.Get(row_index, field_id)), "</td>");
47 |     }
48 |     handler->Print("</tr>");
49 |   }
50 |   handler->Print("</table></div>");
51 | }
52 | 
53 | bool DatabaseHandler(BaseHandler* handler) {
54 |   SystemHandlerTemplate handler_template("Database Status", handler);
55 |   handler_template.Header("Database Status");
56 |   ShowInnoDBStatus(handler);
57 |   ShowVariables(handler);
58 |   ShowStatus(handler);
59 |   return true;
60 | }
61 | REGISTER_HANDLER(
62 |     DatabaseHandler, SYSTEM_HANDLER_PREFIX "/db$", DatabaseHandler);
63 | 
64 | }  // namespace
65 | 


--------------------------------------------------------------------------------
/nineserver/tools/embed_main.cc:
--------------------------------------------------------------------------------
 1 | #include <algorithm>
 2 | #include <string>
 3 | #include <vector>
 4 | 
 5 | #include "base/base.h"
 6 | 
 7 | DEFINE_string(namespace, "", "Namespace.");
 8 | 
 9 | string FileGetContents(const string& file_name) {
10 |   string result;
11 |   FILE* fp = fopen(file_name.c_str(), "r");
12 |   CHECK(fp != nullptr) << "Failed to read " << file_name;
13 |   while (true) {
14 |     char buffer[1024];
15 |     int length = fread(buffer, 1, sizeof(buffer), fp);
16 |     result.append(buffer, length);
17 |     if (length <= 0) break;
18 |   }
19 |   fclose(fp);
20 |   return result;
21 | }
22 | 
23 | void Escape(const string& data) {
24 |   vector<string> buffer;
25 |   buffer.push_back("");
26 |   bool last_is_hex = false;
27 |   for (unsigned char c : data) {
28 |     string output;
29 |     switch (c) {
30 |       case '\n': output = "\\n"; break;
31 |       case '\r': output = "\\r"; break;
32 |       case '"': output = "\\\""; break;
33 |       case '\\': output = "\\\\"; break;
34 |       case '?': output = "\\?"; break;
35 |       default:
36 |         if (isgraph(c) && !(isxdigit(c) && last_is_hex)) {
37 |           output = string(1, c);
38 |         } else {
39 |           output = StringPrintf("\\x%02x", c);
40 |           last_is_hex = true;
41 |         }
42 |         break;
43 |     }
44 |     if (buffer.back().size() + output.size() > 60) {
45 |       buffer.push_back("");
46 |     }
47 |     buffer.back().append(output);
48 |   }
49 |   printf("StringPiece(\n");
50 |   for (const string& line : buffer) {
51 |     printf("    \"%s\"\n", line.c_str());
52 |   }
53 |   printf("    , %ld)\n", data.size());
54 | }
55 | 
56 | int main(int argc, char **argv) {
57 |   ParseCommandLineFlags(&argc, &argv);
58 |   vector<string> files;
59 |   for (int i = 1; i < argc; i++) {
60 |     files.push_back(argv[i]);
61 |   }
62 |   std::sort(files.begin(), files.end());
63 |   int common_length = 0;
64 |   for (; common_length < files[0].size(); common_length++) {
65 |     if (files[0][common_length] != files.back()[common_length]) break;
66 |   }
67 |   puts("#include \"nineserver/handler/resource_pool.h\"");
68 |   puts("namespace {\n");
69 |   puts("map<StringPiece, StringPiece> GetResourceData() {");
70 |   puts("  return map<StringPiece, StringPiece>({");
71 |   for (string& file : files) {
72 |     puts("{");
73 |     Escape(file.substr(common_length, file.size() - common_length));
74 |     puts(",");
75 |     Escape(FileGetContents(file));
76 |     puts("},");
77 |   }
78 |   puts("});");
79 |   puts("}");
80 |   puts("}  // namespace");
81 |   puts("REGISTER_RESOURCE(GetResourceData());");
82 |   return 0;
83 | }
84 | 


--------------------------------------------------------------------------------
/nineserver/handler/system/stats.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/handler/logging.h"
 2 | #include "nineserver/handler/system/system.h"
 3 | #include "nineserver/http/html.h"
 4 | 
 5 | void PrintTable(BaseHandler* handler, bool per_request) {
 6 |   const auto stats = Logging::GetStats();
 7 |   auto fields = Logging::GetFields();
 8 |   string key = handler->GET("key"_a).ToString();
 9 | 
10 |   handler->Print(
11 |       R"(<div class="table-responsive"><table class="table table-striped">)");
12 |   handler->Print("<thead><tr><th><a href=\"?key=path\">Path</a></th>");
13 |   handler->Print("<th><a href=\"?\"># of requests</a></th>");
14 |   for (const auto& field : fields) {
15 |     handler->Print("<th><a href=\"?key=", string(field.key), "\">",
16 |                    EscapeHtml(field.name), "</a></th>");
17 |   }
18 |   handler->Print("</tr></thead>");
19 |   vector<pair<int64, ArenaStringPiece>> rows;
20 |   for (const auto& path_and_key_to_value : stats) {
21 |     ArenaBuffer* buffer = handler->NextBuffer();
22 |     const auto& data = path_and_key_to_value.second;
23 |     int64 num_requests = FindWithDefault(data, "", -1);
24 |     buffer->StrCat("<tr><td>"_a, EscapeHtml(path_and_key_to_value.first),
25 |                    "</td><td>"_a, num_requests, "</td>"_a);
26 |     for (const auto& field : fields) {
27 |       int64 value = FindWithDefault(data, field.key, -1);
28 |       if (value >= 0 && per_request) {
29 |         value /= num_requests;
30 |       }
31 |       if (value < 0) {
32 |         buffer->StrCat("<td>N/A</td>"_a);
33 |       } else {
34 |         value = (value + field.divisor / 2) / field.divisor;
35 |         buffer->StrCat(
36 |             "<td>"_a, value, " "_a, EscapeHtml(field.unit), "</td>"_a);
37 |       }
38 |     }
39 |     buffer->StrCat("</tr>"_a);
40 |     int64 value = FindWithDefault(data, key, 0);
41 |     if (value >= 0 && per_request && key != ""_a) {
42 |       value /= num_requests;
43 |     }
44 |     rows.push_back(pair<int64, ArenaStringPiece>(
45 |         -value, buffer->ToArenaStringPiece()));
46 |   }
47 |   sort(rows.begin(), rows.end());
48 |   for (const auto& row : rows) { handler->Print(row.second); }
49 |   handler->Print("</table></div>");
50 | }
51 | 
52 | bool StatHandler(BaseHandler* handler) {
53 |   SystemHandlerTemplate handler_template("Access Statistics", handler);
54 |   handler_template.Header("Access Statistics");
55 | 
56 |   handler->Print("<h3>Total resource</h3>");
57 |   PrintTable(handler, false /* per_request */);
58 |   handler->Print("<h3>Resource per request</h3>");
59 |   PrintTable(handler, true /* per_request */);
60 | 
61 |   return true;
62 | }
63 | REGISTER_HANDLER(StatHandler, SYSTEM_HANDLER_PREFIX "/stats$", StatHandler);
64 | 


--------------------------------------------------------------------------------
/nineserver/http/http_contents_test.cc:
--------------------------------------------------------------------------------
 1 | #include <sys/time.h>
 2 | 
 3 | #include "base/testing.h"
 4 | #include "nineserver/benchmark/benchmark.h"
 5 | #include "nineserver/http/http_contents.h"
 6 | #include "nineserver/io/string_io.h"
 7 | 
 8 | TEST(HttpContentsTest, Read) {
 9 |   StringIO string_io;
10 |   Arena arena;
11 |   HttpContents http_contents;
12 |   Benchmark("ParseRequest", [&]() {
13 |     string_io.InitStringIO(
14 |         "GET / HTTP/1.1\r\n"
15 |         "User-Agent: foo\r\n"
16 |         "Host: example.com\r\n"
17 |         "Accept: */*\r\n"
18 |         "\r\n"_a);
19 |     http_contents.Init(&arena);
20 |     ASSERT_TRUE(http_contents.Read(&string_io));
21 |   });
22 |   EXPECT_EQ("GET / HTTP/1.1", http_contents.GetHeader(""));
23 |   EXPECT_EQ("example.com", http_contents.GetHeader("Host"));
24 |   EXPECT_EQ("foo", http_contents.GetHeader("User-Agent"));
25 |   http_contents.Init(&arena);
26 |   EXPECT_EQ("", http_contents.GetHeader("Host"));
27 | }
28 | 
29 | TEST(HttpContentsTest, ReadPostRequest) {
30 |   StringIO string_io;
31 |   Arena arena;
32 |   HttpContents http_contents;
33 |   Benchmark("ParseRequest", [&]() {
34 |     string_io.InitStringIO(
35 |         "POST / HTTP/1.1\r\n"
36 |         "User-Agent: foo\r\n"
37 |         "Host: example.com\r\n"
38 |         "Accept: */*\r\n"
39 |         "Content-Length: 7\r\n"
40 |         "Content-Type: application/x-www-form-urlencoded\r\n"
41 |         "\r\n"
42 |         "foo=bar"_a);
43 |     http_contents.Init(&arena);
44 |     ASSERT_TRUE(http_contents.Read(&string_io));
45 |   });
46 |   EXPECT_EQ("POST / HTTP/1.1", http_contents.GetHeader(""));
47 |   EXPECT_EQ("example.com", http_contents.GetHeader("Host"));
48 |   EXPECT_EQ("7", http_contents.GetHeader("Content-Length"));
49 |   EXPECT_EQ("foo=bar", http_contents.GetFirstContent());
50 |   http_contents.Init(&arena);
51 |   EXPECT_EQ("", http_contents.GetHeader("Host"));
52 |   EXPECT_EQ("", http_contents.GetFirstContent());
53 | }
54 | 
55 | TEST(HttpContentsTest, Write) {
56 |   StringIO string_io;
57 |   Arena arena;
58 |   HttpContents http_contents;
59 |   http_contents.Init(&arena);
60 |   http_contents.SetHeader(""_a, "HTTP/1.1 200 OK"_a);
61 |   http_contents.SetHeader("Content-Type"_a, "text/html; charset=UTF-8"_a);
62 |   http_contents.Print("foo"_a);
63 |   http_contents.Print("bar"_a);
64 |   Benchmark("BuildResponse", [&]() {
65 |     string_io.InitStringIO("");
66 |     ASSERT_TRUE(http_contents.Write(&string_io));
67 |     ASSERT_EQ(
68 |         "HTTP/1.1 200 OK\r\n"
69 |         "Content-Type: text/html; charset=UTF-8\r\n"
70 |         "Content-Length: 6\r\n"
71 |         "\r\n"
72 |         "foobar"_a,
73 |         string_io.output());
74 |   });
75 | }
76 | 


--------------------------------------------------------------------------------
/nineserver/json_test.cc:
--------------------------------------------------------------------------------
 1 | #include "base/testing.h"
 2 | #include "nineserver/json.h"
 3 | 
 4 | struct TestObject {
 5 |   string string_value = "";
 6 |   int int_value = 0;
 7 | 
 8 |   Json ToJson() const {
 9 |     return Json::object({
10 |         {"string_value", string_value},
11 |         {"int_value", int_value}});
12 |   }
13 | 
14 |   // string FromJson(const Json& json) {
15 |   //   if (!json.is_object()) {
16 |   //     return "object is expected";
17 |   //   }
18 |   //   auto string_value_ptr = json.find("string_value");
19 |   //   if (string_value_ptr == json.end()) {
20 |   //     string_value = "";
21 |   //   } else if (string_value_ptr->is_string()) {
22 |   //     string_value = string_value_ptr->get<string>();
23 |   //   } else {
24 |   //     return "string_value expects a string";
25 |   //   }
26 |   //   auto int_value_ptr = json.find("int_value");
27 |   //   if (int_value_ptr == json.end()) {
28 |   //     int_value = 0;
29 |   //   } else if (int_value_ptr->is_number()) {
30 |   //     int_value = int_value_ptr->get<int>();
31 |   //   } else {
32 |   //     return "int_value expects a number";
33 |   //   }
34 |   //   return "";
35 |   // }
36 | };
37 | 
38 | TEST(JsonTest, JsonEncode) {
39 |   EXPECT_EQ("[3,2,1]", JsonEncode(vector<int>({3, 2 ,1})));
40 |   EXPECT_EQ("[0.5,1,1.5]", JsonEncode(vector<double>({0.5, 1, 1.5})));
41 |   EXPECT_EQ("[1,2,3]", JsonEncode(set<int>({3, 2, 1})));
42 |   EXPECT_EQ(R"({"key":"value"})",
43 |             JsonEncode(map<string, string>({{"key", "value"}})));
44 |   EXPECT_EQ(R"({"key1":"value1","key2":"value2"})",
45 |             JsonEncode(
46 |                 map<string, string>({{"key1", "value1"}, {"key2", "value2"}})));
47 |   TestObject test_object;
48 |   test_object.string_value = "foo";
49 |   test_object.int_value = 12345;
50 |   EXPECT_EQ(R"({"int_value":12345,"string_value":"foo"})",
51 |             JsonEncode(test_object));
52 | }
53 | 
54 | /*
55 | TEST(JsonTest, JsonDecode) {
56 |   {
57 |     vector<int> value;
58 |     EXPECT_EQ("", JsonDecode("[1,2,3]", &value));
59 |     EXPECT_THAT(value, testing::ElementsAre(1, 2, 3));
60 |   }
61 | 
62 |   {
63 |     vector<int> value;
64 |     EXPECT_EQ("", JsonDecode("[1,2,3]", &value));
65 |     EXPECT_THAT(value, testing::ElementsAre(1, 2, 3));
66 |   }
67 | 
68 |   {
69 |     TestObject value;
70 |     EXPECT_EQ(
71 |         "", JsonDecode(R"({"int_value":12345,"string_value":"foo"})", &value));
72 |     EXPECT_EQ(12345, value.int_value);
73 |     EXPECT_EQ("foo", value.string_value);
74 |   }
75 | 
76 |   {
77 |     vector<int> value;
78 |     EXPECT_NE("", JsonDecode("[1,2,\"3\"]", &value));
79 |   }
80 | 
81 |   {
82 |     TestObject value;
83 |     EXPECT_NE("", JsonDecode(R"({"int_value":"foo"})", &value));
84 |   }
85 | }
86 | */


--------------------------------------------------------------------------------
/nineserver/BUILD:
--------------------------------------------------------------------------------
  1 | licenses(["notice"])
  2 | 
  3 | package(default_visibility = ["//visibility:public"])
  4 | 
  5 | cc_library(
  6 |     name = "common",
  7 |     srcs = ["common.cc"],
  8 |     hdrs = ["common.h"],
  9 |     deps = ["//external:base"],
 10 | )
 11 | 
 12 | cc_library(
 13 |     name = "util",
 14 |     srcs = ["util.cc"],
 15 |     hdrs = ["util.h"],
 16 |     deps = [
 17 |         ":common",
 18 |         ":hash",
 19 |         ":json",
 20 |         ":signal",
 21 |         "//external:base",
 22 |         "//nineserver/arena:arena",
 23 |         "//nineserver/arena:arena_buffer",
 24 |         "//nineserver/arena:arena_interface",
 25 |         "//nineserver/arena:arena_string_piece",
 26 |         "//nineserver/handler",
 27 |         "//nineserver/http/stream:http_stream",
 28 |         "//nineserver/http:html",
 29 |         "//nineserver/http:http_contents",
 30 |         "//nineserver/http:http_parameters",
 31 |         "//nineserver/http:proxy",
 32 |         "//nineserver/http:url",
 33 |         "//nineserver/http:util",
 34 |         "//nineserver/io:descriptor_io",
 35 |         "//nineserver/io:generic_io",
 36 |         "//nineserver/sql:mysql",
 37 |     ],
 38 | )
 39 | 
 40 | cc_library(
 41 |     name = "base64",
 42 |     srcs = ["base64.cc"],
 43 |     hdrs = ["base64.h"],
 44 |     deps = [
 45 |         "//external:base",
 46 |         "//nineserver/arena:arena_buffer",
 47 |     ],
 48 | )
 49 | 
 50 | cc_test(
 51 |     name = "base64_test",
 52 |     srcs = ["base64_test.cc"],
 53 |     deps = [
 54 |         ":base64",
 55 |         "//external:testing_main",
 56 |     ],
 57 | )
 58 | 
 59 | cc_binary(
 60 |     name = "hash_main",
 61 |     srcs = ["hash_main.cc"],
 62 |     deps = [
 63 |         ":hash",
 64 |         "//external:base",
 65 |         "//nineserver/arena:arena_buffer",
 66 |     ],
 67 |     linkopts = ["-lcrypto"],
 68 | )
 69 | 
 70 | cc_library(
 71 |     name = "hash",
 72 |     srcs = ["hash.cc"],
 73 |     hdrs = ["hash.h"],
 74 |     deps = [
 75 |         "//external:base",
 76 |         "//nineserver/arena:arena_buffer",
 77 |     ],
 78 |     linkopts = ["-lcrypto"],
 79 | )
 80 | 
 81 | cc_library(
 82 |     name = "json",
 83 |     srcs = ["json.cc"],
 84 |     hdrs = ["json.h"],
 85 |     deps = [
 86 |         ":common",
 87 |         "//external:base",
 88 |         "//nineserver/json11",
 89 |     ],
 90 | )
 91 | 
 92 | cc_test(
 93 |     name = "json_test",
 94 |     srcs = ["json_test.cc"],
 95 |     deps = [
 96 |         ":json",
 97 |         "//external:testing_main",
 98 |     ],
 99 | )
100 | 
101 | cc_test(
102 |     name = "common_test",
103 |     srcs = ["common_test.cc"],
104 |     deps = [
105 |         ":util",
106 |         "//external:testing_main",
107 |     ],
108 | )
109 | 
110 | filegroup(
111 |     name = "main",
112 |     srcs = ["main.cc"],
113 | )
114 | 
115 | cc_library(
116 |     name = "signal",
117 |     srcs = ["signal.cc"],
118 |     hdrs = ["signal.h"],
119 |     deps = ["//external:base"],
120 | )
121 | 


--------------------------------------------------------------------------------
/nineserver/http/session_test.cc:
--------------------------------------------------------------------------------
  1 | #include "base/testing.h"
  2 | #include "nineserver/common.h"
  3 | #include "nineserver/http/session.h"
  4 | 
  5 | DECLARE_int32(num_sessions);
  6 | 
  7 | class SessionTest : public testing::Test {
  8 |  public:
  9 |   SessionTest() {
 10 |     FLAGS_num_sessions = 10000;
 11 |   }
 12 | };
 13 | 
 14 | struct TestData1 {
 15 |   TestData1() : value("") {}
 16 |   TestData1(const string& v) : value(v) {}
 17 | 
 18 |   string value;
 19 | };
 20 | 
 21 | struct TestData2 {
 22 |   TestData2() {}
 23 |   TestData2(const string& v) : value(v) {}
 24 | 
 25 |   string value;
 26 | };
 27 | 
 28 | TEST_F(SessionTest, SimpleSenario) {
 29 |   Session session;
 30 |   auto lock = session.Lock();
 31 |   ASSERT_EQ(nullptr, session.GetOrNull<TestData1>());
 32 |   EXPECT_EQ("", session.Get<TestData1>().value);
 33 |   session.Set(MakeUnique<TestData1>("test1a"));
 34 |   EXPECT_EQ("test1a", session.Get<TestData1>().value);
 35 |   {
 36 |     auto* test_data = session.Mutable<TestData1>();
 37 |     ASSERT_NE(nullptr, test_data);
 38 |     EXPECT_EQ("test1a", test_data->value);
 39 |     test_data->value = "test1b";
 40 |   }
 41 |   {
 42 |     auto* test_data = session.GetOrNull<TestData1>();
 43 |     ASSERT_NE(nullptr, test_data);
 44 |     EXPECT_EQ("test1b", test_data->value);
 45 |   }
 46 | 
 47 |   ASSERT_EQ(nullptr, session.GetOrNull<TestData2>());
 48 |   session.Set(MakeUnique<TestData2>("test2a"));
 49 |   {
 50 |     auto* test_data = session.GetOrNull<TestData1>();
 51 |     ASSERT_NE(nullptr, test_data);
 52 |     EXPECT_EQ("test1b", test_data->value);
 53 |   }
 54 |   {
 55 |     auto* test_data = session.GetOrNull<TestData2>();
 56 |     ASSERT_NE(nullptr, test_data);
 57 |     EXPECT_EQ("test2a", test_data->value);
 58 |   }
 59 |   {
 60 |     auto* test_data = session.Mutable<TestData2>();
 61 |     ASSERT_NE(nullptr, test_data);
 62 |     EXPECT_EQ("test2a", test_data->value);
 63 |     test_data->value = "test2b";
 64 |   }
 65 |   {
 66 |     auto* test_data = session.GetOrNull<TestData2>();
 67 |     ASSERT_NE(nullptr, test_data);
 68 |     EXPECT_EQ("test2b", test_data->value);
 69 |   }
 70 |   {
 71 |     auto* test_data = session.GetOrNull<TestData1>();
 72 |     ASSERT_NE(nullptr, test_data);
 73 |     EXPECT_EQ("test1b", test_data->value);
 74 |   }
 75 | }
 76 | 
 77 | TEST_F(SessionTest, Sessions) {
 78 |   FLAGS_num_sessions = 3;
 79 |   std::shared_ptr<Session> session = GetSession("example");
 80 |   session->Set(MakeUnique<string>("test1"));
 81 |   ASSERT_EQ("test1", GetSession("example")->Get<string>());
 82 |   for (int i = 0; i < 10; i++) {
 83 |     GetSession(StrCat(i));
 84 |   }
 85 |   // Empty sessions should be removed in advance.
 86 |   ASSERT_EQ("test1", GetSession("example")->Get<string>());
 87 | 
 88 |   for (int i = 0; i < 10; i++) {
 89 |     GetSession(StrCat(i))->Set(MakeUnique<string>("dummy"));
 90 |     RemoveSession(StrCat(i));
 91 |   }
 92 |   // The other sessions are removed, so this session should still be alive.
 93 |   ASSERT_EQ("test1", GetSession("example")->Get<string>());
 94 | 
 95 |   for (int i = 0; i < 10; i++) {
 96 |     GetSession(StrCat(i))->Set(MakeUnique<string>("dummy"));
 97 |   }
 98 |   // The session should be kicked out.
 99 |   ASSERT_EQ("", GetSession("example")->Get<string>());
100 | }
101 | 


--------------------------------------------------------------------------------
/example/data/nginx/api.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | function GetWalltime()
  4 |     { return array_sum(array_map('floatval', explode(' ', microtime()))); }
  5 | 
  6 | define('START_TIME', GetWalltime());
  7 | 
  8 | function CallApiInternal($path, $data) {
  9 |   $sock = pfsockopen($_SERVER['REMOTE_ADDR'],
 10 |                      intval($_SERVER['HTTP_X_NINESERVER_PORT']));
 11 |   if ($sock === FALSE) {
 12 |     error_log('Failed to call API.' . $_SERVER['HTTP_X_NINESERVER_PORT']);
 13 |     return FALSE;
 14 |   }
 15 |   header('X-Nineserver-Proxy: ' . ftell($sock));
 16 |   $cookies = [];
 17 |   foreach ($_COOKIE as $key => $value) {
 18 |     $cookies[] = "$key=$value";
 19 |   }
 20 |   $cookie_header = '';
 21 |   if (count($cookies) > 0) {
 22 |     $cookie_header = "Cookie: " . implode('; ', $cookies) . "\r\n";
 23 |   }
 24 |   if (fwrite(
 25 |       $sock,
 26 |       "POST $path HTTP/1.1\r\n" . $cookie_header .
 27 |       "Content-Length: " . strlen($data) . "\r\n\r\n" . $data) === FALSE) {
 28 |     error_log('Failed to call fwrite.');
 29 |     return FALSE;
 30 |   }
 31 |   $headers = [];
 32 |   while (true) {
 33 |     $header = fgets($sock);
 34 |     if ($header === FALSE) {
 35 |       error_log('Header is broken');
 36 |       return FALSE;
 37 |     }
 38 |     if (count($headers) == 0) {
 39 |       $headers[''] = trim($header);
 40 |       continue;
 41 |     }
 42 |     if (trim($header) == '') break;
 43 |     list($key, $value) = explode(': ', rtrim($header), 2);
 44 |     if ($key == 'Set-Cookie') {
 45 |       header("$key: $value");
 46 |       $cookie_value = explode('; ', $value, 2);
 47 |       list($cookie_key, $cookie_value) = explode('=', $cookie_value, 2);
 48 |       $_COOKIE[$cookie_key] = $cookie_value;
 49 |     }
 50 |     $headers[$key] = $value;
 51 |   }
 52 |   $length = intval($headers['Content-Length']);
 53 |   $response = '';
 54 |   while (strlen($response) < $length) {
 55 |     $piece = fread($sock, $length - strlen($response));
 56 |     if ($piece === FALSE) {
 57 |       error_log('Not enough contents');
 58 |       return FALSE;
 59 |     }
 60 |     $response .= $piece;
 61 |   }
 62 |   return $response;
 63 | }
 64 | 
 65 | function CallApi($path, $params = []) {
 66 |   $data = http_build_query($params, '', '&');
 67 |   for ($i = 1; $i <= 4; $i++) {
 68 |     $response = CallApiInternal($path, $data);
 69 |     if ($response !== FALSE) break;
 70 |     error_log("Connection refused...");
 71 |     sleep($i * 0.1);
 72 |   }
 73 |   return $response;
 74 | }
 75 | 
 76 | function FetchAssoc($path, $params = []) {
 77 |   $data = json_decode(CallApi($path, $params), TRUE);
 78 |   $rows = [];
 79 |   for ($i = 1; $i < count($data); $i++) {
 80 |     $row = [];
 81 |     for ($j = 0; $j < count($data[$i]); $j++) {
 82 |       $row[$data[0][$j]] = $data[$i][$j];
 83 |     }
 84 |     $rows[] = $row;
 85 |   }
 86 |   return $rows;
 87 | }
 88 | 
 89 | function StoreSession() {
 90 |   $_COOKIE['session_data'] =
 91 |       rtrim(strtr(base64_encode(json_encode($_SESSION)), '+/', '-_'), '=');
 92 |   setcookie('session_data', $_COOKIE['session_data'], 0, '/');
 93 | }
 94 | 
 95 | function LoadSession() {
 96 |   $session = json_decode(base64_decode(
 97 |       strtr($_COOKIE['session_data'], '-_', '+/')), TRUE);
 98 |   $_SESSION = is_array($session) ? $session : [];
 99 | }
100 | 


--------------------------------------------------------------------------------
/nineserver/handler/system/info.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/handler/logging.h"
 2 | #include "nineserver/handler/system/system.h"
 3 | #include "nineserver/http/html.h"
 4 | #include "third_party/gflags/gflags.h"
 5 | 
 6 | bool InfoHandler(BaseHandler* handler) {
 7 |   SystemHandlerTemplate handler_template("Request Information", handler);
 8 |   handler_template.Header("Request Information");
 9 |   handler->Print(R"(<details><summary>Form</summary>)"_a);
10 |   handler->Print(R"(<form action="#" method="GET">GET: )"
11 |                  R"(<input type="text" name="name" value="value">)"
12 |                  R"(<input type="submit" value="Submit"></form>)");
13 |   handler->Print(R"(<form action="#" method="POST">POST: )"
14 |                  R"(<input type="text" name="name" value="value">)"
15 |                  R"(<input type="submit" value="Submit"></form>)");
16 |   handler->Print(R"(<form enctype="multipart/form-data" )"
17 |                  R"(action="#" method="POST">FILE: )"
18 |                  R"(<input type="file" name="name">)"
19 |                  R"(<input type="submit" value="Submit"></form>)");
20 |   handler->Print("</details>"_a);
21 |   handler->Print(R"(<h3>GET</h3><pre class="prettyprint lang-js">)"_a,
22 |                  EscapeHtml(JsonEncode(handler->GET(), true)), "</pre>"_a);
23 |   handler->Print(R"(<h3>POST</h3><pre class="prettyprint lang-js">)"_a,
24 |                  EscapeHtml(JsonEncode(handler->POST(), true)), "</pre>"_a);
25 |   handler->Print(R"(<h3>ENV</h3><pre class="prettyprint lang-js">)"_a,
26 |                  EscapeHtml(JsonEncode(handler->ENV(), true)), "</pre>"_a);
27 |   handler->Print(R"(<h3>FILE</h3><pre class="prettyprint lang-js">)"_a,
28 |                  EscapeHtml(JsonEncode(handler->FILE(), true)), "</pre>"_a);
29 |   handler->Print(R"(<h3>COOKIE</h3><pre class="prettyprint lang-js">)"_a,
30 |                  EscapeHtml(JsonEncode(handler->COOKIE(), true)), "</pre>"_a);
31 |   handler->Print(R"(<h3>SESSION</h3><pre class="prettyprint lang-js">)"_a,
32 |                  EscapeHtml(JsonEncode(handler->SESSION(), true)), "</pre>"_a);
33 |   handler->Print(R"(<h3>Request</h3><pre class="prettyprint lang-js">)"_a,
34 |                  EscapeHtml(JsonEncode(*handler->MutableRequest(), true)),
35 |                  "</pre>"_a);
36 |   handler->Print(R"(<h3>Response</h3><pre class="prettyprint lang-js">)"_a,
37 |                  EscapeHtml(JsonEncode(*handler->MutableResponse(), true)),
38 |                  "</pre>"_a);
39 | 
40 |   vector<google::CommandLineFlagInfo> flags;
41 |   google::GetAllFlags(&flags);
42 |   handler->Print(R"(<h3>Flags</h3><ul>)");
43 |   for (const auto& flag : flags) {
44 |     if (HasPrefixString(flag.filename, "external/")) continue;
45 |     handler->Print("<li>--", EscapeHtml(flag.name), "="_a,
46 |                    flag.current_value != flag.default_value
47 |                       ? "<b>" + EscapeHtml(flag.current_value) + "</b>"
48 |                       : EscapeHtml(flag.current_value),
49 |                    " <span style=\"color:#888\">("_a,
50 |                    EscapeHtml(flag.filename),
51 |                    ")</span><blockquote>"_a,
52 |                    EscapeHtml(flag.description), "</blockquote></li>"_a);
53 |   }
54 |   handler->Print("</ul>");
55 | 
56 |   return true;
57 | }
58 | REGISTER_HANDLER(InfoHandler, SYSTEM_HANDLER_PREFIX "/$", InfoHandler);
59 | 


--------------------------------------------------------------------------------
/nineserver/http/http_parameters.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/http/http_parameters.h"
 2 | 
 3 | DEFINE_int32(http_parameters_binary_search_threshold, 20,
 4 |              "Minimum number of elements to binary-search.");
 5 | 
 6 | void HttpParameters::Add(ArenaStringPiece key, ArenaStringPiece value) {
 7 |   DCHECK(!key.empty() || !value.empty());
 8 |   if (is_sorted_ && !parameters_.empty() && parameters_.back().first > key) {
 9 |     is_sorted_ = false;
10 |   }
11 |   parameters_.emplace_back(key, value);
12 | }
13 | 
14 | void HttpParameters::Set(ArenaStringPiece key, ArenaStringPiece value) {
15 |   DCHECK(!key.empty() || !value.empty());
16 |   bool found = false;
17 |   for (auto& key_and_value : parameters_) {
18 |     if (key_and_value.first == key) {
19 |       if (found) {
20 |         key_and_value.first = ""_a;
21 |         key_and_value.second = ""_a;
22 |         is_sorted_ = false;
23 |       } else {
24 |         key_and_value.second = value;
25 |         found = true;
26 |       }
27 |     }
28 |   }
29 |   if (!found) {
30 |     Add(key, value);
31 |   }
32 | }
33 | 
34 | void HttpParameters::Remove(StringPiece key) {
35 |   for (auto& key_and_value : parameters_) {
36 |     if (key_and_value.first == key) {
37 |       key_and_value.first = "";
38 |       key_and_value.second = "";
39 |       is_sorted_ = false;
40 |     }
41 |   }
42 | }
43 | 
44 | ArenaStringPiece HttpParameters::Get(
45 |     StringPiece key, ArenaStringPiece default_value) const {
46 |   if (is_sorted_ &&
47 |       FLAGS_http_parameters_binary_search_threshold < parameters_.size()) {
48 |     auto lower = key.empty() ? parameters_.begin() : std::lower_bound(
49 |         parameters_.begin(), parameters_.end(),
50 |         pair<StringPiece, StringPiece>(key, ""_a));
51 |     if (lower != parameters_.end() && lower->first == key) {
52 |       return ArenaStringPiece(lower->second);
53 |     }
54 |     return default_value;
55 |   }
56 |   for (const auto& key_and_value : parameters_) {
57 |     if (key_and_value.first == key) {
58 |       if (key.empty() && key_and_value.second.empty()) continue;
59 |       return ArenaStringPiece(key_and_value.second);
60 |     }
61 |   }
62 |   return default_value;
63 | }
64 | 
65 | void HttpParameters::Clear() {
66 |   InitializeVectorWithCapacity(&parameters_, 0, 64);
67 |   is_sorted_ = true;
68 | }
69 | 
70 | void HttpParameters::Sort() {
71 |   if (is_sorted_) {
72 |     return;
73 |   }
74 |   std::stable_sort(
75 |       parameters_.begin(), parameters_.end(),
76 |       [](const pair<StringPiece, StringPiece>& lhs,
77 |          const pair<StringPiece, StringPiece>& rhs) {
78 |         if (lhs.first.empty() && lhs.second.empty()) { return false; }
79 |         if (rhs.first.empty() && rhs.second.empty()) { return true; }
80 |         return lhs.first < rhs.first;
81 |       });
82 |   while (parameters_.back().first.empty() &&
83 |          parameters_.back().second.empty()) {
84 |     parameters_.resize(parameters_.size() - 1);
85 |   }
86 |   is_sorted_ = true;
87 | }
88 | 
89 | bool HttpParameters::IsSorted() const { return is_sorted_; }
90 | 
91 | Json HttpParameters::ToJson() const {
92 |   map<string, vector<string>> parameters;
93 |   for (const auto& key_and_value : parameters_) {
94 |     parameters[key_and_value.first.ToString()].push_back(
95 |         key_and_value.second.ToString());
96 |   }
97 |   return parameters;
98 | }
99 | 


--------------------------------------------------------------------------------
/nineserver/http/stream/http_stream.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <map>
 3 | #include <string>
 4 | 
 5 | #include "base/base.h"
 6 | #include "nineserver/arena/arena.h"
 7 | #include "nineserver/http/http_contents.h"
 8 | #include "nineserver/http/http_parameters.h"
 9 | #include "nineserver/http/url.h"
10 | 
11 | // 共通HTTP入出力ストリーム．
12 | class Stream {
13 |  public:
14 |   static const ArenaStringPiece kHttpOk;
15 |   static const ArenaStringPiece kHttpBadRequest;
16 | 
17 |   Stream() {}
18 |   virtual ~Stream() {
19 |     CHECK(is_destroyed_) << "Destroy must be called before destructing the "
20 |                          << "stream to avoid 'pure virtual function call'.";
21 |   }
22 | 
23 |   virtual bool Init();
24 | 
25 |   // Initialize Stream object for a request.
26 |   bool Start();
27 |   void Finish();
28 | 
29 |   // This may release the current IO to the pool.  The released IO should be
30 |   // handled by Init in the future.
31 |   virtual bool MayRelease() { return false; }
32 | 
33 |   // Finish the current response.  The stream must not be resused after Destroy.
34 |   virtual void Destroy();
35 |   bool IsDestroyed() const;
36 | 
37 |   virtual bool Read();
38 |   virtual void Flush() {};
39 |   virtual const GenericIO& GetIO() const = 0;
40 |   virtual GenericIO* MutableIO() = 0;
41 | 
42 |   void SetKeepAlive(bool allow_keep_alive = true)
43 |       { allow_keep_alive_ = allow_keep_alive; }
44 |   bool GetKeepAlive() const { return allow_keep_alive_; }
45 |   // Returns true if the current request can keep alive.
46 |   virtual bool CanKeepAlive() const;
47 | 
48 |   const HttpParameters& GetQueryParameters() const { return get_parameters_; }
49 |   const HttpParameters& GetPostParameters() const { return post_parameters_; }
50 |   const HttpParameters& GetCookieParameters() const
51 |       { return cookie_parameters_; }
52 |   const map<StringPiece, std::unique_ptr<HttpParameters>>&
53 |       GetFileParameters() const { return file_parameters_; }
54 |   const Json& GetSessionParameters() const { return session_parameters_; }
55 |   Json* MutableSessionParameters() { return &session_parameters_; }
56 | 
57 |   const HttpContents& GetRequest() const { return request_; }
58 |   inline HttpContents* MutableRequest() { return &request_; }
59 |   inline HttpContents* MutableResponse() { return &response_; }
60 | 
61 |   Arena* MutableArena() { return &arena_; }
62 | 
63 |   Json ToJson() const;
64 | 
65 |   string DebugString() const;
66 | 
67 |  protected:
68 |   // Fills parameters based on server parameters and data.
69 |   bool ParseParameters();
70 | 
71 |  protected:
72 |   static const string* kEmptyString;
73 | 
74 |   // Whether to allow keep-alive.
75 |   bool allow_keep_alive_ = false;
76 |   // Whether the Stream is started and not finished.
77 |   bool is_started_ = false;
78 |   // Whether the Stream is destroyed and Init must be called.
79 |   bool is_destroyed_ = true;
80 | 
81 |   // Following parameters depend on a request, and they must be cleared in
82 |   // Start.
83 |   Arena arena_;
84 |   HttpContents request_;
85 |   HttpContents response_;
86 |   HttpParameters get_parameters_;
87 |   HttpParameters post_parameters_;
88 |   HttpParameters cookie_parameters_;
89 |   Json session_parameters_;
90 |   map<StringPiece, std::unique_ptr<HttpParameters>> file_parameters_;
91 | 
92 |  private:
93 |   void Clear();
94 | 
95 |   DISALLOW_COPY_AND_ASSIGN(Stream);
96 | };
97 | 


--------------------------------------------------------------------------------
/nineserver/sql/mysql_test.cc:
--------------------------------------------------------------------------------
 1 | #include "base/testing.h"
 2 | #include "nineserver/json.h"
 3 | #include "nineserver/sql/mysql.h"
 4 | 
 5 | using testing::ElementsAre;
 6 | 
 7 | class MySQLTest : public testing::Test {
 8 |  public:
 9 |   MySQLTest() {
10 |     result_.num_rows = 2;
11 |     result_.num_fields = 3;
12 |     result_.data.reset(new ArenaStringPiece[9]);
13 |     result_.data[0] = "field1"_a;
14 |     result_.data[1] = "field2"_a;
15 |     result_.data[2] = "field3"_a;
16 |     result_.data[3] = "value1"_a;
17 |     result_.data[4] = "value2"_a;
18 |     result_.data[5] = "value3"_a;
19 |     result_.data[6] = "0"_a;
20 |     result_.data[7] = ""_a;
21 |     result_.data[8] = QueryResult::Null();
22 |   }
23 | 
24 |   QueryResult result_;
25 | };
26 | 
27 | TEST_F(MySQLTest, QueryResult) {
28 |   EXPECT_EQ("field1", result_.Field(0));
29 |   EXPECT_EQ("field2", result_.Field(1));
30 |   EXPECT_EQ("field3", result_.Field(2));
31 |   EXPECT_EQ("value1", result_.Get(0, 0));
32 |   EXPECT_EQ("value2", result_.Get(0, 1));
33 |   EXPECT_EQ("value3", result_.Get(0, 2));
34 |   EXPECT_EQ("0", result_.Get(1, 0));
35 |   EXPECT_EQ("", result_.Get(1, 1));
36 |   EXPECT_EQ("", result_.Get(1, 2));
37 |   EXPECT_FALSE(QueryResult::IsNull(result_.Get(0, 0)));
38 |   EXPECT_FALSE(QueryResult::IsNull(result_.Get(0, 1)));
39 |   EXPECT_FALSE(QueryResult::IsNull(result_.Get(0, 2)));
40 |   EXPECT_FALSE(QueryResult::IsNull(result_.Get(1, 0)));
41 |   EXPECT_FALSE(QueryResult::IsNull(result_.Get(1, 1)));
42 |   EXPECT_TRUE(QueryResult::IsNull(result_.Get(1, 2)));
43 | 
44 |   EXPECT_EQ(2, result_.size());
45 |   EXPECT_EQ(3, result_[0].size());
46 |   EXPECT_EQ("value1", result_[0][0]);
47 |   EXPECT_TRUE(QueryResult::IsNull(result_[1][2]));
48 | }
49 | 
50 | TEST_F(MySQLTest, QueryResult_ToJson) {
51 |   EXPECT_EQ(
52 |       R"([["field1","field2","field3"],)"
53 |       R"(["value1","value2","value3"],)"
54 |       R"(["0","",null]])",
55 |       JsonEncode(result_));
56 | }
57 | 
58 | TEST_F(MySQLTest, QueryResult_ForEach) {
59 |   vector<vector<ArenaStringPiece>> table;
60 |   for (const auto& result_row : result_) {
61 |     vector<ArenaStringPiece> row;
62 |     for (const auto& result_cell : result_row) {
63 |       row.push_back(result_cell);
64 |     }
65 |     table.push_back(std::move(row));
66 |   }
67 |   EXPECT_THAT(table,
68 |               ElementsAre(
69 |                   ElementsAre("value1"_a, "value2"_a, "value3"_a),
70 |                   ElementsAre("0"_a, ""_a, ""_a)));
71 | }
72 | 
73 | TEST_F(MySQLTest, ToSqlTimestamp) {
74 |   setenv("TZ", "Asia/Tokyo", 1);
75 |   tzset();
76 |   EXPECT_EQ("2016-01-02 03:04:05", ToSqlTimestamp(1451671445));
77 |   EXPECT_EQ("2016-11-22 01:23:45", ToSqlTimestamp(1479745425));
78 |   EXPECT_EQ("1970-01-01 09:00:00", ToSqlTimestamp(0));
79 |   EXPECT_EQ("0000-00-00 00:00:00", ToSqlTimestamp(-1));
80 | }
81 | 
82 | TEST_F(MySQLTest, FromSqlTimestamp) {
83 |   setenv("TZ", "Asia/Tokyo", 1);
84 |   tzset();
85 |   EXPECT_EQ(1451671445, FromSqlTimestamp("2016-01-02 03:04:05"));
86 |   EXPECT_EQ(1479745425, FromSqlTimestamp("2016-11-22 01:23:45"));
87 |   EXPECT_EQ(0, FromSqlTimestamp("1970-01-01 09:00:00"));
88 |   EXPECT_EQ(-1, FromSqlTimestamp("0000-00-00 00:00:00"));
89 | 
90 |   // Invalid format.
91 |   EXPECT_EQ(-1, FromSqlTimestamp("2016-01-02"));
92 |   EXPECT_EQ(-1, FromSqlTimestamp("2016-01-02 03:04"));
93 |   EXPECT_EQ(-1, FromSqlTimestamp("2016/01/02 03:04:05"));
94 | }
95 | 


--------------------------------------------------------------------------------
/nineserver/handler/system/system.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/handler/system/system.h"
 2 | 
 3 | SystemHandlerTemplate::SystemHandlerTemplate(
 4 |     StringPiece title, BaseHandler* handler)
 5 |     : handler_(handler) {
 6 |   handler->Print(
 7 |       R"(<!DOCTYPE html>)"
 8 |       R"(<html lang="en">)"
 9 |       R"(  <head>)"
10 |       R"(    <meta charset="utf-8">)"
11 |       R"(    <meta name="viewport" content="width=device-width, initial-scale=1">)"
12 |       R"(    <meta name="description" content="">)"
13 |       R"(    <meta name="author" content="">)"
14 |       R"(    <title>)",
15 |       title.ToString(),
16 |       R"(</title>)"
17 |       R"(    <link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">)"
18 |       R"(    <link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap-theme.min.css" rel="stylesheet">)"
19 |       R"(    <style>pre { white-space: pre-wrap; word-wrap: break-word; }</style>)"
20 |       R"(  </head>)"
21 |       R"(  <body style="padding-top:70px;padding-bottom:30px">)"_a);
22 | 
23 |   const vector<pair<string, string>> links = {
24 |       {"Info", "/_/"},
25 |       {"Stats", "/_/stats"},
26 |       {"DB Status", "/_/db"},
27 |       {"Session", "/_/session"},
28 |   };
29 | 
30 |   handler->Print(
31 |       R"(    <nav class="navbar navbar-inverse navbar-fixed-top">)"
32 |       R"(      <div class="container">)"
33 |       R"(        <div class="navbar-header">)"
34 |       R"(          <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">)"
35 |       R"(            <span class="sr-only">Toggle navigation</span>)"
36 |       R"(            <span class="icon-bar"></span>)"
37 |       R"(            <span class="icon-bar"></span>)"
38 |       R"(            <span class="icon-bar"></span>)"
39 |       R"(          </button>)"
40 |       R"(          <a class="navbar-brand" href="/_/">Nineserver</a>)"
41 |       R"(        </div>)"
42 |       R"(        <div id="navbar" class="navbar-collapse collapse">)"
43 |       R"(          <ul class="nav navbar-nav">)"_a);
44 | 
45 |   StringPiece script_name = handler->ENV("SCRIPT_NAME");
46 |   for (const auto& link : links) {
47 |     handler->Print(
48 |         link.second == script_name ? R"(<li class="active">)"_a : "<li>"_a);
49 |     handler->Print("<a href=\""_a, string(link.second), "\">"_a,
50 |                    string(link.first), "</a></li>"_a);
51 |   }
52 | 
53 |   handler->Print(
54 |       R"(                </ul>)"
55 |       R"(              </li>)"
56 |       R"(            </ul>)"
57 |       R"(          </div><!--/.nav-collapse -->)"
58 |       R"(        </div>)"
59 |       R"(      </nav>)"
60 |       R"(<div class="container theme-showcase" role="main">)"_a);
61 | }
62 | 
63 | SystemHandlerTemplate::~SystemHandlerTemplate() {
64 |   handler_->Print(
65 |       R"(</div>)"
66 |       R"(    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>)"
67 |       R"(    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>)"
68 |       R"(    <script src="https://cdn.rawgit.com/google/code-prettify/master/loader/run_prettify.js"></script>)"
69 |       R"(  </body>)"
70 |       R"(</html>)"
71 |   );
72 | }
73 | 
74 | void SystemHandlerTemplate::Header(StringPiece title) {
75 |   handler_->Print(
76 |       R"(<div class="page-header"><h2>)"_a, title.ToString(), "</h2></div>"_a);
77 | }
78 | 


--------------------------------------------------------------------------------
/nineserver/http/session.cc:
--------------------------------------------------------------------------------
 1 | #include "nineserver/http/session.h"
 2 | 
 3 | #include <memory>
 4 | #include <functional>
 5 | 
 6 | #include "base/base.h"
 7 | 
 8 | DEFINE_int32(num_sessions, 10000, "# of sessions to accept.");
 9 | 
10 | vector<Session::Deleter>* Session::deleters_ = nullptr;
11 | std::mutex Session::deleters_mutex_;
12 | 
13 | namespace {
14 | 
15 | class SessionPool {
16 |  public:
17 |   SessionPool() {}
18 | 
19 |   static SessionPool* GetSessionPool() {
20 |     static SessionPool* pool = new SessionPool();
21 |     return pool;
22 |   }
23 | 
24 |   void Compact() {
25 |     if (sessions_.size() < FLAGS_num_sessions * 2) { return; }
26 |     vector<pair<pair<bool, int64>, std::shared_ptr<Session>>> sessions;
27 |     sessions.reserve(sessions_.size());
28 |     for (const auto& key_and_session : sessions_) {
29 |       std::shared_ptr<Session> session = key_and_session.second;
30 |       auto session_guard = session->Lock();
31 |       sessions.emplace_back(
32 |           make_pair<bool, int64>(!session->Empty(), session->session_access()),
33 |           std::move(session));
34 |     }
35 |     sort(sessions.rbegin(), sessions.rend());
36 |     if (sessions.size() > FLAGS_num_sessions) {
37 |       sessions.resize(FLAGS_num_sessions);
38 |     }
39 |     sessions_.clear();
40 |     for (const auto& access_and_session : sessions) {
41 |       std::shared_ptr<Session> session = access_and_session.second;
42 |       sessions_.emplace(session->session_key(), std::move(session));
43 |     }
44 |   }
45 | 
46 |   std::shared_ptr<Session> Get(StringPiece session_key, bool add_session) {
47 |     std::lock_guard<std::mutex> sessions_guard_(sessions_lock_);
48 |     std::shared_ptr<Session>* session = FindOrNull(sessions_, session_key);
49 |     if (session != nullptr) { return *session; }
50 |     if (!add_session) { return nullptr; }
51 |     Compact();
52 |     std::shared_ptr<Session> new_session(new Session(session_key));
53 |     sessions_.emplace(new_session->session_key(), new_session);
54 |     return new_session;
55 |   }
56 | 
57 |   bool Set(std::shared_ptr<Session> session) {
58 |     std::lock_guard<std::mutex> sessions_guard_(sessions_lock_);
59 |     std::shared_ptr<Session>* current_session =
60 |       FindOrNull(sessions_, session->session_key());
61 |     if (current_session != nullptr && *current_session == session) {
62 |       return false;
63 |     }
64 |     sessions_[session->session_key()] = session;
65 |     return true;
66 |   }
67 | 
68 |   int Remove(StringPiece session_key) {
69 |     std::lock_guard<std::mutex> sessions_guard_(sessions_lock_);
70 |     return sessions_.erase(session_key);
71 |   }
72 | 
73 |  private:
74 |   map<StringPiece, std::shared_ptr<Session>> sessions_;
75 |   std::mutex sessions_lock_;
76 | };
77 | 
78 | }  // namespace
79 | 
80 | std::shared_ptr<Session> GetSession(StringPiece session_key) {
81 |   std::shared_ptr<Session> session =
82 |       SessionPool::GetSessionPool()->Get(session_key, true);
83 |   // Prevent acquiring a locked session.
84 |   auto lock = session->Lock();
85 |   return session;
86 | }
87 | 
88 | bool SetSession(std::shared_ptr<Session> session) {
89 |   return SessionPool::GetSessionPool()->Set(session);
90 | }
91 | 
92 | bool RemoveSession(StringPiece session_key) {
93 |   std::shared_ptr<Session> session =
94 |       SessionPool::GetSessionPool()->Get(session_key, false);
95 |   if (session == nullptr) { return false; }
96 |   auto lock = session->Lock();
97 |   return SessionPool::GetSessionPool()->Remove(session_key) > 0;
98 | }
99 | 


--------------------------------------------------------------------------------
/nineserver/http/BUILD:
--------------------------------------------------------------------------------
  1 | licenses(["notice"])
  2 | 
  3 | package(default_visibility = ["//visibility:public"])
  4 | 
  5 | cc_library(
  6 |     name = "html",
  7 |     srcs = ["html.cc"],
  8 |     hdrs = ["html.h"],
  9 |     deps = [
 10 |         "//external:base",
 11 |     ],
 12 | )
 13 | 
 14 | cc_test(
 15 |     name = "html_test",
 16 |     srcs = ["html_test.cc"],
 17 |     deps = [
 18 |         ":html",
 19 |         "//external:testing_main",
 20 |     ],
 21 | )
 22 | 
 23 | cc_library(
 24 |     name = "http_contents",
 25 |     srcs = ["http_contents.cc"],
 26 |     hdrs = ["http_contents.h"],
 27 |     deps = [
 28 |         ":http_parameters",
 29 |         "//external:base",
 30 |         "//nineserver/arena",
 31 |         "//nineserver/arena:arena_interface",
 32 |         "//nineserver/io:generic_io",
 33 |         "//nineserver:common",
 34 |         "//nineserver:json",
 35 |     ],
 36 | )
 37 | 
 38 | cc_test(
 39 |     name = "http_contents_test",
 40 |     srcs = ["http_contents_test.cc"],
 41 |     deps = [
 42 |         ":http_contents",
 43 |         "//external:testing_main",
 44 |         "//nineserver/benchmark",
 45 |         "//nineserver/io:string_io",
 46 |     ],
 47 |     tags = ["benchmark"],
 48 | )
 49 | 
 50 | cc_library(
 51 |     name = "http_parameters",
 52 |     srcs = ["http_parameters.cc"],
 53 |     hdrs = ["http_parameters.h"],
 54 |     deps = [
 55 |         "//external:base",
 56 |         "//nineserver/io:generic_io",
 57 |         "//nineserver/arena",
 58 |         "//nineserver:common",
 59 |         "//nineserver:json",
 60 |     ],
 61 | )
 62 | 
 63 | cc_test(
 64 |     name = "http_parameters_test",
 65 |     srcs = ["http_parameters_test.cc"],
 66 |     deps = [
 67 |         ":http_parameters",
 68 |         "//external:testing_main",
 69 |         "//nineserver/benchmark",
 70 |     ],
 71 |     tags = ["benchmark"],
 72 | )
 73 | 
 74 | cc_library(
 75 |     name = "proxy",
 76 |     srcs = ["proxy.cc"],
 77 |     hdrs = ["proxy.h"],
 78 |     deps = [
 79 |         ":http_contents",
 80 |         "//external:base",
 81 |         "//nineserver/io:descriptor_io",
 82 |         "//nineserver:common",
 83 |     ],
 84 | )
 85 | 
 86 | cc_binary(
 87 |     name = "proxy_main",
 88 |     srcs = ["proxy_main.cc"],
 89 |     deps = [
 90 |         ":proxy",
 91 |         ":http_contents",
 92 |         "//external:base",
 93 |         "//nineserver/arena",
 94 |         "//nineserver/io:descriptor_io",
 95 |         "//nineserver:common",
 96 |     ],
 97 | )
 98 | 
 99 | cc_library(
100 |     name = "session",
101 |     srcs = ["session.cc"],
102 |     hdrs = ["session.h"],
103 |     deps = [
104 |         "//external:base",
105 |     ],
106 | )
107 | 
108 | cc_test(
109 |     name = "session_test",
110 |     srcs = ["session_test.cc"],
111 |     deps = [
112 |         ":session",
113 |         "//external:testing_main",
114 |         "//nineserver:common",
115 |     ],
116 | )
117 | 
118 | cc_library(
119 |     name = "url",
120 |     srcs = ["url.cc"],
121 |     hdrs = ["url.h"],
122 |     deps = [
123 |         "//external:base",
124 |         "//nineserver/arena:arena_buffer",
125 |     ],
126 | )
127 | 
128 | cc_library(
129 |     name = "util",
130 |     srcs = ["util.cc"],
131 |     hdrs = ["util.h"],
132 |     deps = [
133 |         "//external:base",
134 |         "//nineserver/arena:arena_string_piece",
135 |         "@cctz//:time_zone",
136 |     ],
137 | )
138 | 
139 | cc_test(
140 |     name = "util_test",
141 |     srcs = ["util_test.cc"],
142 |     deps = [
143 |         ":util",
144 |         "//external:testing_main",
145 |     ],
146 | )
147 | 


--------------------------------------------------------------------------------
/nineserver/http/session.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <functional>
  3 | #include <memory>
  4 | #include <mutex>
  5 | 
  6 | #include "base/base.h"
  7 | 
  8 | class Session {
  9 |  public:
 10 |   Session(StringPiece session_key) : session_key_(session_key.ToString())
 11 |       { Touch(); }
 12 |   Session() : Session(StringPiece("", 0)) {}
 13 |   ~Session() { Clear(); }
 14 | 
 15 |   const string& session_key() const { return session_key_; }
 16 |   int64 session_access() const {
 17 |     std::lock_guard<std::mutex> access_guard(access_mutex_);
 18 |     return access_;
 19 |   }
 20 | 
 21 |   template<typename T>
 22 |   const T* GetOrNull() const {
 23 |     TypeId type_id = GetTypeId<T>();
 24 |     std::lock_guard<std::mutex> data_guard(data_mutex_);
 25 |     return type_id < data_.size() ? static_cast<T*>(data_[type_id]) : nullptr;
 26 |   }
 27 | 
 28 |   template<typename T>
 29 |   const T& Get() const {
 30 |     static T kEmpty = T();
 31 |     const T* value = GetOrNull<T>();
 32 |     return value == nullptr ? kEmpty : *value;
 33 |   }
 34 | 
 35 |   template<typename T>
 36 |   T* Mutable() {
 37 |     TypeId type_id = GetTypeId<T>();
 38 |     std::lock_guard<std::mutex> data_guard(data_mutex_);
 39 |     if (type_id >= data_.size()) {
 40 |       data_.resize(type_id + 1, nullptr);
 41 |     }
 42 |     if (data_[type_id] == nullptr) {
 43 |       data_[type_id] = new T();
 44 |     }
 45 |     return static_cast<T*>(data_[type_id]);
 46 |   }
 47 | 
 48 |   template<typename T>
 49 |   void Set(std::unique_ptr<T> value) {
 50 |     TypeId type_id = GetTypeId<T>();
 51 |     std::lock_guard<std::mutex> data_guard(data_mutex_);
 52 |     data_.resize(type_id + 1, nullptr);
 53 |     data_[type_id] = value.release();
 54 |   }
 55 | 
 56 |   std::unique_lock<std::mutex> Lock() const {
 57 |     Touch();
 58 |     return std::unique_lock<std::mutex>(mutex_);
 59 |   }
 60 | 
 61 |   void Clear() {
 62 |     vector<void*> old_data;
 63 |     {
 64 |       std::lock_guard<std::mutex> data_guard(data_mutex_);
 65 |       old_data.swap(data_);
 66 |     }
 67 |     std::lock_guard<std::mutex> deleters_guard(deleters_mutex_);
 68 |     for (int i = 0; i < old_data.size(); i++) {
 69 |       (*deleters_)[i](old_data[i]);
 70 |     }
 71 |   }
 72 | 
 73 |   bool Empty() const {
 74 |     std::lock_guard<std::mutex> data_guard(data_mutex_);
 75 |     return data_.empty();
 76 |   }
 77 | 
 78 |   void Touch() const {
 79 |     static int64 access_id = 1;
 80 |     static std::mutex access_id_mutex;
 81 |     int new_access_id;
 82 |     {
 83 |       std::lock_guard<std::mutex> access_id_guard(access_id_mutex);
 84 |       new_access_id = access_id;
 85 |     }
 86 |     {
 87 |       std::lock_guard<std::mutex> access_guard(access_mutex_);
 88 |       access_ = new_access_id;
 89 |     }
 90 |   }
 91 | 
 92 |  private:
 93 |   typedef int TypeId;
 94 |   typedef std::function<void(void*)> Deleter;
 95 | 
 96 |   static TypeId IncrementTypeId(const Deleter& deleter) {
 97 |     std::lock_guard<std::mutex> deleters_guard(deleters_mutex_);
 98 |     if (deleters_ == nullptr) {
 99 |       deleters_ = new vector<Deleter>();
100 |     }
101 |     deleters_->push_back(deleter);
102 |     return deleters_->size() - 1;
103 |   }
104 | 
105 |   template<typename T>
106 |   static TypeId GetTypeId() {
107 |     static TypeId type_id = IncrementTypeId(
108 |         [](void* ptr) { delete static_cast<T*>(ptr); });
109 |     return type_id;
110 |   }
111 | 
112 |   string session_key_;
113 |   mutable int64 access_ = 0;
114 |   mutable std::mutex access_mutex_;
115 |   vector<void*> data_;
116 |   mutable std::mutex data_mutex_;
117 |   mutable std::mutex mutex_;
118 |   static vector<Deleter>* deleters_;
119 |   static std::mutex deleters_mutex_;
120 | };
121 | 
122 | std::shared_ptr<Session> GetSession(StringPiece session_key);
123 | bool SetSession(std::shared_ptr<Session> session);
124 | bool RemoveSession(StringPiece session_key);
125 | 


--------------------------------------------------------------------------------
/nineserver/sql/mysql.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <stdio.h>
  3 | #include <stdlib.h>
  4 | #include <mysql/mysql.h>
  5 | 
  6 | #include <memory>
  7 | 
  8 | #include "base/base.h"
  9 | #include "nineserver/arena/arena_buffer.h"
 10 | #include "nineserver/json.h"
 11 | 
 12 | string ToSqlTimestamp(time_t time);
 13 | time_t FromSqlTimestamp(StringPiece sql_timestamp);
 14 | 
 15 | struct QueryResult {
 16 |   int32 num_rows = 0;
 17 |   int32 num_fields = 0;
 18 |   std::unique_ptr<ArenaStringPiece[]> data;
 19 |   std::unique_ptr<ArenaBuffer> arena_buffer;
 20 | 
 21 |   struct CellIterator {
 22 |     const QueryResult* result = nullptr;
 23 |     int64 row_index = 0;
 24 |     int64 cell_index = 0;
 25 | 
 26 |     ArenaStringPiece operator*() { return result->Get(row_index, cell_index); }
 27 |     CellIterator& operator++() { cell_index++; return *this; }
 28 |     CellIterator& operator++(int) { return ++*this; }
 29 |     bool operator==(const CellIterator& rhs) const {
 30 |       return result == rhs.result && row_index == rhs.row_index &&
 31 |              cell_index == rhs.cell_index;
 32 |     }
 33 |     bool operator!=(const CellIterator& rhs) const { return !(*this == rhs); }
 34 |   };
 35 | 
 36 |   struct RowIterator {
 37 |     const QueryResult* result = nullptr;
 38 |     int64 row_index = 0;
 39 | 
 40 |     typedef CellIterator iterator;
 41 |     iterator begin() const {
 42 |       iterator it;
 43 |       it.result = result;
 44 |       it.row_index = row_index;
 45 |       it.cell_index = 0;
 46 |       return it;
 47 |     }
 48 | 
 49 |     iterator end() const {
 50 |       iterator it = begin();
 51 |       it.cell_index = result->num_fields;
 52 |       return it;
 53 |     }
 54 | 
 55 |     ArenaStringPiece operator[](int64 column_index) const {
 56 |       return result->Get(row_index, column_index);
 57 |     }
 58 | 
 59 |     size_t size() const { return result->num_fields; }
 60 | 
 61 |     RowIterator& operator*() { return *this; }
 62 | 
 63 |     RowIterator& operator++() { row_index++; return *this; }
 64 |     RowIterator& operator++(int) { return ++*this; }
 65 |     bool operator==(const RowIterator& rhs) const
 66 |         { return result == rhs.result && row_index == rhs.row_index; }
 67 |     bool operator!=(const RowIterator& rhs) const { return !(*this == rhs); }
 68 |   };
 69 | 
 70 |   typedef RowIterator iterator;
 71 | 
 72 |   iterator begin() const {
 73 |     iterator it;
 74 |     it.result = this;
 75 |     it.row_index = 0;
 76 |     return it;
 77 |   }
 78 | 
 79 |   iterator end() const {
 80 |     iterator it = begin();
 81 |     it.row_index = num_rows;
 82 |     return it;
 83 |   }
 84 | 
 85 |   RowIterator operator[](int64 row_index) const {
 86 |     iterator it = begin();
 87 |     it.row_index = row_index;
 88 |     return it;
 89 |   }
 90 | 
 91 |   size_t size() const { return num_rows; }
 92 | 
 93 |   inline ArenaStringPiece Field(int field_index) const {
 94 |     DCHECK_GE(field_index, 0);
 95 |     DCHECK_LT(field_index, num_fields);
 96 |     return data[field_index];
 97 |   }
 98 | 
 99 |   inline ArenaStringPiece Get(int row_index, int field_index) const {
100 |     DCHECK_GE(row_index, 0);
101 |     DCHECK_LT(row_index, num_rows);
102 |     DCHECK_GE(field_index, 0);
103 |     DCHECK_LT(field_index, num_fields);
104 |     return data[(row_index + 1) * num_fields + field_index];
105 |   }
106 | 
107 |   Json ToJson() const;
108 | 
109 |   static ArenaStringPiece Null();
110 |   static bool IsNull(StringPiece value);
111 | };
112 | 
113 | class MySQL {
114 |  public:
115 |   static MYSQL* Connect();
116 | 
117 |   static bool Command(StringPiece query);
118 | 
119 |   static QueryResult SelectAll(
120 |       StringPiece query, ArenaBuffer* arena_buffer = nullptr);
121 | 
122 |   static int64 GetAffectedRows();
123 |   static int64 GetInsertId();
124 | 
125 |   static bool Escape(StringPiece data, BufferInterface* buffer);
126 |   static string Escape(StringPiece data);
127 | 
128 |  private:
129 |   static MYSQL* Query(StringPiece query);
130 | };
131 | 


--------------------------------------------------------------------------------
/nineserver/io/descriptor_io.cc:
--------------------------------------------------------------------------------
  1 | #include "nineserver/io/descriptor_io.h"
  2 | 
  3 | #include <arpa/inet.h>
  4 | #include <assert.h>
  5 | #include <ctype.h>
  6 | #include <errno.h>
  7 | #include <functional>
  8 | #include <list>
  9 | #include <memory>
 10 | #include <mutex>
 11 | #include <netinet/in.h>
 12 | #include <netinet/tcp.h>
 13 | #include <pthread.h>
 14 | #include <signal.h>
 15 | #include <stdarg.h>
 16 | #include <sys/select.h>
 17 | #include <sys/socket.h>
 18 | #include <sys/uio.h>
 19 | #include <sys/un.h>
 20 | #include <thread>
 21 | #include <unistd.h>
 22 | #include <vector>
 23 | 
 24 | #include "base/base.h"
 25 | 
 26 | void DescriptorIO::InitDescriptorIO(StringPiece address) {
 27 |   if (address.starts_with("unix://")) {
 28 |     InitDescriptorIO(socket(AF_UNIX, SOCK_STREAM, 0));
 29 |     if (descriptor_ < 0) {
 30 |       LOG(ERROR) << "Failed to create a socket: " << strerror(errno);
 31 |       Destroy();
 32 |       return;
 33 |     }
 34 |     address.remove_prefix(strlen("unix://"));
 35 |     struct {
 36 |       sa_family_t sun_family;
 37 |       char sun_path[1000];
 38 |     } sockaddr;
 39 |     memset(&sockaddr, 0, sizeof(sockaddr));
 40 |     sockaddr.sun_family = AF_UNIX;
 41 |     CHECK_LT(address.size(), sizeof(sockaddr.sun_path));
 42 |     memcpy(sockaddr.sun_path, address.data(), address.size());
 43 |     sockaddr.sun_path[address.size()] = 0;
 44 |     if (connect(descriptor_, (struct sockaddr*)&sockaddr,
 45 |                 sizeof(sockaddr)) < 0) {
 46 |       LOG_FIRST_N(WARNING, 100)
 47 |           << "Failed to connect to: unix://" << sockaddr.sun_path
 48 |           << ": " << strerror(errno);
 49 |       Destroy();
 50 |       return;
 51 |     }
 52 |   } else if (address.starts_with("tcp://")) {
 53 |     InitDescriptorIO(socket(AF_INET, SOCK_STREAM, 0));
 54 |     if (descriptor_ < 0) {
 55 |       LOG(ERROR) << "Failed to create a socket: " << strerror(errno);
 56 |       Destroy();
 57 |       return;
 58 |     }
 59 |     address.remove_prefix(strlen("tcp://"));
 60 |     vector<StringPiece> parts =
 61 |         strings::Split(address, strings::delimiter::Limit(":", 1));
 62 |     int32 port;
 63 |     if (parts.size() != 2 ||
 64 |         !safe_strto32(parts[1].data(), parts[1].size(), &port)) {
 65 |       LOG(ERROR) << "Failed to parse: " << address;
 66 |       Destroy();
 67 |       return;
 68 |     }
 69 |     struct sockaddr_in sockaddr;
 70 |     memset(&sockaddr, 0, sizeof(sockaddr));
 71 |     sockaddr.sin_family = AF_INET;
 72 |     sockaddr.sin_port = htons(port);
 73 |     sockaddr.sin_addr.s_addr = inet_addr(parts[0].ToString().c_str());
 74 |     if (connect(descriptor_, (struct sockaddr*)&sockaddr,
 75 |                 sizeof(sockaddr)) < 0) {
 76 |       LOG_FIRST_N(WARNING, 100) << "Failed to connect to: tcp://" << address;
 77 |       Destroy();
 78 |       return;
 79 |     }
 80 |   } else {
 81 |     LOG(ERROR) << "Failed to parse address: " << address;
 82 |     Destroy();
 83 |   }
 84 | }
 85 | 
 86 | int DescriptorIO::ReadIO(char* buffer, int length) {
 87 |   if (descriptor_ < 0) { return -1; }
 88 |   return read(descriptor_, buffer, length);
 89 | }
 90 | 
 91 | bool DescriptorIO::WriteIO(const vector<StringPiece>& data) {
 92 |   if (IsDestroyed()) {
 93 |     return false;
 94 |   }
 95 | 
 96 |   write_pointers_.resize(data.size());
 97 |   int source_length = 0;
 98 |   for (int i = 0; i < data.size(); i++) {
 99 |     write_pointers_[i].iov_base =
100 |         static_cast<void*>(const_cast<char*>(data[i].data()));
101 |     write_pointers_[i].iov_len = data[i].size();
102 |     source_length += data[i].size();
103 |   }
104 |   
105 |   int length = writev(
106 |       descriptor_, write_pointers_.data(), write_pointers_.size());
107 |   if (length < 0) {
108 |     VLOG(1) << "Failed to write " << source_length << " bytes data: "
109 |                  << strerror(errno);
110 |     Destroy();
111 |     return false;
112 |   }
113 |   return true;
114 | }
115 | 
116 | void DescriptorIO::CloseIO() {
117 |   if (descriptor_ >= 0) {
118 |     DVLOG(5) << "DescriptorIO::CloseIO()";
119 |     close(descriptor_);
120 |     descriptor_ = -1;
121 |   }
122 | }
123 | 


--------------------------------------------------------------------------------
/nineserver/arena/arena_string_piece.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <functional>
  3 | #include <string>
  4 | #include <type_traits>
  5 | #include <vector>
  6 | 
  7 | #include "base/base.h"
  8 | #include "nineserver/common.h"
  9 | 
 10 | class ArenaStringPiece {
 11 |  public:
 12 |   ArenaStringPiece() {}
 13 |   ArenaStringPiece(const char* data, std::size_t length)
 14 |       : value_(data, length) {}
 15 |   ArenaStringPiece(const ArenaStringPiece& value) : value_(value.value_) {}
 16 |   ArenaStringPiece(ArenaStringPiece&& value) : value_(value.value_) {}
 17 |   // TODO(P2): Prepare a static function to convert for safety.
 18 |   explicit ArenaStringPiece(StringPiece value) : value_(value) {}
 19 |   ~ArenaStringPiece() noexcept {}
 20 | 
 21 |   inline ArenaStringPiece operator=(ArenaStringPiece value) {
 22 |     value_ = value.value_;
 23 |     return *this;
 24 |   }
 25 | 
 26 |   inline operator StringPiece() const { return value_; }
 27 |   inline StringPiece ToStringPiece() const { return value_; }
 28 |   inline string ToString() const { return value_.ToString(); }
 29 | 
 30 |   inline bool empty() const { return value_.empty(); }
 31 |   inline const char* data() const { return value_.data(); }
 32 |   inline int64 size() const { return value_.size(); }
 33 | 
 34 |   inline ArenaStringPiece substr(
 35 |       int64 position, int64 length = StringPiece::npos) const {
 36 |     return ArenaStringPiece(value_.substr(position, length));
 37 |   }
 38 |   inline void remove_suffix(int64 length) { value_.remove_suffix(length); }
 39 |   inline void remove_prefix(int64 length) { value_.remove_prefix(length); }
 40 | 
 41 |   inline bool operator!=(StringPiece rhs) const { return value_ != rhs; }
 42 |   inline bool operator==(StringPiece rhs) const { return value_ == rhs; }
 43 |   inline bool operator<(StringPiece rhs) const { return value_ < rhs; }
 44 |   inline bool operator>(StringPiece rhs) const { return value_ > rhs; }
 45 |   inline bool operator<=(StringPiece rhs) const { return value_ <= rhs; }
 46 |   inline bool operator>=(StringPiece rhs) const { return value_ >= rhs; }
 47 | 
 48 |   StringPiece* MutableStringPiece() { return &value_; }
 49 | 
 50 |  private:
 51 |   StringPiece value_;
 52 | };
 53 | 
 54 | ArenaStringPiece operator"" _a(const char* str, std::size_t length);
 55 | 
 56 | template<typename Delimiter>
 57 | inline bool SplitToArenaStringPieces(
 58 |     ArenaStringPiece input, Delimiter delimiter,
 59 |     ArenaStringPiece* output1, ArenaStringPiece* output2) {
 60 |   return SplitToStringPieces(
 61 |       input, delimiter,
 62 |       output1 == nullptr ? nullptr : output1->MutableStringPiece(),
 63 |       output2 == nullptr ? nullptr : output2->MutableStringPiece());
 64 | }
 65 | 
 66 | template<typename Delimiter, typename... Args>
 67 | inline bool SplitToArenaStringPieces(
 68 |     ArenaStringPiece input, Delimiter delimiter,
 69 |     ArenaStringPiece* output1, ArenaStringPiece* output2,
 70 |     ArenaStringPiece* output3, Args*... args) {
 71 |   ArenaStringPiece trailing;
 72 |   if (!SplitToArenaStringPieces(input, delimiter, output1, &trailing)) {
 73 |     return false;
 74 |   }
 75 |   return SplitToArenaStringPieces(
 76 |       trailing, delimiter, output2, output3, args...);
 77 | }
 78 | 
 79 | template<typename Delimiter>
 80 | inline bool ReverseSplitToArenaStringPieces(
 81 |     ArenaStringPiece input, Delimiter delimiter,
 82 |     ArenaStringPiece* output1, ArenaStringPiece* output2) {
 83 |   return ReverseSplitToStringPieces(
 84 |       input, delimiter,
 85 |       output1 == nullptr ? nullptr : output1->MutableStringPiece(),
 86 |       output2 == nullptr ? nullptr : output2->MutableStringPiece());
 87 | }
 88 | 
 89 | template<typename Delimiter, typename... Args>
 90 | inline bool ReverseSplitToArenaStringPieces(
 91 |     ArenaStringPiece input, Delimiter delimiter,
 92 |     ArenaStringPiece* output1, ArenaStringPiece* output2,
 93 |     ArenaStringPiece* output3, Args*... args) {
 94 |   ArenaStringPiece leading;
 95 |   if (!ReverseSplitToStringPieces(input, delimiter, &leading, output1)) {
 96 |     return false;
 97 |   }
 98 |   return ReverseSplitToStringPieces(
 99 |       leading, delimiter, args..., output3, output2);
100 | }
101 | 


--------------------------------------------------------------------------------
/example/config/mime.types:
--------------------------------------------------------------------------------
 1 | types {
 2 |     text/html                             html htm shtml;
 3 |     text/css                              css;
 4 |     text/xml                              xml;
 5 |     image/gif                             gif;
 6 |     image/jpeg                            jpeg jpg;
 7 |     application/javascript                js;
 8 |     application/atom+xml                  atom;
 9 |     application/rss+xml                   rss;
10 | 
11 |     text/mathml                           mml;
12 |     text/plain                            txt;
13 |     text/vnd.sun.j2me.app-descriptor      jad;
14 |     text/vnd.wap.wml                      wml;
15 |     text/x-component                      htc;
16 | 
17 |     image/png                             png;
18 |     image/tiff                            tif tiff;
19 |     image/vnd.wap.wbmp                    wbmp;
20 |     image/x-icon                          ico;
21 |     image/x-jng                           jng;
22 |     image/x-ms-bmp                        bmp;
23 |     image/svg+xml                         svg svgz;
24 |     image/webp                            webp;
25 | 
26 |     application/font-woff                 woff;
27 |     application/java-archive              jar war ear;
28 |     application/json                      json;
29 |     application/mac-binhex40              hqx;
30 |     application/msword                    doc;
31 |     application/pdf                       pdf;
32 |     application/postscript                ps eps ai;
33 |     application/rtf                       rtf;
34 |     application/vnd.apple.mpegurl         m3u8;
35 |     application/vnd.ms-excel              xls;
36 |     application/vnd.ms-fontobject         eot;
37 |     application/vnd.ms-powerpoint         ppt;
38 |     application/vnd.wap.wmlc              wmlc;
39 |     application/vnd.google-earth.kml+xml  kml;
40 |     application/vnd.google-earth.kmz      kmz;
41 |     application/x-7z-compressed           7z;
42 |     application/x-cocoa                   cco;
43 |     application/x-java-archive-diff       jardiff;
44 |     application/x-java-jnlp-file          jnlp;
45 |     application/x-makeself                run;
46 |     application/x-perl                    pl pm;
47 |     application/x-pilot                   prc pdb;
48 |     application/x-rar-compressed          rar;
49 |     application/x-redhat-package-manager  rpm;
50 |     application/x-sea                     sea;
51 |     application/x-shockwave-flash         swf;
52 |     application/x-stuffit                 sit;
53 |     application/x-tcl                     tcl tk;
54 |     application/x-x509-ca-cert            der pem crt;
55 |     application/x-xpinstall               xpi;
56 |     application/xhtml+xml                 xhtml;
57 |     application/xspf+xml                  xspf;
58 |     application/zip                       zip;
59 | 
60 |     application/octet-stream              bin exe dll;
61 |     application/octet-stream              deb;
62 |     application/octet-stream              dmg;
63 |     application/octet-stream              iso img;
64 |     application/octet-stream              msi msp msm;
65 | 
66 |     application/vnd.openxmlformats-officedocument.wordprocessingml.document    docx;
67 |     application/vnd.openxmlformats-officedocument.spreadsheetml.sheet          xlsx;
68 |     application/vnd.openxmlformats-officedocument.presentationml.presentation  pptx;
69 | 
70 |     audio/midi                            mid midi kar;
71 |     audio/mpeg                            mp3;
72 |     audio/ogg                             ogg;
73 |     audio/x-m4a                           m4a;
74 |     audio/x-realaudio                     ra;
75 | 
76 |     video/3gpp                            3gpp 3gp;
77 |     video/mp2t                            ts;
78 |     video/mp4                             mp4;
79 |     video/mpeg                            mpeg mpg;
80 |     video/quicktime                       mov;
81 |     video/webm                            webm;
82 |     video/x-flv                           flv;
83 |     video/x-m4v                           m4v;
84 |     video/x-mng                           mng;
85 |     video/x-ms-asf                        asx asf;
86 |     video/x-ms-wmv                        wmv;
87 |     video/x-msvideo                       avi;
88 | }
89 | 


--------------------------------------------------------------------------------
/nineserver/http/http_contents.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <time.h>
  3 | #include <string>
  4 | #include <map>
  5 | #include <unordered_map>
  6 | 
  7 | #include "base/base.h"
  8 | #include "nineserver/arena/arena.h"
  9 | #include "nineserver/arena/arena_interface.h"
 10 | #include "nineserver/common.h"
 11 | #include "nineserver/io/generic_io.h"
 12 | #include "nineserver/json.h"
 13 | #include "nineserver/http/http_parameters.h"
 14 | 
 15 | class HttpContents : public ArenaInterface {
 16 |  public:
 17 |   // TODO(P2): Make this case insensitive.
 18 |   typedef map<StringPiece, vector<StringPiece>> Headers;
 19 | 
 20 |   const StringPiece kContentLengthHeader = StringPiece("Content-Length");
 21 |   const StringPiece kTransferEncodingHeader = StringPiece("Transfer-Encoding");
 22 | 
 23 |   HttpContents() : arena_(nullptr) {}
 24 |   ~HttpContents() {}
 25 | 
 26 |   // Initializes the object.
 27 |   void Init(Arena* arena);
 28 |   void Clear();
 29 | 
 30 |   bool ReadHeader(GenericIO* io);
 31 |   bool ReadContent(GenericIO* io);
 32 |   // ignore_content should be enabled for a reponse for HEAD.
 33 |   bool Read(GenericIO* io, bool ignore_content = false);
 34 | 
 35 |   bool Write(GenericIO* io, StringPiece hostname = "");
 36 | 
 37 |   // Appends a content.
 38 |   inline void Print() {}
 39 |   template<typename T, typename... Args>
 40 |   inline void Print(T&& content, Args&&... args) {
 41 |     if (DVLOG_IS_ON(15)) {
 42 |       LOG(INFO) << "HttpContents::Print(\"" << content << "\")";
 43 |     } else if (DVLOG_IS_ON(5)) {
 44 |       LOG(INFO) << "HttpContents::Print(" << StringPiece(content).size() << ")";
 45 |     }
 46 |     contents_.push_back(ToArenaStringPiece(std::forward<T>(content)));
 47 |     Print(std::forward<Args>(args)...);
 48 |   }
 49 | 
 50 |   // Sets header.
 51 |   template<typename K, typename V>
 52 |   void SetHeader(K&& key, V&& value, bool overwrite = true) {
 53 |     DVLOG(5) << "HttpContents::SetHeader(\"" << key << "\", \""
 54 |              << value << "\", " << overwrite << ")";
 55 |     if (overwrite) {
 56 |       headers_.Set(ToArenaStringPiece(std::forward<K>(key)),
 57 |                    ToArenaStringPiece(std::forward<V>(value)));
 58 |     } else {
 59 |       headers_.Add(ToArenaStringPiece(std::forward<K>(key)),
 60 |                    ToArenaStringPiece(std::forward<V>(value)));
 61 |     }
 62 |   }
 63 | 
 64 |   ArenaStringPiece GetHeader(
 65 |       StringPiece key,
 66 |       ArenaStringPiece default_value = ArenaStringPiece()) const {
 67 |     return ArenaStringPiece(headers_.Get(key, default_value));
 68 |   }
 69 | 
 70 |   const HttpParameters& GetEnvironments() const { return environments_; }
 71 |   HttpParameters* MutableEnvironments() { return &environments_; }
 72 | 
 73 |   ArenaStringPiece GetFirstContent() const {
 74 |     if (contents_.empty()) {
 75 |       DVLOG(5) << "Empty contents.";
 76 |       return ""_a;
 77 |     }
 78 |     return ArenaStringPiece(contents_[0]);
 79 |   }
 80 | 
 81 |   // Returns contents.  This is not const because this may join chunked
 82 |   // contents.
 83 |   ArenaStringPiece GetContents() {
 84 |     if (contents_.empty()) {
 85 |       return ""_a;
 86 |     }
 87 |     if (contents_.size() > 1) {
 88 |       int64 content_length = 0;
 89 |       for (StringPiece content : contents_) {
 90 |         content_length += content.size();
 91 |       }
 92 |       ArenaBuffer* buffer = arena_->NextBuffer();
 93 |       buffer->reserve(content_length);
 94 |       for (StringPiece content : contents_) {
 95 |         buffer->append(content);
 96 |       }
 97 |       contents_.clear();
 98 |       contents_.push_back(*buffer);
 99 |     }
100 |     return ArenaStringPiece(contents_[0]);
101 |   }
102 | 
103 |   void ClearContents() { return contents_.clear(); }
104 | 
105 |   void Destroy() { is_destroyed_ = true; }
106 |   bool IsDestroyed() const { return is_destroyed_; }
107 | 
108 |   Json ToJson() const {
109 |     return Json::object({
110 |         {"environments", environments_},
111 |         {"headers", headers_}});
112 |   }
113 | 
114 |   Arena* MutableArena() override { return arena_; }
115 | 
116 |  private:
117 | 
118 |   Arena* arena_;
119 |   bool is_destroyed_ = false;
120 | 
121 |   HttpParameters headers_;
122 |   HttpParameters environments_;
123 |   vector<StringPiece> output_buffer_;
124 |   vector<StringPiece> contents_;
125 | };
126 | 


--------------------------------------------------------------------------------
/nineserver/common.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <ctype.h>
  3 | #include <string.h>
  4 | #include <algorithm>
  5 | 
  6 | #include "base/base.h"
  7 | 
  8 | #ifndef DVLOG_IS_ON
  9 | #ifdef NDEBUG
 10 | #define DVLOG_IS_ON(level) false
 11 | #else
 12 | #define DVLOG_IS_ON(level) VLOG_IS_ON(level)
 13 | #endif
 14 | #endif
 15 | 
 16 | // Enables to prioritize functions.
 17 | template<unsigned priority>
 18 | struct overload_priority : overload_priority<priority - 1> {};
 19 | template<> struct overload_priority<0> {};
 20 | 
 21 | template<typename T>
 22 | void InitializeVectorWithCapacity(
 23 |     vector<T>* v, int64 minimum, int64 maximum = 0) {
 24 |   if (minimum > maximum) { maximum = minimum; }
 25 |   v->clear();
 26 |   if (v->capacity() > maximum) {
 27 |     v->shrink_to_fit();
 28 |     v->reserve(maximum);
 29 |   } else if (v->capacity() < minimum) {
 30 |     v->reserve(minimum);
 31 |   }
 32 | }
 33 | 
 34 | template<typename T, typename... Args>
 35 | std::unique_ptr<T> MakeUnique(Args&&... args) {
 36 |   return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 37 | }
 38 | 
 39 | bool CaseInsensitiveEqual(StringPiece l, StringPiece r);
 40 | 
 41 | struct StringPieceHash {
 42 |   std::size_t operator()(const StringPiece& key) const {
 43 |     return key.size();
 44 |   }
 45 | };
 46 | 
 47 | struct CaseInsensitiveStringPiece {
 48 |   std::size_t operator()(const StringPiece& x) const {
 49 |     if (x.empty()) { return 0; }
 50 |     std::size_t hash = 0;
 51 |     for (int i = 0; i < sizeof(hash) && i < x.size(); i++) {
 52 |       hash = (hash << 8) | static_cast<uint8>(tolower(x[i]));
 53 |     }
 54 |     return hash ^ x.size();
 55 |   }
 56 | 
 57 |   bool operator()(const StringPiece& l, const StringPiece& r) const
 58 |       { return CaseInsensitiveEqual(l, r); }
 59 | };
 60 | 
 61 | namespace internal {
 62 | 
 63 | inline size_t Length(char c) { return 1; }
 64 | inline size_t Length(StringPiece s) { return s.size(); }
 65 | 
 66 | }  // namespace
 67 | 
 68 | template<typename Delimiter>
 69 | inline bool SplitToStringPieces(
 70 |     StringPiece input, Delimiter delimiter,
 71 |     StringPiece* output1, StringPiece* output2) {
 72 |   auto position = input.find(delimiter);
 73 |   if (position == StringPiece::npos) {
 74 |     *output1 = input;
 75 |     return false;
 76 |   }
 77 |   if (output1 != nullptr) {
 78 |     output1->set(input.data(), position);
 79 |   }
 80 |   if (output2 != nullptr) {
 81 |     output2->set(input.data() + position + internal::Length(delimiter),
 82 |                  input.size() - position - internal::Length(delimiter));
 83 |   }
 84 |   return true;
 85 | }
 86 | 
 87 | template<typename Delimiter, typename... Args>
 88 | inline bool SplitToStringPieces(
 89 |     StringPiece input, Delimiter delimiter,
 90 |     StringPiece* output1, StringPiece* output2,
 91 |     StringPiece* output3, Args*... args) {
 92 |   StringPiece trailing;
 93 |   if (!SplitToStringPieces(input, delimiter, output1, &trailing)) {
 94 |     return false;
 95 |   }
 96 |   return SplitToStringPieces(trailing, delimiter, output2, output3, args...);
 97 | }
 98 | 
 99 | template<typename Delimiter>
100 | inline bool ReverseSplitToStringPieces(
101 |     StringPiece input, Delimiter delimiter,
102 |     StringPiece* output1, StringPiece* output2) {
103 |   auto position = input.rfind(delimiter);
104 |   if (position == StringPiece::npos) {
105 |     if (output2 != nullptr) {
106 |       *output2 = input;
107 |     }
108 |     return false;
109 |   }
110 |   if (output1 != nullptr) {
111 |     output1->set(input.data(), position);
112 |   }
113 |   if (output2 != nullptr) {
114 |     output2->set(input.data() + position + internal::Length(delimiter),
115 |                  input.size() - position - internal::Length(delimiter));
116 |   }
117 |   return true;
118 | }
119 | 
120 | template<typename Delimiter, typename... Args>
121 | inline bool ReverseSplitToStringPieces(
122 |     StringPiece input, Delimiter delimiter, Args*... args,
123 |     StringPiece* output3, StringPiece* output2, StringPiece* output1) {
124 |   StringPiece leading;
125 |   if (!ReverseSplitToStringPieces(input, delimiter, &leading, output1)) {
126 |     return false;
127 |   }
128 |   return ReverseSplitToStringPieces(
129 |       leading, delimiter, args..., output3, output2);
130 | }
131 | 
132 | double GetThreadClock();
133 | double GetCurrentTime();
134 | 
135 | int64 Rand();
136 | 


--------------------------------------------------------------------------------
/nineserver/test/scenario_test.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | 
  3 | set -e -u -x
  4 | 
  5 | PORT="$(./nineserver/tools/free_port)"
  6 | TMPFILE="${TMPDIR:-/tmp}/scenario-${PORT}"
  7 | 
  8 | ToCrLf() {
  9 |   awk '{sub(/$/, "\r"); print}'
 10 | }
 11 | 
 12 | ./nineserver/test/main --port="${PORT}" --alsologtostderr &
 13 | sleep 0.5
 14 | 
 15 | ################################################################################
 16 | # /_/null should always return OK.
 17 | ################################################################################
 18 | ToCrLf <<'EOM' | nc 127.0.0.1 "${PORT}" | grep -v ^X-Profile >"${TMPFILE}"
 19 | GET /_/null HTTP/1.1
 20 | User-Agent: curl/7.37.1
 21 | Host: localhost:8081
 22 | Accept: */*
 23 | Connection: close
 24 | 
 25 | EOM
 26 | 
 27 | cat <<'EOM' | diff --strip-trailing-cr - "${TMPFILE}"
 28 | HTTP/1.1 200 OK
 29 | Content-Type: text/plain; charset=UTF-8
 30 | Connection: close
 31 | Content-Length: 3
 32 | 
 33 | OK
 34 | EOM
 35 | 
 36 | ################################################################################
 37 | # /_/undefined should return 404.
 38 | ################################################################################
 39 | ToCrLf <<'EOM' | nc 127.0.0.1 "${PORT}" | grep -v ^X-Profile >"${TMPFILE}"
 40 | GET /_/undefined HTTP/1.1
 41 | User-Agent: curl/7.37.1
 42 | Host: localhost:8081
 43 | Accept: */*
 44 | Connection: close
 45 | 
 46 | EOM
 47 | 
 48 | cat <<'EOM' | diff --strip-trailing-cr - "${TMPFILE}"
 49 | HTTP/1.1 404 Not Found
 50 | Content-Type: text/plain; charset=UTF-8
 51 | Connection: close
 52 | Content-Length: 34
 53 | 
 54 | No such system handler: undefined
 55 | EOM
 56 | 
 57 | ################################################################################
 58 | # /_/undefined should return 404.
 59 | ################################################################################
 60 | ToCrLf <<'EOM' | nc 127.0.0.1 "${PORT}" | grep -v ^X-Profile >"${TMPFILE}"
 61 | GET /_/undefined HTTP/1.1
 62 | User-Agent: curl/7.37.1
 63 | Host: localhost:8081
 64 | Accept: */*
 65 | Connection: close
 66 | 
 67 | EOM
 68 | 
 69 | cat <<'EOM' | diff --strip-trailing-cr - "${TMPFILE}"
 70 | HTTP/1.1 404 Not Found
 71 | Content-Type: text/plain; charset=UTF-8
 72 | Connection: close
 73 | Content-Length: 34
 74 | 
 75 | No such system handler: undefined
 76 | EOM
 77 | 
 78 | ################################################################################
 79 | # Test parameters
 80 | ################################################################################
 81 | curl "http://localhost:${PORT}/_/var?key=query_parameters&foo=bar&%E3%81%82%E3%81%84%E3%81%86%E3%81%88%E3%81%8A=%E3%81%8B%E3%81%8D%E3%81%8F%E3%81%91%E3%81%93" > "${TMPFILE}"
 82 | echo -n '{"foo":["bar"],"key":["query_parameters"],"あいうえお":["かきくけこ"]}' | diff - "${TMPFILE}"
 83 | 
 84 | curl --data-urlencode 'foo=bar' --data-urlencode 'あいうえお=かきくけこ' \
 85 |     "http://localhost:${PORT}/_/var?key=post_parameters" > "${TMPFILE}"
 86 | echo -n '{"foo":["bar"],"あいうえお":["かきくけこ"]}' | diff - "${TMPFILE}"
 87 | 
 88 | curl -F 'foo=bar' -F 'あいうえお=かきくけこ' \
 89 |     "http://localhost:${PORT}/_/var?key=file_parameters" > "${TMPFILE}"
 90 | echo -n '{"foo":{"Content-Body":["bar"],"Content-Disposition":["form-data; name=\"foo\""]},"あいうえお":{"Content-Body":["かきくけこ"],"Content-Disposition":["form-data; name=\"あいうえお\""]}}' | diff - "${TMPFILE}"
 91 | 
 92 | curl -c - "http://localhost:${PORT}/_/cookie?key=foo&value=bar" | \
 93 | curl -b - -c - \
 94 |     "http://localhost:${PORT}/_/cookie?key=あいうえお&value=かきくけこ" | \
 95 | curl -b - "http://localhost:${PORT}/_/var?key=cookie_parameters" \
 96 |     > "${TMPFILE}"
 97 | echo -n '{"foo":["bar"],"あいうえお":["かきくけこ"]}' | diff - "${TMPFILE}"
 98 | 
 99 | ################################################################################
100 | # ApachBench should work.
101 | ################################################################################
102 | ab -n 1000 -c 10 -k "http://127.0.0.1:${PORT}/_/null" 2>/dev/null | \
103 |     grep 'Complete requests' | grep 1000
104 | ab -n 1000 -c 10 "http://127.0.0.1:${PORT}/_/null" 2>/dev/null | \
105 |     grep 'Complete requests' | grep 1000
106 | 
107 | ################################################################################
108 | # Quit the server.
109 | ################################################################################
110 | curl "http://127.0.0.1:${PORT}/_/quit"
111 | 
112 | wait
113 | rm "${TMPFILE}"
114 | 


--------------------------------------------------------------------------------
/nineserver/io/generic_io.cc:
--------------------------------------------------------------------------------
  1 | #include "nineserver/io/generic_io.h"
  2 | 
  3 | #include <arpa/inet.h>
  4 | #include <assert.h>
  5 | #include <ctype.h>
  6 | #include <errno.h>
  7 | #include <functional>
  8 | #include <list>
  9 | #include <memory>
 10 | #include <mutex>
 11 | #include <netinet/in.h>
 12 | #include <netinet/tcp.h>
 13 | #include <pthread.h>
 14 | #include <signal.h>
 15 | #include <stdarg.h>
 16 | #include <sys/select.h>
 17 | #include <sys/socket.h>
 18 | #include <sys/uio.h>
 19 | #include <sys/un.h>
 20 | #include <thread>
 21 | #include <unistd.h>
 22 | #include <vector>
 23 | 
 24 | #include "base/base.h"
 25 | #include "nineserver/arena/arena_buffer.h"
 26 | 
 27 | void GenericIO::Init() {
 28 |   DVLOG(6) << "GenericIO::Init()";
 29 |   Destroy();
 30 |   is_destroyed_ = false;
 31 |   buffer_start_ = 0;
 32 |   buffer_end_ = 0;
 33 | }
 34 | 
 35 | bool GenericIO::ReadLine(BufferInterface* output) {
 36 |   DVLOG(6) << "GenericIO::ReadLine()";
 37 |   if (buffer_end_ < 0) {
 38 |     return false;
 39 |   }
 40 |   auto original_length = output->size();
 41 |   while (true) {
 42 |     StringPiece buffer(buffer_ + buffer_start_, buffer_end_ - buffer_start_);
 43 |     auto position = buffer.find('\n');
 44 |     if (position != StringPiece::npos) {
 45 |       output->append(buffer.substr(0, position + 1));
 46 |       buffer_start_ += position + 1;
 47 |       break;
 48 |     }
 49 |     output->append(buffer);
 50 |     if (!ReadBuffer()) {
 51 |       return false;
 52 |     } else if (buffer_end_ == 0) {
 53 |       break;
 54 |     }
 55 |   }
 56 |   return original_length != output->size();
 57 | }
 58 | 
 59 | int GenericIO::ReadN(int length, BufferInterface* output) {
 60 |   DVLOG(6) << "GenericIO::ReadN()";
 61 |   if (buffer_end_ < 0) {
 62 |     return false;
 63 |   }
 64 |   auto original_length = output->size();
 65 |   while (true) {
 66 |     StringPiece buffer(buffer_ + buffer_start_, buffer_end_ - buffer_start_);
 67 |     int remaining = original_length + length - output->size();
 68 |     if (remaining <= buffer.size()) {
 69 |       output->append(buffer.substr(0, remaining));
 70 |       buffer_start_ += remaining;
 71 |       break;
 72 |     }
 73 |     output->append(buffer);
 74 |     if (!ReadBuffer()) {
 75 |       return false;
 76 |     } else if (buffer_end_ == 0) {
 77 |       break;
 78 |     }
 79 |   }
 80 |   return output->size() - original_length;
 81 | }
 82 | 
 83 | int GenericIO::ReadCharacter() {
 84 |   DVLOG(6) << "GenericIO::ReadCharacter()";
 85 |   if (IsEof()) { return -1; }
 86 |   return buffer_[buffer_start_++];
 87 | }
 88 | 
 89 | bool GenericIO::IsEof() {
 90 |   DVLOG(6) << "GenericIO::IsEof()";
 91 |   if (buffer_end_ < 0) {
 92 |     return true;
 93 |   }
 94 |   if (buffer_start_ >= buffer_end_) {
 95 |     if (IsDestroyed()) { return true; }
 96 |     if (!ReadBuffer()) {
 97 |       // NOTE: This is not warning because IsEof is usually called to check if
 98 |       // the response finishes.
 99 |       DVLOG(5) << "Failed to read: " << strerror(errno);
100 |       return true;
101 |     // If it reaches EOF.
102 |     } else if (buffer_end_ == 0) {
103 |       DVLOG(6) << "Reaches EOF.";
104 |       buffer_end_ = -1;
105 |       return true;
106 |     }
107 |   }
108 |   return false;
109 | }
110 | 
111 | bool GenericIO::ReadBuffer() {
112 |   DVLOG(6) << "GenericIO::ReadBuffer()";
113 |   buffer_start_ = 0;
114 |   buffer_end_ = ReadIO(buffer_, sizeof(buffer_));
115 |   DVLOG(6) << "New buffer: " << buffer_end_;
116 |   return buffer_end_ >= 0;
117 | }
118 | 
119 | bool GenericIO::Write(StringPiece data) {
120 |   if (data.empty()) { return true; }
121 |   write_buffer_[0] = data;
122 |   return WriteIO(write_buffer_);
123 | }
124 | 
125 | bool GenericIO::Write(const vector<StringPiece>& data) {
126 |   if (DVLOG_IS_ON(15)) {
127 |     for (StringPiece piece : data) {
128 |       LOG(INFO) << "GenericIO::Write(\"" << piece << "\")";
129 |     }
130 |   } else if (DVLOG_IS_ON(5)) {
131 |     for (StringPiece piece : data) {
132 |       LOG(INFO) << "GenericIO::Write(" << piece.size() << ")";
133 |     }
134 |   }
135 |   return WriteIO(data);
136 | }
137 | 
138 | void GenericIO::Destroy() {
139 |   if (IsDestroyed()) { return; }
140 |   DVLOG(6) << "GenericIO::Destroy()";
141 |   is_destroyed_ = true;
142 |   CloseIO();
143 | }
144 | 
145 | bool GenericIO::IsDestroyed() const {
146 |   return is_destroyed_;
147 | }
148 | 
149 | bool GenericIO::Empty() const {
150 |   return buffer_start_ == buffer_end_;
151 | }
152 | 


--------------------------------------------------------------------------------
/example/run.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | # run.sh
  3 | 
  4 | export PATH="$(pwd)/bin:${PATH}"
  5 | 
  6 | source imosh || exit 1
  7 | 
  8 | DEFINE_int v 0 'Verbosity level.'
  9 | DEFINE_int port 8080 'Port number to listen.'
 10 | DEFINE_bool --alias=n dry_run false 'Dry run.'
 11 | 
 12 | DEFINE_int --group=php php_port 0 'Port for PHP-FPM.'
 13 | 
 14 | DEFINE_int --group=nginx nginx_port 8000 'Port.'
 15 | DEFINE_int --group=nginx nginx_worker_processes 4 '# of worker processes.'
 16 | DEFINE_int --group=nginx nginx_worker_connections 2048 \
 17 |     '# of worker connections.'
 18 | 
 19 | eval "${IMOSH_INIT}"
 20 | 
 21 | set -e -u
 22 | 
 23 | MAIN="$(echo */main)"
 24 | ROOT_DIRECTORY="${PWD}/${MAIN%/main}"
 25 | 
 26 | PHP_PATH="/tmp/$(sub::time).$$.php-fpm.sock"
 27 | sub::atexit "rm -f ${PHP_PATH} || true"
 28 | 
 29 | generate_nginx_conf() {
 30 |   echo "worker_processes ${FLAGS_nginx_worker_processes};"
 31 |   echo 'daemon off;'
 32 |   echo 'error_log /dev/stderr debug;'
 33 |   echo 'events {'
 34 |   {
 35 |     echo "worker_connections ${FLAGS_nginx_worker_connections};"
 36 |     echo 'multi_accept on;'
 37 |   }
 38 |   echo '}'
 39 | 
 40 |   echo 'http {'
 41 |   {
 42 |     cat "${ROOT_DIRECTORY}/config/mime.types"
 43 |     echo 'default_type application/octet-stream;'
 44 |     echo 'sendfile on;'
 45 |     echo 'keepalive_timeout 120;'
 46 | 
 47 |     echo 'upstream fcgi {'
 48 |     {
 49 |       if (( FLAGS_php_port == 0 )); then
 50 |         echo "server unix:${PHP_PATH};"
 51 |       else
 52 |         echo "server 127.0.0.1:${FLAGS_php_port};"
 53 |       fi
 54 |     }
 55 |     echo '}'
 56 | 
 57 |     echo 'server {'
 58 |     {
 59 |       if (( FLAGS_nginx_port == 0 )); then
 60 |         echo "listen unix:${PROXY_SOCKET};"
 61 |       else
 62 |         echo "listen ${FLAGS_nginx_port};"
 63 |       fi
 64 |       echo 'server_name localhost;'
 65 |       # echo 'root data/www;'
 66 |       echo "root ${ROOT_DIRECTORY}/data/nginx;"
 67 | 
 68 |       # Matches static files.
 69 |       echo 'location ~ .*\.(css|js|ico|html|jpg)$ {}'
 70 | 
 71 |       echo 'location ~ [^/]\.php$ {'
 72 |       {
 73 |         echo 'fastcgi_pass fcgi;'
 74 |         cat "${ROOT_DIRECTORY}/config/fcgi.conf"
 75 |       }
 76 |       echo '}'
 77 |     }
 78 |     echo '}'
 79 |   }
 80 |   echo '}'
 81 | }
 82 | 
 83 | run_nginx() {
 84 |   local tmpfile
 85 |   func::tmpfile tmpfile
 86 |   generate_nginx_conf > "${tmpfile}"
 87 |   nginx -p "${ROOT_DIRECTORY}" -c "${tmpfile}"
 88 | }
 89 | 
 90 | generate_fpm() {
 91 |   echo 'daemonize = no'
 92 |   echo 'error_log = /dev/stderr'
 93 |   echo '[www]'
 94 |   echo 'pm = static'
 95 |   if (( FLAGS_php_port == 0 )); then
 96 |     echo "listen = ${PHP_PATH}"
 97 |   else
 98 |     echo "listen = 0.0.0.0:${FLAGS_php_port}"
 99 |   fi
100 |   echo 'pm.max_children = 8'
101 |   echo 'pm.process_idle_timeout = 10s'
102 |   echo 'pm.max_requests = 0'
103 |   echo 'request_terminate_timeout = 10'
104 |   echo 'pm.status_path = /status'
105 |   echo 'ping.path = /ping'
106 |   echo 'catch_workers_output = yes'
107 |   echo 'php_flag[display_errors] = on'
108 |   echo 'php_admin_flag[log_errors] = on'
109 | }
110 | 
111 | generate_php_ini() {
112 |   echo 'error_log = /dev/stderr'
113 |   echo 'date.timezone = "Asia/Tokyo"'
114 | }
115 | 
116 | run_fpm() {
117 |   local php_fpm_conf
118 |   func::tmpfile php_fpm_conf
119 |   generate_fpm > "${php_fpm_conf}"
120 | 
121 |   local php_ini_conf
122 |   func::tmpfile php_ini_conf
123 |   generate_php_ini > "${php_ini_conf}"
124 | 
125 |   php-fpm -F -n -y "${php_fpm_conf}" -c "${php_ini_conf}"
126 | }
127 | 
128 | COMMAND=(
129 |     "${MAIN}"
130 |     --port="${FLAGS_port}"
131 |     --alsologtostderr
132 |     --v="${FLAGS_v}")
133 | 
134 | if (( FLAGS_nginx_port == 0 )); then
135 |   PROXY_SOCKET="$(sub::tmpfile).socket"
136 |   COMMAND+=(--proxy="unix://${PROXY_SOCKET}")
137 | else
138 |   COMMAND+=(--proxy="tcp://127.0.0.1:${FLAGS_nginx_port}")
139 | fi
140 | 
141 | if (( FLAGS_dry_run )); then
142 |   echo '======================================================================='
143 |   generate_nginx_conf
144 |   echo '======================================================================='
145 |   generate_fpm
146 |   echo '======================================================================='
147 |   generate_php_ini
148 |   echo '======================================================================='
149 |   echo "${COMMAND[@]}"
150 | else
151 |   run_nginx &
152 |   run_fpm &
153 |   "${COMMAND[@]}"
154 |   sub::exit
155 | fi
156 | 


--------------------------------------------------------------------------------
/nineserver/http/http_parameters_test.cc:
--------------------------------------------------------------------------------
  1 | #include <sys/time.h>
  2 | 
  3 | #include "base/testing.h"
  4 | #include "nineserver/benchmark/benchmark.h"
  5 | #include "nineserver/http/http_parameters.h"
  6 | 
  7 | DECLARE_int32(http_parameters_binary_search_threshold);
  8 | 
  9 | TEST(HttpParametersBenchmark, HttpParameters) {
 10 |   HttpParameters parameters;
 11 |   Benchmark("Add10Parameters", [&]() {
 12 |     parameters.Clear();
 13 |     parameters.Add("Host"_a, "1"_a);
 14 |     parameters.Add("Accept"_a, "2"_a);
 15 |     parameters.Add("Accept-Encoding"_a, "3"_a);
 16 |     parameters.Add("Accept-Language"_a, "4"_a);
 17 |     parameters.Add("Cache-Control"_a, "5"_a);
 18 |     parameters.Add("Connection"_a, "6"_a);
 19 |     parameters.Add("Cookie"_a, "7"_a);
 20 |     parameters.Add("If-None-Match"_a, "8"_a);
 21 |     parameters.Add("Upgrade-Insecure-Requests"_a, "9"_a);
 22 |     parameters.Add("User-Agent"_a, "10"_a);
 23 |   });
 24 |   ASSERT_FALSE(parameters.IsSorted());
 25 |   Benchmark("GetThirdParameter", [&]() {
 26 |     ASSERT_EQ("3"_a, parameters.Get("Accept-Encoding"_a));
 27 |   });
 28 |   Benchmark("GetLastParameter", [&]() {
 29 |     ASSERT_EQ("10"_a, parameters.Get("User-Agent"_a));
 30 |   });
 31 | }
 32 | 
 33 | TEST(HttpParametersBenchmark, SortedHttpParameters) {
 34 |   FLAGS_http_parameters_binary_search_threshold = 0;
 35 |   HttpParameters parameters;
 36 |   Benchmark("Add10Parameters", [&]() {
 37 |     parameters.Clear();
 38 |     parameters.Add("Host"_a, "1"_a);
 39 |     parameters.Add("Accept"_a, "2"_a);
 40 |     parameters.Add("Accept-Encoding"_a, "3"_a);
 41 |     parameters.Add("Accept-Language"_a, "4"_a);
 42 |     parameters.Add("Cache-Control"_a, "5"_a);
 43 |     parameters.Add("Connection"_a, "6"_a);
 44 |     parameters.Add("Cookie"_a, "7"_a);
 45 |     parameters.Add("If-None-Match"_a, "8"_a);
 46 |     parameters.Add("Upgrade-Insecure-Requests"_a, "9"_a);
 47 |     parameters.Add("User-Agent"_a, "10"_a);
 48 |     parameters.Sort();
 49 |   });
 50 |   ASSERT_TRUE(parameters.IsSorted());
 51 |   Benchmark("GetThirdParameter", [&]() {
 52 |     ASSERT_EQ("3"_a, parameters.Get("Accept-Encoding"_a));
 53 |   });
 54 |   Benchmark("GetLastParameter", [&]() {
 55 |     ASSERT_EQ("10"_a, parameters.Get("User-Agent"_a));
 56 |   });
 57 | }
 58 | 
 59 | TEST(HttpParametersBenchmark, Map) {
 60 |   map<StringPiece, StringPiece> parameters;
 61 |   Benchmark("Add10Parameters", [&]() {
 62 |     parameters.clear();
 63 |     parameters.emplace("Host"_a, "1"_a);
 64 |     parameters.emplace("Accept"_a, "2"_a);
 65 |     parameters.emplace("Accept-Encoding"_a, "3"_a);
 66 |     parameters.emplace("Accept-Language"_a, "4"_a);
 67 |     parameters.emplace("Cache-Control"_a, "5"_a);
 68 |     parameters.emplace("Connection"_a, "6"_a);
 69 |     parameters.emplace("Cookie"_a, "7"_a);
 70 |     parameters.emplace("If-None-Match"_a, "8"_a);
 71 |     parameters.emplace("Upgrade-Insecure-Requests"_a, "9"_a);
 72 |     parameters.emplace("User-Agent"_a, "10"_a);
 73 |   });
 74 |   Benchmark("GetThirdParameter", [&]() {
 75 |     ASSERT_EQ("3"_a, parameters.find("Accept-Encoding"_a)->second);
 76 |   });
 77 |   Benchmark("GetLastParameter", [&]() {
 78 |     ASSERT_EQ("10"_a, parameters.find("User-Agent"_a)->second);
 79 |   });
 80 | }
 81 | 
 82 | TEST(HttpParametersBenchmark, Vector) {
 83 |   vector<pair<StringPiece, StringPiece>> parameters;
 84 |   Benchmark("Add10Parameters", [&]() {
 85 |     parameters.clear();
 86 |     parameters.emplace_back("Host"_a, "1"_a);
 87 |     parameters.emplace_back("Accept"_a, "2"_a);
 88 |     parameters.emplace_back("Accept-Encoding"_a, "3"_a);
 89 |     parameters.emplace_back("Accept-Language"_a, "4"_a);
 90 |     parameters.emplace_back("Cache-Control"_a, "5"_a);
 91 |     parameters.emplace_back("Connection"_a, "6"_a);
 92 |     parameters.emplace_back("Cookie"_a, "7"_a);
 93 |     parameters.emplace_back("If-None-Match"_a, "8"_a);
 94 |     parameters.emplace_back("Upgrade-Insecure-Requests"_a, "9"_a);
 95 |     parameters.emplace_back("User-Agent"_a, "10"_a);
 96 |     sort(parameters.begin(), parameters.end());
 97 |   });
 98 |   Benchmark("GetThirdParameter", [&]() {
 99 |     ASSERT_EQ(
100 |         "3"_a,
101 |         std::lower_bound(
102 |             parameters.begin(), parameters.end(),
103 |             pair<StringPiece, StringPiece>("Accept-Encoding"_a, ""_a))->second);
104 |   });
105 |   Benchmark("GetLastParameter", [&]() {
106 |     ASSERT_EQ(
107 |         "10"_a,
108 |         std::lower_bound(
109 |             parameters.begin(), parameters.end(),
110 |             pair<StringPiece, StringPiece>("User-Agent"_a, ""_a))->second);
111 |   });
112 | }
113 | 


--------------------------------------------------------------------------------
/nineserver/arena/arena_buffer.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <memory>
  3 | #include <string>
  4 | #include <vector>
  5 | 
  6 | #include "base/base.h"
  7 | #include "nineserver/common.h"
  8 | #include "nineserver/arena/arena_string_piece.h"
  9 | 
 10 | // Interface to access to both of ArenaBuffer and string.
 11 | class BufferInterface {
 12 |  public:
 13 |   BufferInterface() {}
 14 |   virtual ~BufferInterface() {}
 15 | 
 16 |   virtual void resize(int64 size) = 0;
 17 |   virtual void reserve(int64 size) = 0;
 18 |   virtual void append(StringPiece str) = 0;
 19 |   // Falls back to append.
 20 |   virtual void push_back(char c) {
 21 |     char buffer[1] = {c};
 22 |     append(StringPiece(buffer, 1));
 23 |   }
 24 | 
 25 |   virtual const char* data() const = 0;
 26 |   virtual int64 size() const = 0;
 27 | 
 28 |   operator StringPiece() const { return StringPiece(data(), size()); }
 29 | 
 30 |   template<typename V, typename... Args>
 31 |   inline void StrCat(const V& value, const Args&... args) {
 32 |     AlphaNum alpha_num(value);
 33 |     append(StringPiece(alpha_num.data(), alpha_num.size()));
 34 |     StrCat(args...);
 35 |   }
 36 |   inline void StrCat() {}
 37 | };
 38 | 
 39 | // ArenaBuffer manages long memory areas, and provides the last piece as a
 40 | // buffer.  Caller can resize the last piece.  Once the piece's size is
 41 | // finalized, it can be converted into StringPiece safely while ArenaBuffer
 42 | // is alive.
 43 | //
 44 | // How to create a buffer:
 45 | // 1. Init() allocates a new 0-byte buffer.
 46 | // 2. resize methods (incl. push_back/append) resizes the buffer.
 47 | // 3. ToStringPiece() returns the current buffer as StringPiece.
 48 | // 4. Next Init() call finalizes the memory location.
 49 | class ArenaBuffer : public BufferInterface {
 50 |  public:
 51 |   ArenaBuffer();
 52 | 
 53 |   // Initialize the ArenaBuffer.  This may release memories, so any StringPiece
 54 |   // created by this object must be invalidated.
 55 |   void DeleteAll();
 56 | 
 57 |   // Prepares a new buffer.
 58 |   void Init();
 59 | 
 60 |   //////////////////////////////////////////////////////////////////////////////
 61 |   // Resize functions
 62 |   // CAVEAT: Resize function may change the current buffer's memory location.
 63 |   //////////////////////////////////////////////////////////////////////////////
 64 | 
 65 |   // Resizes the buffer into `size`.
 66 |   void resize(int64 size) override;
 67 |   // An alias of resize(0).
 68 |   void clear();
 69 |   // Add a character `c` at the end.
 70 |   void push_back(char c) override;
 71 |   // Appends a string `str` at the end.
 72 |   void append(StringPiece str) override;
 73 |   // Reserves capacity.
 74 |   void reserve(int64 size) override;
 75 |   // Returns capacity.
 76 |   int64 capacity() const;
 77 |   // Returns usage.
 78 |   int64 usage() const;
 79 | 
 80 |   //////////////////////////////////////////////////////////////////////////////
 81 |   // Accessors
 82 |   //////////////////////////////////////////////////////////////////////////////
 83 |   char& operator[](int64 index) { return data()[index]; }
 84 |   char operator[](int64 index) const { return data()[index]; }
 85 | 
 86 |   inline char* data()
 87 |       { return buffers_.back().data_.get() + buffers_.back().size_ - size_; }
 88 |   inline const char* data() const override
 89 |       { return buffers_.back().data_.get() + buffers_.back().size_ - size_; }
 90 |   inline int64 size() const override { return size_; }
 91 | 
 92 |   operator StringPiece() const { return StringPiece(data(), size()); }
 93 |   operator ArenaStringPiece() const { return ToArenaStringPiece(); }
 94 | 
 95 |   ArenaStringPiece ToArenaStringPiece() const {
 96 |     return ArenaStringPiece(StringPiece(*this));
 97 |   }
 98 | 
 99 |  private:
100 |   class Buffer {
101 |    public:
102 |     explicit Buffer(int capacity)
103 |         : data_(new char[capacity]), capacity_(capacity), size_(0) {}
104 |     Buffer(Buffer&& buffer) { *this = std::move(buffer); }
105 |     ~Buffer() noexcept {}
106 | 
107 |     void operator=(Buffer&& buffer) {
108 |       data_ = std::move(buffer.data_);
109 |       capacity_ = buffer.capacity_;
110 |       size_ = buffer.size_;
111 |       buffer.capacity_ = 0;
112 |       buffer.size_ = 0;
113 |     }
114 | 
115 |     std::unique_ptr<char[]> data_;
116 |     int64 capacity_;
117 |     int64 size_;
118 |   };
119 | 
120 |   // Prepares a new memory area.
121 |   void AddBuffer(int length = 0);
122 | 
123 |   vector<Buffer> buffers_;
124 |   int64 size_ = 0;
125 |   int64 usage_ = 0;
126 | };
127 | 
128 | class StringBuffer : public BufferInterface {
129 |  public:
130 |   StringBuffer(string* buffer) : buffer_(buffer) {}
131 |   StringBuffer() : buffer_(new string), buffer_is_owned_(true) {}
132 |   ~StringBuffer() override {
133 |     if (buffer_is_owned_) {
134 |       delete buffer_;
135 |     }
136 |   }
137 | 
138 |   string* get() const { return buffer_; }
139 | 
140 |   const char* data() const override { return buffer_->data(); }
141 |   int64 size() const override { return static_cast<int64>(buffer_->size()); }
142 |   void resize(int64 size) override { buffer_->resize(size); }
143 |   void reserve(int64 size) override { buffer_->reserve(size); }
144 |   void append(StringPiece str) override
145 |       { buffer_->append(str.data(), str.size()); }
146 | 
147 |   operator const string&() const { return *buffer_; }
148 |   operator string&&() { return std::move(*buffer_); }
149 | 
150 |  private:
151 |   string* buffer_;
152 |   bool buffer_is_owned_ = false;
153 | };
154 | 


--------------------------------------------------------------------------------
/nineserver/handler/base_handler_test.cc:
--------------------------------------------------------------------------------
  1 | #include "base/testing.h"
  2 | #include "nineserver/benchmark/benchmark.h"
  3 | #include "nineserver/handler/base_handler.h"
  4 | #include "nineserver/http/stream/string_stream.h"
  5 | 
  6 | DECLARE_bool(profile_header);
  7 | 
  8 | map<StringPiece, StringPiece> GetResourceData() {
  9 |   return map<StringPiece, StringPiece>();
 10 | }
 11 | 
 12 | class BaseHandlerTest : public testing::Test {
 13 |  public:
 14 |   BaseHandlerTest() {
 15 |     FLAGS_profile_header = false;
 16 |     handler_.SetStream(&stream_);
 17 |   }
 18 | 
 19 |   int RunHandler() {
 20 |     int count = 0;
 21 |     for (handler_.Init(); handler_.Start();) {
 22 |       count++;
 23 |       handler_.Process();
 24 |     }
 25 |     handler_.Destroy();
 26 |     return count;
 27 |   }
 28 | 
 29 |   void RegisterHandler(StringPiece prefix, const string& name, bool result) {
 30 |     handler_pool_.Register(prefix, [this, name, result](BaseHandler*) {
 31 |       handler_history_.push_back(name);
 32 |       return result;
 33 |     });
 34 |   }
 35 | 
 36 |   StringStream stream_;
 37 |   BaseHandler handler_;
 38 |   HandlerPool handler_pool_;
 39 |   vector<string> handler_history_;
 40 | };
 41 | 
 42 | bool ReplaceFilter(BaseHandler* handler) {
 43 |   ArenaStringPiece data = handler->MutableResponse()->GetContents();
 44 |   ArenaStringPiece former, latter;
 45 |   if (!SplitToArenaStringPieces(data, "foo", &former, &latter)) {
 46 |     return false;
 47 |   }
 48 |   handler->MutableResponse()->ClearContents();
 49 |   handler->MutableResponse()->Print(former);
 50 |   handler->MutableResponse()->Print("baz");
 51 |   handler->MutableResponse()->Print(latter);
 52 |   return false;
 53 | }
 54 | REGISTER_FILTER(ReplaceFilter, "/", ReplaceFilter);
 55 | 
 56 | TEST_F(BaseHandlerTest, SimpleScenario) {
 57 |   Benchmark("NullHandler", [this]() {
 58 |     stream_.SetInput(
 59 |         "GET /_/null HTTP/1.1\r\n"
 60 |         "Host: localhost\r\n"
 61 |         "User-Agent: foo\r\n"
 62 |         "\r\n"_a);
 63 |     EXPECT_EQ(1, RunHandler());
 64 |     EXPECT_EQ(
 65 |         "HTTP/1.1 200 OK\r\n"
 66 |         "Content-Type: text/plain; charset=UTF-8\r\n"
 67 |         "Connection: close\r\n"
 68 |         "Content-Length: 3\r\n"
 69 |         "\r\n"
 70 |         "OK\n"_a,
 71 |         stream_.GetOutput());
 72 |   });
 73 | }
 74 | 
 75 | TEST_F(BaseHandlerTest, ReplaceFilter) {
 76 |   Benchmark("ReplaceFilter", [this]() {
 77 |     stream_.SetInput(
 78 |         "GET /_/var?key=query_parameters&foo=bar HTTP/1.1\r\n"
 79 |         "Host: localhost\r\n"
 80 |         "User-Agent: foo\r\n"
 81 |         "\r\n"_a);
 82 |     EXPECT_EQ(1, RunHandler());
 83 |     EXPECT_EQ(
 84 |         "HTTP/1.1 200 OK\r\n"
 85 |         "Content-Type: text/plain; charset=UTF-8\r\n"
 86 |         "Connection: close\r\n"
 87 |         "Content-Length: 42\r\n"
 88 |         "\r\n"
 89 |         "{\"baz\":[\"bar\"],\"key\":[\"query_parameters\"]}"_a,
 90 |         stream_.GetOutput());
 91 |   });
 92 | }
 93 | 
 94 | TEST_F(BaseHandlerTest, HandlerPool_True) {
 95 |   RegisterHandler("/a", "/a", true);
 96 |   RegisterHandler("/aa", "/aa", true);
 97 |   RegisterHandler("/abc", "/abc1", true);
 98 |   RegisterHandler("/abc", "/abc2", true);
 99 |   RegisterHandler("/abcdef", "/abcdef", true);
100 | 
101 |   handler_history_.clear();
102 |   stream_.MutableRequest()->MutableEnvironments()->Set(
103 |       "SCRIPT_NAME"_a, "/abcdefghi"_a);
104 |   handler_pool_.Run(&handler_);
105 |   EXPECT_THAT(handler_history_, testing::ElementsAre("/abcdef"));
106 | 
107 |   handler_history_.clear();
108 |   stream_.MutableRequest()->MutableEnvironments()->Set(
109 |       "SCRIPT_NAME"_a, "/abcdef"_a);
110 |   handler_pool_.Run(&handler_);
111 |   EXPECT_THAT(handler_history_, testing::ElementsAre("/abcdef"));
112 | 
113 |   handler_history_.clear();
114 |   stream_.MutableRequest()->MutableEnvironments()->Set(
115 |       "SCRIPT_NAME"_a, "/abcde"_a);
116 |   handler_pool_.Run(&handler_);
117 |   EXPECT_THAT(handler_history_, testing::ElementsAre("/abc2"));
118 | 
119 |   handler_history_.clear();
120 |   stream_.MutableRequest()->MutableEnvironments()->Set(
121 |       "SCRIPT_NAME"_a, "/"_a);
122 |   handler_pool_.Run(&handler_);
123 |   EXPECT_THAT(handler_history_, testing::ElementsAre());
124 | }
125 | 
126 | TEST_F(BaseHandlerTest, HandlerPool_False) {
127 |   RegisterHandler("/a", "/a", false);
128 |   RegisterHandler("/aa", "/aa", false);
129 |   RegisterHandler("/abc", "/abc1", false);
130 |   RegisterHandler("/abc", "/abc2", false);
131 |   RegisterHandler("/abcdef", "/abcdef", false);
132 | 
133 |   handler_history_.clear();
134 |   stream_.MutableRequest()->MutableEnvironments()->Set(
135 |       "SCRIPT_NAME"_a, "/abcdefghi"_a);
136 |   handler_pool_.Run(&handler_);
137 |   EXPECT_THAT(handler_history_,
138 |               testing::ElementsAre("/abcdef", "/abc2", "/abc1", "/a"));
139 | 
140 |   handler_history_.clear();
141 |   stream_.MutableRequest()->MutableEnvironments()->Set(
142 |       "SCRIPT_NAME"_a, "/abcdef"_a);
143 |   handler_pool_.Run(&handler_);
144 |   EXPECT_THAT(handler_history_,
145 |               testing::ElementsAre("/abcdef", "/abc2", "/abc1", "/a"));
146 | 
147 |   handler_history_.clear();
148 |   stream_.MutableRequest()->MutableEnvironments()->Set(
149 |       "SCRIPT_NAME"_a, "/abcde"_a);
150 |   handler_pool_.Run(&handler_);
151 |   EXPECT_THAT(handler_history_,
152 |               testing::ElementsAre("/abc2", "/abc1", "/a"));
153 | 
154 |   handler_history_.clear();
155 |   stream_.MutableRequest()->MutableEnvironments()->Set(
156 |       "SCRIPT_NAME"_a, "/abc"_a);
157 |   handler_pool_.Run(&handler_);
158 |   EXPECT_THAT(handler_history_,
159 |               testing::ElementsAre("/abc2", "/abc1", "/a"));
160 | 
161 |   handler_history_.clear();
162 |   stream_.MutableRequest()->MutableEnvironments()->Set(
163 |       "SCRIPT_NAME"_a, "/"_a);
164 |   handler_pool_.Run(&handler_);
165 |   EXPECT_THAT(handler_history_, testing::ElementsAre());
166 | }
167 | 


--------------------------------------------------------------------------------
/nineserver/http/stream/standalone_stream.cc:
--------------------------------------------------------------------------------
  1 | #include <arpa/inet.h>
  2 | #include <assert.h>
  3 | #include <ctype.h>
  4 | #include <errno.h>
  5 | #include <netinet/in.h>
  6 | #include <netinet/tcp.h>
  7 | #include <poll.h>
  8 | #include <pthread.h>
  9 | #include <signal.h>
 10 | #include <stdarg.h>
 11 | #include <sys/select.h>
 12 | #include <sys/socket.h>
 13 | #include <sys/uio.h>
 14 | #include <unistd.h>
 15 | #include <functional>
 16 | #include <list>
 17 | #include <memory>
 18 | #include <mutex>
 19 | #include <thread>
 20 | #include <vector>
 21 | 
 22 | #include "base/base.h"
 23 | #include "nineserver/http/stream/http_stream.h"
 24 | #include "nineserver/http/stream/standalone_stream.h"
 25 | #include "nineserver/signal.h"
 26 | 
 27 | #define CHECK_SYS(...) CHECK((__VA_ARGS__) >= 0) << strerror(errno)
 28 | 
 29 | DEFINE_int32(port, 0, "Port number to listen.");
 30 | DEFINE_int32(connection, 1000, "The maximum number of connections to listen.");
 31 | DEFINE_int32(threads, 50, "The number of threads for HTTP.");
 32 | DEFINE_double(keep_alive_ratio, 0.5, "Ratio for keep-alive.");
 33 | DEFINE_int32(socket_timeout_in_ms, 0, "Read timeout in ms.");
 34 | DEFINE_bool(descriptor_pool, true, "Use descriptor pool.");
 35 | 
 36 | namespace {
 37 | 
 38 | const int kPollEvent = POLLIN | POLLPRI | POLLERR | POLLHUP;
 39 | 
 40 | class DescriptorPool {
 41 |  public:
 42 |   DescriptorPool() {
 43 |     int listen_fd = socket(PF_INET, SOCK_STREAM, 0);
 44 |     CHECK_SYS(listen_fd);
 45 |     AddExitHandler([listen_fd]() { close(listen_fd); });
 46 | 
 47 |     struct sockaddr_in server_addr = {};
 48 |     server_addr.sin_family = AF_INET;
 49 |     server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 50 |     server_addr.sin_port = htons(FLAGS_port);
 51 |     int enable = 1;
 52 |     CHECK_SYS(setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR,
 53 |                          &enable, sizeof(enable)));
 54 | #ifdef TCP_DEFER_ACCEPT
 55 |     CHECK_SYS(setsockopt(listen_fd, IPPROTO_TCP, TCP_DEFER_ACCEPT,
 56 |                          &enable, sizeof(enable)));
 57 | #endif
 58 |     CHECK_SYS(::bind(listen_fd, (sockaddr*)&server_addr, sizeof(server_addr)));
 59 |     CHECK_SYS(listen(listen_fd, FLAGS_connection));
 60 |     LOG(INFO) << "Listening :" << ntohs(server_addr.sin_port) << "...";
 61 | 
 62 |     pollfds_.push_back(
 63 |         {.fd = listen_fd, .events = kPollEvent, .revents = 0});
 64 |   }
 65 | 
 66 |   static DescriptorPool* Get() {
 67 |     static DescriptorPool* descriptor_pool = new DescriptorPool();
 68 |     return descriptor_pool;
 69 |   }
 70 | 
 71 |   void AddDescriptor(int descriptor) {
 72 |     if (descriptor < 0) return;
 73 |     std::lock_guard<std::mutex> pool_lock(pool_mutex_);
 74 |     pending_descriptors_.push_back(descriptor);
 75 |   }
 76 | 
 77 |   int GetDescriptor(int index) {
 78 |     if (!FLAGS_descriptor_pool || index % 2 == 0) {
 79 |       return accept(pollfds_[0].fd, nullptr, nullptr);
 80 |     }
 81 |     std::lock_guard<std::mutex> pollfds_guard(pollfds_mutex_);
 82 |     while (true) {
 83 |       if (!ready_descriptors_.empty()) {
 84 |         int descriptor = ready_descriptors_.back();
 85 |         ready_descriptors_.pop_back();
 86 |         return descriptor;
 87 |       }
 88 |       {
 89 |         std::lock_guard<std::mutex> pool_lock(pool_mutex_);
 90 |         for (int descriptor : pending_descriptors_) {
 91 |           pollfds_.push_back(
 92 |               {.fd = descriptor, .events = kPollEvent, .revents = 0});
 93 |         }
 94 |         pending_descriptors_.clear();
 95 |       }
 96 |       if (poll(pollfds_.data() + 1, pollfds_.size() - 1, 10) == 0) {
 97 |         continue;
 98 |       }
 99 |       for (int i = 1; i < pollfds_.size(); i++) {
100 |         if (pollfds_[i].revents == 0) continue;
101 |         if ((pollfds_[i].revents & POLLIN) != 0) {
102 |           int descriptor = pollfds_[i].fd;
103 |           if (i == 0) {
104 |             descriptor = accept(descriptor, nullptr, nullptr);
105 |             CHECK_SYS(descriptor);
106 |           }
107 |           ready_descriptors_.push_back(descriptor);
108 |         } else if (i != 0 && close(pollfds_[i].fd)) {
109 |           VLOG(1) << "Close error: " << strerror(errno);
110 |         }
111 |         if (i != 0) {
112 |           swap(pollfds_[i], pollfds_.back());
113 |           pollfds_.pop_back();
114 |           i--;
115 |         }
116 |       }
117 |     }
118 |   }
119 | 
120 |  private:
121 |   std::mutex pool_mutex_;
122 |   vector<int> ready_descriptors_;
123 |   vector<int> pending_descriptors_;
124 | 
125 |   std::mutex pollfds_mutex_;
126 |   vector<struct pollfd> pollfds_;
127 | };
128 | 
129 | }  // namespace
130 | 
131 | // static
132 | StandaloneStream* StandaloneStream::New(int index) {
133 |   DescriptorPool::Get();
134 |   return new StandaloneStream(index);
135 | }
136 | 
137 | // static
138 | void StandaloneStream::StartThreads(
139 |     const std::function<void(Stream*)>& action,
140 |     vector<std::thread>* threads) {
141 |   for (int i = 0; i < FLAGS_threads; i++) {
142 |     threads->push_back(std::thread([action, i]() {
143 |       std::unique_ptr<StandaloneStream> stream(StandaloneStream::New(i));
144 |       action(stream.get());
145 |       stream->Destroy();
146 |     }));
147 |   }
148 | }
149 | 
150 | bool StandaloneStream::Init() {
151 |   DCHECK(!GetKeepAlive());
152 |   if (!Stream::Init()) {
153 |     Destroy();
154 |     return false;
155 |   }
156 | 
157 |   int fd = DescriptorPool::Get()->GetDescriptor(index_);
158 |   DVLOG(5) << "Descriptor " << fd << ".";
159 | 
160 |   static const int enable = 1;
161 |   CHECK_SYS(setsockopt(
162 |       fd, IPPROTO_TCP, TCP_NODELAY, &enable, sizeof(enable)));
163 | 
164 |   if (FLAGS_socket_timeout_in_ms > 0) {
165 |     struct timeval tv;
166 |     tv.tv_sec = FLAGS_socket_timeout_in_ms / 1000;
167 |     tv.tv_usec = FLAGS_socket_timeout_in_ms % 1000 * 1000;
168 |     CHECK_SYS(setsockopt(
169 |         fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)));
170 |   }
171 | 
172 |   io_.InitDescriptorIO(fd);
173 |   if (keep_alive_count_ < FLAGS_threads * FLAGS_keep_alive_ratio) {
174 |     SetKeepAlive();
175 |     keep_alive_count_++;
176 |   } else {
177 |     LOG_FIRST_N(WARNING, 1)
178 |         << "Exceed # of keep alive connections: " << keep_alive_count_;
179 |   }
180 |   return true;
181 | }
182 | 
183 | bool StandaloneStream::Read() {
184 |   if (!Stream::Read()) { return false; }
185 | 
186 |   if (GetRequest().GetHeader("Expect"_a) == "100-continue"_a) {
187 |     MutableIO()->Write("HTTP/1.1 100 Continue\r\n\r\n"_a);
188 |   }
189 |   return true;
190 | }
191 | 
192 | bool StandaloneStream::MayRelease() {
193 |   if (!FLAGS_descriptor_pool) {
194 |     return false;
195 |   }
196 | 
197 |   if (!io_.Empty()) { return false; }
198 |   struct pollfd fd =
199 |       {.fd = io_.GetDescriptor(), .events = kPollEvent, .revents = 0};
200 |   if (poll(&fd, 1, 50) > 0) {
201 |     return false;
202 |   }
203 | 
204 |   int descriptor = io_.ReleaseDescriptor();
205 |   DescriptorPool::Get()->AddDescriptor(descriptor);
206 |   Destroy();
207 |   return true;
208 | }
209 | 
210 | void StandaloneStream::Destroy() {
211 |   if (GetKeepAlive()) {
212 |     SetKeepAlive(false);
213 |     keep_alive_count_--;
214 |   }
215 |   Stream::Destroy();
216 | }
217 | 
218 | std::atomic<int> StandaloneStream::keep_alive_count_(0);
219 | 


--------------------------------------------------------------------------------
/nineserver/handler/base_handler.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <thread>
  3 | #include <vector>
  4 | 
  5 | #include "base/base.h"
  6 | #include "nineserver/arena/arena_interface.h"
  7 | #include "nineserver/arena/arena_string_piece.h"
  8 | #include "nineserver/base64.h"
  9 | #include "nineserver/http/session.h"
 10 | #include "nineserver/http/stream/http_stream.h"
 11 | #include "third_party/glog/base/googleinit.h"
 12 | 
 13 | class BaseHandler : public ArenaInterface {
 14 |  public:
 15 |   BaseHandler() {}
 16 |   virtual ~BaseHandler() {}
 17 | 
 18 |   //////////////////////////////////////////////////////////////////////////////
 19 |   // Process functions
 20 |   //////////////////////////////////////////////////////////////////////////////
 21 |   void SetStream(Stream* stream) { stream_ = stream; }
 22 |   bool Init() { return stream_->Init(); }
 23 |   bool Start() { return stream_->Start(); }
 24 |   bool Process();
 25 |   void Destroy() { stream_->Destroy(); }
 26 |   void Finish();
 27 |   bool MayRelease() { return stream_->MayRelease(); }
 28 | 
 29 |   //////////////////////////////////////////////////////////////////////////////
 30 |   // Request functions
 31 |   //////////////////////////////////////////////////////////////////////////////
 32 |   inline const HttpParameters& ENV() const
 33 |       { return stream_->GetRequest().GetEnvironments(); }
 34 |   inline const ArenaStringPiece ENV(
 35 |       StringPiece key, ArenaStringPiece default_value = ""_a) const
 36 |       { return ENV().Get(key, default_value); }
 37 |   inline const HttpParameters& GET() const
 38 |       { return stream_->GetQueryParameters(); }
 39 |   inline const ArenaStringPiece GET(
 40 |       StringPiece key, ArenaStringPiece default_value = ""_a) const
 41 |       { return GET().Get(key, default_value); }
 42 |   inline const HttpParameters& POST() const
 43 |       { return stream_->GetPostParameters(); }
 44 |   inline const ArenaStringPiece POST(
 45 |       StringPiece key, ArenaStringPiece default_value = ""_a) const
 46 |       { return POST().Get(key, default_value); }
 47 |   inline const HttpParameters& COOKIE() const
 48 |       { return stream_->GetCookieParameters(); }
 49 |   inline const ArenaStringPiece COOKIE(
 50 |       StringPiece key, ArenaStringPiece default_value = ""_a) const
 51 |       { return COOKIE().Get(key, default_value); }
 52 |   inline const map<StringPiece, std::unique_ptr<HttpParameters>>& FILE() const
 53 |       { return stream_->GetFileParameters(); }
 54 |   inline const HttpParameters& FILE(StringPiece key) const {
 55 |     static HttpParameters http_parameters;
 56 |     const std::unique_ptr<HttpParameters>& file =
 57 |         FindWithDefault(FILE(), key, nullptr);
 58 |     return file != nullptr ? *file : http_parameters;
 59 |   }
 60 |   inline const Json& SESSION() const { return stream_->GetSessionParameters(); }
 61 | 
 62 |   //////////////////////////////////////////////////////////////////////////////
 63 |   // Response functions
 64 |   //////////////////////////////////////////////////////////////////////////////
 65 |   template<typename K, typename V>
 66 |   inline void SetHeader(K&& key, V&& value, bool overwrite = true) {
 67 |     MutableResponse()->SetHeader(key, value, overwrite);
 68 |   }
 69 |   template<typename... Args>
 70 |   inline void Print(Args&&... args) {
 71 |     MutableResponse()->Print(std::forward<Args>(args)...);
 72 |   }
 73 | 
 74 |   inline void SetCookie(
 75 |       StringPiece key, StringPiece value,
 76 |       int64 age = 0, StringPiece path = "/") {
 77 |     ArenaBuffer* buffer = MutableArena()->NextBuffer();
 78 |     UrlEncode(key, buffer);
 79 |     buffer->push_back('=');
 80 |     UrlEncode(value, buffer);
 81 |     if (age != 0) {
 82 |       buffer->append("; max-age="_a);
 83 |       buffer->StrCat(age);
 84 |     }
 85 |     if (!path.empty()) {
 86 |       buffer->append("; path="_a);
 87 |       buffer->append(path);
 88 |     }
 89 |     SetHeader("Set-Cookie"_a, *buffer, false);
 90 |   }
 91 | 
 92 |   void SetSessionData(const Json& value) {
 93 |     *stream_->MutableSessionParameters() = value;
 94 |     if (value.type() == Json::NUL) {
 95 |       SetCookie("session_data"_a, "", -1);
 96 |       return;
 97 |     }
 98 |     SetCookie("session_data"_a, Base64::UrlEncode(JsonEncode(value)));
 99 |   }
100 | 
101 |   // Sets a content-type and sends a file.
102 |   bool SendResource(StringPiece path, bool cache = true);
103 | 
104 |   // TODO(P1): Implement cache control.
105 | 
106 |   bool NotModified(StringPiece expected_etag = StringPiece());
107 | 
108 |   //////////////////////////////////////////////////////////////////////////////
109 |   // Accessors
110 |   //////////////////////////////////////////////////////////////////////////////
111 |   inline Stream* MutableStream() { return stream_; }
112 |   inline HttpContents* MutableRequest()
113 |       { return MutableStream()->MutableRequest(); }
114 |   inline HttpContents* MutableResponse()
115 |       { return MutableStream()->MutableResponse(); }
116 |   std::shared_ptr<Session> MutableSession();
117 | 
118 |  protected:
119 |   //////////////////////////////////////////////////////////////////////////////
120 |   // Interfaces
121 |   //////////////////////////////////////////////////////////////////////////////
122 |   virtual bool Run() { return false; }
123 |   virtual void PostProcess() {}
124 | 
125 |   virtual string ProfileName();
126 |   virtual void Profile(double cpu_time, double real_time);
127 | 
128 |   // For ArenaInterface.
129 |   Arena* MutableArena() override { return stream_->MutableArena(); }
130 | 
131 |  private:
132 |   bool SystemHandler();
133 | 
134 |   std::shared_ptr<Session> session_;
135 |   Stream* stream_;
136 | };
137 | 
138 | class BaseHandlerFactory {
139 |  public:
140 |   BaseHandlerFactory();
141 |   virtual ~BaseHandlerFactory() {}
142 | 
143 |   virtual BaseHandler* NewHandler() = 0;
144 |   void Run();
145 | 
146 |  private:
147 |   vector<std::thread> threads_;
148 | };
149 | 
150 | class HandlerPool {
151 |  public:
152 |   void Register(StringPiece prefix,
153 |                 const std::function<bool(BaseHandler*)>& handler);
154 | 
155 |   template<typename T>
156 |   typename std::enable_if<
157 |       std::is_base_of<BaseHandler, T>::value &&
158 |       !std::is_same<BaseHandler, T>::value,
159 |       void>::type
160 |       Register(StringPiece prefix, const std::function<bool(T*)>& handler) {
161 |     Register(prefix, [handler](BaseHandler* base_handler) {
162 |       T* original_handler = dynamic_cast<T*>(base_handler);
163 |       if (original_handler == nullptr) { return false; }
164 |       return handler(original_handler);
165 |     });
166 |   }
167 | 
168 |   template<typename T>
169 |   void Register(StringPiece prefix, bool(*handler)(T*)) {
170 |     Register(prefix, std::function<bool(T*)>(handler));
171 |   }
172 | 
173 |   bool Run(BaseHandler* stream);
174 | 
175 |   void PrintHandlers(StringPiece purpose);
176 | 
177 |  private:
178 |   multimap<StringPiece, std::function<bool(BaseHandler*)>> handlers_;
179 |   std::mutex handlers_mutex_;
180 | };
181 | 
182 | HandlerPool* GetHandlerPool();
183 | HandlerPool* GetFilterPool();
184 | 
185 | #define REGISTER_HANDLER(name, prefix, body) \
186 |     REGISTER_MODULE_INITIALIZER(name, { \
187 |       GetHandlerPool()->Register(prefix, body); });
188 | #define REGISTER_FILTER(name, prefix, body) \
189 |     REGISTER_MODULE_INITIALIZER(name, { \
190 |       GetFilterPool()->Register(prefix, body); });
191 | 


--------------------------------------------------------------------------------
/nineserver/sql/mysql.cc:
--------------------------------------------------------------------------------
  1 | #include "nineserver/sql/mysql.h"
  2 | 
  3 | #include <time.h>
  4 | 
  5 | #include "base/base.h"
  6 | 
  7 | DEFINE_string(mysql_host, "localhost", "MySQL's host name to connect.");
  8 | DEFINE_string(mysql_user, "root", "MySQL user.");
  9 | DEFINE_string(mysql_password, "", "MySQL password.");
 10 | DEFINE_string(mysql_database, "mysql", "Database to select.");
 11 | DEFINE_int32(mysql_port, 3306, "Port number to connect.");
 12 | DEFINE_string(mysql_socket, "", "UNIX domain socket.");
 13 | 
 14 | string ToSqlTimestamp(time_t time) {
 15 |   if (time < 0) {
 16 |     return "0000-00-00 00:00:00";
 17 |   }
 18 |   char buffer[20];
 19 |   struct tm tm;
 20 |   strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S",
 21 |            localtime_r(&time, &tm));
 22 |   return buffer;
 23 | }
 24 | 
 25 | time_t FromSqlTimestamp(StringPiece sql_timestamp) {
 26 |   if (sql_timestamp.size() != "0000-00-00 00:00:00"_a.size()) {
 27 |     return -1;
 28 |   }
 29 |   if (!isdigit(sql_timestamp[0]) || !isdigit(sql_timestamp[1]) ||
 30 |       !isdigit(sql_timestamp[2]) || !isdigit(sql_timestamp[3]) ||
 31 |       sql_timestamp[4] != '-' ||
 32 |       !isdigit(sql_timestamp[5]) || !isdigit(sql_timestamp[6]) ||
 33 |       sql_timestamp[7] != '-' ||
 34 |       !isdigit(sql_timestamp[8]) || !isdigit(sql_timestamp[9]) ||
 35 |       sql_timestamp[10] != ' ' ||
 36 |       !isdigit(sql_timestamp[11]) || !isdigit(sql_timestamp[12]) ||
 37 |       sql_timestamp[13] != ':' ||
 38 |       !isdigit(sql_timestamp[14]) || !isdigit(sql_timestamp[15]) ||
 39 |       sql_timestamp[16] != ':' ||
 40 |       !isdigit(sql_timestamp[17]) || !isdigit(sql_timestamp[18])) {
 41 |     return -1;
 42 |   }
 43 |   struct tm t;
 44 |   t.tm_year = (sql_timestamp[0] & 15) * 1000 +
 45 |               (sql_timestamp[1] & 15) * 100 +
 46 |               (sql_timestamp[2] & 15) * 10 +
 47 |               (sql_timestamp[3] & 15) - 1900;
 48 |   t.tm_mon = (sql_timestamp[5] & 15) * 10 + (sql_timestamp[6] & 15) - 1;
 49 |   t.tm_mday = (sql_timestamp[8] & 15) * 10 + (sql_timestamp[9] & 15);
 50 |   t.tm_hour = (sql_timestamp[11] & 15) * 10 + (sql_timestamp[12] & 15);
 51 |   t.tm_min = (sql_timestamp[14] & 15) * 10 + (sql_timestamp[15] & 15);
 52 |   t.tm_sec = (sql_timestamp[17] & 15) * 10 + (sql_timestamp[18] & 15);
 53 |   t.tm_wday = 0;
 54 |   t.tm_yday = 0;
 55 |   t.tm_isdst = 0;
 56 |   return mktime(&t);
 57 | }
 58 | 
 59 | Json QueryResult::ToJson() const {
 60 |   vector<Json> json;
 61 |   {
 62 |     vector<Json> fields;
 63 |     for (int field_index = 0; field_index < num_fields; field_index++) {
 64 |       fields.push_back(Json(Field(field_index)));
 65 |     }
 66 |     json.push_back(Json(std::move(fields)));
 67 |   }
 68 |   for (int row_index = 0; row_index < num_rows; row_index++) {
 69 |     vector<Json> row;
 70 |     for (int field_index = 0; field_index < num_fields; field_index++) {
 71 |       ArenaStringPiece cell = Get(row_index, field_index);
 72 |       if (IsNull(cell)) {
 73 |         row.push_back(Json(nullptr));
 74 |       } else {
 75 |         row.push_back(Json(cell));
 76 |       }
 77 |     }
 78 |     json.push_back(Json(row));
 79 |   }
 80 |   return json;
 81 | }
 82 | 
 83 | ArenaStringPiece QueryResult::Null() {
 84 |   static const char* mysql_null = "\0MYSQL_NULL";
 85 |   return ArenaStringPiece(StringPiece(mysql_null, 0));
 86 | }
 87 | 
 88 | bool QueryResult::IsNull(StringPiece value) {
 89 |   return Null().data() == value.data();
 90 | }
 91 | 
 92 | MYSQL* MySQL::Connect() {
 93 |   thread_local MYSQL* connection = nullptr;
 94 |   if (connection == nullptr) {
 95 |     connection = mysql_init(nullptr);
 96 |     if (!mysql_real_connect(
 97 |         connection, FLAGS_mysql_host.c_str(), FLAGS_mysql_user.c_str(),
 98 |         FLAGS_mysql_password.empty() ? nullptr : FLAGS_mysql_password.c_str(),
 99 |         FLAGS_mysql_database.c_str(), FLAGS_mysql_port,
100 |         FLAGS_mysql_socket.empty() ? nullptr : FLAGS_mysql_socket.c_str(), 0)) {
101 |       LOG_FIRST_N(ERROR, 10)
102 |           << "Failed to connect SQL server: " << mysql_error(connection);
103 |       connection = nullptr;
104 |     }
105 |     if (mysql_set_character_set(connection, "utf8") != 0) {
106 |       LOG_FIRST_N(ERROR, 10) << "Failed to set character set.";
107 |     }
108 |   }
109 |   return connection;
110 | }
111 | 
112 | bool MySQL::Command(StringPiece query) {
113 |   MYSQL* connection = Query(query);
114 |   if (connection == nullptr) { return false; }
115 |   MYSQL_RES* result = mysql_store_result(connection);
116 |   if (result != nullptr) { mysql_free_result(result); }
117 |   return true;
118 | }
119 | 
120 | QueryResult MySQL::SelectAll(StringPiece query, ArenaBuffer* arena_buffer) {
121 |   MYSQL* connection = Query(query);
122 |   if (connection == nullptr) { return QueryResult{}; }
123 |   MYSQL_RES* result = mysql_store_result(connection);
124 |   if (result == nullptr) { return QueryResult{}; }
125 |   QueryResult query_result;
126 |   query_result.num_rows = mysql_num_rows(result);
127 |   query_result.num_fields = mysql_num_fields(result);
128 |   if (arena_buffer == nullptr) {
129 |     query_result.arena_buffer.reset(new ArenaBuffer);
130 |     arena_buffer = query_result.arena_buffer.get();
131 |   }
132 |   query_result.data.reset(new ArenaStringPiece[
133 |       static_cast<int64>(query_result.num_rows + 1) * query_result.num_fields]);
134 |   MYSQL_FIELD* fields = mysql_fetch_fields(result);
135 |   for (int field_id = 0; field_id < query_result.num_fields; field_id++) {
136 |     arena_buffer->Init();
137 |     arena_buffer->append(StringPiece(fields[field_id].name));
138 |     query_result.data[field_id] = *arena_buffer;
139 |   }
140 |   for (int row_id = 0; row_id < query_result.num_rows; row_id++) {
141 |     MYSQL_ROW row = mysql_fetch_row(result);
142 |     if (row == nullptr) {
143 |       query_result.num_rows = row_id;
144 |       break;
145 |     }
146 |     auto* lengths = mysql_fetch_lengths(result);
147 |     for (int field_id = 0; field_id < query_result.num_fields; field_id++) {
148 |       arena_buffer->Init();
149 |       arena_buffer->resize(lengths[field_id]);
150 |       memcpy(arena_buffer->data(), row[field_id], arena_buffer->size());
151 |       query_result.data[(row_id + 1) * query_result.num_fields + field_id] =
152 |           row[field_id] == nullptr ? QueryResult::Null() : *arena_buffer;
153 |     }
154 |   }
155 |   mysql_free_result(result);
156 |   return query_result;
157 | }
158 | 
159 | MYSQL* MySQL::Query(StringPiece query) {
160 |   MYSQL* connection = Connect();
161 |   if (connection == nullptr) { return nullptr; }
162 |   if (mysql_real_query(connection, query.data(), query.size()) != 0) {
163 |     LOG(WARNING) << mysql_error(connection) << ": " << query;
164 |     return nullptr;
165 |   }
166 |   return connection;
167 | }
168 | 
169 | int64 MySQL::GetAffectedRows() {
170 |   MYSQL* connection = Connect();
171 |   if (connection == nullptr) { return -1; }
172 |   return static_cast<int64>(mysql_affected_rows(connection));
173 | }
174 | 
175 | int64 MySQL::GetInsertId() {
176 |   MYSQL* connection = Connect();
177 |   if (connection == nullptr) { return -1; }
178 |   return static_cast<int64>(mysql_insert_id(connection));
179 | }
180 | 
181 | bool MySQL::Escape(StringPiece data, BufferInterface* buffer) {
182 |   MYSQL* connection = Connect();
183 |   if (connection == nullptr) { return false; }
184 |   char output[data.size() * 2 + 1];
185 |   int64 length = mysql_real_escape_string(
186 |       connection, output, data.data(), data.size());
187 |   buffer->append(StringPiece(output, length));
188 |   return true;
189 | }
190 | 
191 | string MySQL::Escape(StringPiece data) {
192 |   string result;
193 |   StringBuffer buffer(&result);
194 |   Escape(data, &buffer);
195 |   return result;
196 | }
197 | 


--------------------------------------------------------------------------------
/nineserver/http/util.cc:
--------------------------------------------------------------------------------
  1 | #include "nineserver/http/util.h"
  2 | 
  3 | #include <chrono>
  4 | 
  5 | #include "time_zone.h"
  6 | 
  7 | string ToHttpDateTime(time_t time) {
  8 |   char buffer[100];
  9 |   struct tm tm;
 10 |   strftime(buffer, sizeof(buffer), "%a, %d %b %Y %H:%M:%S GMT",
 11 |            gmtime_r(&time, &tm));
 12 |   return buffer;
 13 | }
 14 | 
 15 | time_t FromHttpDateTime(const string& http_date_time) {
 16 |   string formatted_time;
 17 |   cctz::time_zone lax;
 18 |   if (TryStripSuffixString(http_date_time, " UTC", &formatted_time) ||
 19 |       TryStripSuffixString(http_date_time, " GMT", &formatted_time)) {
 20 |     load_time_zone("UTC", &lax);
 21 |   } else if (TryStripSuffixString(http_date_time, " JST", &formatted_time)) {
 22 |     load_time_zone("Asia/Tokyo", &lax);
 23 |   } else if (TryStripSuffixString(http_date_time, " PST", &formatted_time) ||
 24 |              TryStripSuffixString(http_date_time, " PDT", &formatted_time)) {
 25 |     load_time_zone("America/Los_Angeles", &lax);
 26 |   } else if (TryStripSuffixString(http_date_time, " EST", &formatted_time) ||
 27 |              TryStripSuffixString(http_date_time, " EDT", &formatted_time)) {
 28 |     load_time_zone("America/New_York", &lax);
 29 |   } else if (TryStripSuffixString(http_date_time, " CST", &formatted_time) ||
 30 |              TryStripSuffixString(http_date_time, " CDT", &formatted_time)) {
 31 |     load_time_zone("America/Chicago", &lax);
 32 |   } else {
 33 |     return static_cast<time_t>(0);
 34 |   }
 35 | 
 36 |   std::chrono::system_clock::time_point tp;
 37 |   if (!cctz::parse("%a, %d %b %Y %H:%M:%S", formatted_time, lax, &tp)) {
 38 |     return static_cast<time_t>(0);
 39 |   }
 40 | 
 41 |   return std::chrono::system_clock::to_time_t(tp);
 42 | }
 43 | 
 44 | const map<StringPiece, string>& GetMimeTypes() {
 45 |   static map<StringPiece, string>* mime_types = new map<StringPiece, string>({
 46 |       {"html", "text/html"},
 47 |       {"htm", "text/html"},
 48 |       {"shtml", "text/html"},
 49 |       {"css", "text/css"},
 50 |       {"xml", "text/xml"},
 51 |       {"gif", "image/gif"},
 52 |       {"jpeg", "image/jpeg"},
 53 |       {"jpg", "image/jpeg"},
 54 |       {"js", "application/javascript"},
 55 |       {"atom", "application/atom+xml"},
 56 |       {"rss", "application/rss+xml"},
 57 |       {"mml", "text/mathml"},
 58 |       {"txt", "text/plain"},
 59 |       {"jad", "text/vnd.sun.j2me.app-descriptor"},
 60 |       {"wml", "text/vnd.wap.wml"},
 61 |       {"htc", "text/x-component"},
 62 |       {"png", "image/png"},
 63 |       {"tif", "image/tiff"},
 64 |       {"tiff", "image/tiff"},
 65 |       {"wbmp", "image/vnd.wap.wbmp"},
 66 |       {"ico", "image/x-icon"},
 67 |       {"jng", "image/x-jng"},
 68 |       {"bmp", "image/x-ms-bmp"},
 69 |       {"svgz", "image/svg+xml svg"},
 70 |       {"webp", "image/webp"},
 71 |       {"woff", "application/font-woff"},
 72 |       {"jar", "application/java-archive"},
 73 |       {"war", "application/java-archive"},
 74 |       {"ear", "application/java-archive"},
 75 |       {"json", "application/json"},
 76 |       {"hqx", "application/mac-binhex40"},
 77 |       {"doc", "application/msword"},
 78 |       {"pdf", "application/pdf"},
 79 |       {"ps", "application/postscript"},
 80 |       {"eps", "application/postscript"},
 81 |       {"ai", "application/postscript"},
 82 |       {"rtf", "application/rtf"},
 83 |       {"m3u8", "application/vnd.apple.mpegurl"},
 84 |       {"xls", "application/vnd.ms-excel"},
 85 |       {"eot", "application/vnd.ms-fontobject"},
 86 |       {"ppt", "application/vnd.ms-powerpoint"},
 87 |       {"wmlc", "application/vnd.wap.wmlc"},
 88 |       {"kml", "application/vnd.google-earth.kml+xml"},
 89 |       {"kmz", "application/vnd.google-earth.kmz"},
 90 |       {"7z", "application/x-7z-compressed"},
 91 |       {"cco", "application/x-cocoa"},
 92 |       {"jardiff", "application/x-java-archive-diff"},
 93 |       {"jnlp", "application/x-java-jnlp-file"},
 94 |       {"run", "application/x-makeself"},
 95 |       {"pl", "application/x-perl"},
 96 |       {"pm", "application/x-perl"},
 97 |       {"prc", "application/x-pilot"},
 98 |       {"pdb", "application/x-pilot"},
 99 |       {"rar", "application/x-rar-compressed"},
100 |       {"rpm", "application/x-redhat-package-manager"},
101 |       {"sea", "application/x-sea"},
102 |       {"swf", "application/x-shockwave-flash"},
103 |       {"sit", "application/x-stuffit"},
104 |       {"tcl", "application/x-tcl"},
105 |       {"tk", "application/x-tcl"},
106 |       {"der", "application/x-x509-ca-cert"},
107 |       {"pem", "application/x-x509-ca-cert"},
108 |       {"crt", "application/x-x509-ca-cert"},
109 |       {"xpi", "application/x-xpinstall"},
110 |       {"xhtml", "application/xhtml+xml"},
111 |       {"xspf", "application/xspf+xml"},
112 |       {"zip", "application/zip"},
113 |       {"bin", "application/octet-stream"},
114 |       {"exe", "application/octet-stream"},
115 |       {"dll", "application/octet-stream"},
116 |       {"deb", "application/octet-stream"},
117 |       {"dmg", "application/octet-stream"},
118 |       {"iso", "application/octet-stream"},
119 |       {"img", "application/octet-stream"},
120 |       {"msi", "application/octet-stream"},
121 |       {"msp", "application/octet-stream"},
122 |       {"msm", "application/octet-stream"},
123 |       {"docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
124 |       {"xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
125 |       {"pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"},
126 |       {"mid", "audio/midi"},
127 |       {"midi", "audio/midi"},
128 |       {"kar", "audio/midi"},
129 |       {"mp3", "audio/mpeg"},
130 |       {"ogg", "audio/ogg"},
131 |       {"m4a", "audio/x-m4a"},
132 |       {"ra", "audio/x-realaudio"},
133 |       {"3gp", "video/3gpp 3gpp"},
134 |       {"ts", "video/mp2t"},
135 |       {"mp4", "video/mp4"},
136 |       {"mpeg", "video/mpeg"},
137 |       {"mpg", "video/mpeg"},
138 |       {"mov", "video/quicktime"},
139 |       {"webm", "video/webm"},
140 |       {"flv", "video/x-flv"},
141 |       {"m4v", "video/x-m4v"},
142 |       {"mng", "video/x-mng"},
143 |       {"asx", "video/x-ms-asf"},
144 |       {"asf", "video/x-ms-asf"},
145 |       {"wmv", "video/x-ms-wmv"},
146 |       {"avi", "video/x-msvideo"},
147 |   });
148 |   return *mime_types;
149 | }
150 | 
151 | ArenaStringPiece GetMimeType(StringPiece extension) {
152 |   const string* mime_type = FindOrNull(GetMimeTypes(), extension);
153 |   if (mime_type == nullptr) {
154 |     return ArenaStringPiece();
155 |   }
156 |   return ArenaStringPiece(StringPiece(*mime_type));
157 | }
158 | 
159 | void SplitHeader(StringPiece header, StringPiece* key, StringPiece* value,
160 |                  StringPiece* trailing) {
161 |   if (header.starts_with(" "_a)) {
162 |     header.remove_prefix(1);
163 |   }
164 | 
165 |   int64 position = 0;
166 |   while (position < header.size()) {
167 |     auto semicolon_position = header.find(';', position);
168 |     if (semicolon_position == StringPiece::npos) {
169 |       position = header.size();
170 |       break;
171 |     }
172 |     auto quote_position =
173 |         header.substr(0, semicolon_position).find('"', position);
174 |     if (quote_position == StringPiece::npos) {
175 |       position = semicolon_position;
176 |       break;
177 |     }
178 |     quote_position = header.find('"', quote_position + 1);
179 |     if (quote_position == StringPiece::npos) {
180 |       position = header.size();
181 |       break;
182 |     }
183 |     position = quote_position + 1;
184 |   }
185 |   StringPiece piece;
186 |   if (position < header.size()) {
187 |     DCHECK_EQ(header[position], ';');
188 |     piece = header.substr(0, position);
189 |     *trailing = header.substr(position + 1);
190 |   } else {
191 |     piece = header;
192 |     *trailing = ""_a;
193 |   }
194 | 
195 |   if (!SplitToStringPieces(piece, '=', key, value)) {
196 |     *key = ""_a;
197 |     *value = piece;
198 |   }
199 |   if (value->size() >= 2 && *value->begin() == '"' && *value->rbegin() == '"') {
200 |     value->remove_prefix(1);
201 |     value->remove_suffix(1);
202 |   }
203 | }
204 | 


--------------------------------------------------------------------------------