docs: further setting up structure

backend/include/bs-utility.h

@@ -5,6 +5,7 @@
 #include <exception>
 #include <mutex>
 #include <sstream>
+#include <stack>
 #include <stdexcept>
 #include <string>
 #include <thread>
@@ -42,7 +43,10 @@ template <typename T>
 BlockingStringStream &BlockingStringStream::operator<<(const T &val) {
   {
     std::lock_guard<std::mutex> lock(mutex);
-    if (internalStream.peek() == EOF) internalStream.clear();
+    if (internalStream.peek() == EOF) {
+      internalStream.clear();
+      internalStream.str("");
+    }
     internalStream << val;
   }
   condition.notify_one();
@@ -61,4 +65,10 @@ BlockingStringStream &BlockingStringStream::operator>>(T &val) {
 
   return *this;
 }
+
+class SessionClass {
+  std::stack<int> login_stack;
+  std::string SessionToken;
+  std::string OuthorizationKey;
+};
 #endif  // PROTECTOR_UTILITY_H

backend/include/engine.h

@@ -1,4 +1,11 @@
 #ifndef PROTECTOR_ENGINE_H
 #define PROTECTOR_ENGINE_H
+#include <string>
+class BookStoreEngineClass {
+  std::string config_dir;
 
-#endif // PROTECTOR_ENGINE_H
+ public:
+  BookStoreEngineClass() = delete;
+  BookStoreEngineClass(std::string config_dir) : config_dir(config_dir) {}
+};
+#endif  // PROTECTOR_ENGINE_H

backend/include/schedule.h

@@ -1,4 +1,23 @@
 #ifndef PROTECTOR_SCHEDULE_H
 #define PROTECTOR_SCHEDULE_H
+#include <string>
 
-#endif // PROTECTOR_SCHEDULE_H
+#include "bs-utility.h"
+#include "engine.h"
+class BookStoreBackEndClass {
+  std::string config_dir;
+  BlockingStringStream *input_ptr;
+  BlockingStringStream *output_ptr;
+  BookStoreEngineClass *engine_ptr;
+
+ public:
+  BookStoreBackEndClass() = delete;
+  BookStoreBackEndClass(std::string config_dir, BlockingStringStream *input_ptr,
+                        BlockingStringStream *output_ptr)
+      : config_dir(config_dir), input_ptr(input_ptr), output_ptr(output_ptr) {
+    engine_ptr = new BookStoreEngineClass(config_dir);
+  }
+  ~BookStoreBackEndClass() { delete engine_ptr; }
+  void Run();
+};
+#endif  // PROTECTOR_SCHEDULE_H

backend/src/builtin-cli.cpp

@@ -2,15 +2,34 @@
 
 #include <iostream>
 
-#include "schedule.h"
 #include "bs-utility.h"
+#include "schedule.h"
 void BookStoreMain(bool is_server, std::string config_dir) {
   std::ios::sync_with_stdio(false);
   if (!is_server) {
     ;  // TODO: run as client
   } else {
-    throw FatalError("Server mode is not implemented yet", 1);
     std::cin.tie(nullptr);
     std::cout.rdbuf(nullptr);
+    BlockingStringStream input;
+    BlockingStringStream output;
+    BookStoreBackEndClass backend(config_dir, &input, &output);
+    std::thread backend_thread([&backend]() { backend.Run(); });
+    std::thread input_thread([&input]() {
+      std::string data;
+      while (std::getline(std::cin, data)) {
+        input << data << '\n';
+      }
+    });
+    std::thread output_thread([&output]() {
+      std::string data;
+      while (true) {
+        output.getline(data, '\n');
+        std::cout << data << std::endl;
+      }
+    });
+    input_thread.join();
+    output_thread.join();
+    backend_thread.join();
   }
 }

backend/src/main.cpp

@@ -7,27 +7,27 @@
 void test() {
   BlockingStringStream bss;
 
+  std::thread reader([&bss]() {
+    std::string data;
+    for (int i = 1; i <= 5; ++i) {
+      // Use getline with string delimiter
+      bss.getline(data, '\n');
+      std::cerr << "Received: " << data << std::endl;
+    }
+  });
+  std::this_thread::sleep_for(std::chrono::seconds(1));
   std::thread writer([&bss]() {
     for (int i = 1; i <= 5; ++i) {
       bss << "Data " << i << '\n';
       std::this_thread::sleep_for(std::chrono::seconds(1));
     }
   });
-
-  std::thread reader([&bss]() {
-    std::string data;
-    for (int i = 1; i <= 5; ++i) {
-      // Use getline with string delimiter
-      bss.getline(data, '\n');
-      std::cout << "Received: " << data << std::endl;
-    }
-  });
   reader.join();
   writer.join();
 }
 int main(int argc, char **argv) {
-  test();
-  return 0;
+  // test();
+  // return 0;
   bool is_server = false;
   std::string config_dir = "";
   bool custom_config_dir = false;

backend/src/schedule.cpp

@@ -1,2 +1,13 @@
 #include "schedule.h"
 #include "engine.h"
+
+void BookStoreBackEndClass::Run()
+{
+  std::string request_data;
+  while(true)
+  {
+    input_ptr->getline(request_data, '\n');
+    // std::string response_data = Engine::Process(request_data);
+    // output_ptr << response_data << '\n';
+  }
+}

docs/develop/总体设计文档.md

@@ -47,14 +47,14 @@ memoryriver类维护一个缓存，简单地缓存高频访问和连续访问；
 实际的文件操作只由一个线程负责，万级的IOPS足够应付需求；内存中的资源，
 
 ### 引擎模块
-具体执行业务，一次请求对应且只对应一次引擎模块API调用，支持并行（API阻塞但可同时运行）。当API入口函数被调用后，执行相关具体操作（包括会话管理），然后返回响应。
+具体执行业务，一次请求对应且只对应一次引擎模块API调用，支持并行（API阻塞但可同时运行）。当API入口函数被调用后，执行相关具体操作（不包括会话管理、鉴权），然后返回响应。
 
 ### 调度模块
 负责对外提供文本模式的交互，以及维护请求级的并行。从流`request`读取文本格式的命令，并把内部数据格式的响应翻译成文本格式，向引擎模块发送请求（调用引擎模块对外提供的API），并把响应返回到流`response`。支持条件允许时的并行：
 - 输入子模块从`request`读取请求，打上时间戳，分独占式请求和可并行请求按时间戳顺序分批处理。处理一个请求时，启动一个工作线程调用翻译执行子模块。同一个会话的请求不可并行，把`std::thread`move进相应的该会话的工作线程句柄队列，下一个join前一个。成批执行可并行请求时，启动完当前批次所有工作线程后join每个session的最后一个工作线程，结束之后就可以执行下一批了。为了在服务模式下处理时有时无的请求，两个流在读取时是阻塞的（自己封装一个，用`std::condition_variable`通讯），并且读一个处理一个，碰到“不属于自己批次”的东西才算一批结束。
 - 翻译执行子模块(入口函数本身阻塞)join完同一个session的上一个请求后，向引擎模块API发送请求，得到响应后把响应数据传给输出子模块的调用接口(阻塞但可并行，处理部分同时运行，上锁后直接输出到`response`，输出本身不同时进行)。
 
-注意，在`request`流和`response`流中，输入输出仅保证单个请求/响应是完整的，多个请求/响应之间是完全“混杂”的，通过`session token`、`operation token`（操作标识由用户侧会话管理器维护，~~反正`session token`已经划分频道了，用户开F12瞎改后果自负~~）区分，通过`outhentication key`鉴权。`request`流和`response`流始终由信模块控制。注意，通讯模块不负责会话管理。
+注意，在`request`流和`response`流中，输入输出仅保证单个请求/响应是完整的，多个请求/响应之间是完全“混杂”的，通过`session token`、`operation token`（操作标识由用户侧会话管理器维护，~~反正`session token`已经划分频道了，用户开F12瞎改后果自负~~）区分，通过`outhentication key`鉴权。`request`流和`response`流始终由信模块控制。调度模块负责会话管理、鉴权，保证引擎只接受形式合法的简单内部数据。
 
 ### 内置交互模块
 当处于server模式下，不负责会话管理，直接把`std::cin`和`std::cout`的内容转发给通信与调度模块；处于interactive模式下时，提供用户侧会话管理，然后再调用通信与调度模块。
@@ -74,10 +74,10 @@ memoryriver类维护一个缓存，简单地缓存高频访问和连续访问；
 
 # 用户交互设计
 ## 内置命令
-- `# OpenSession <TempChannelID>`：向引擎申请一个新会话
-- `# CloseSession <SessionToken> <OuthenticationKey>`：显示地告知引擎停止某个会话
+- `# OpenSession <TempChannelID>`：向调度模块申请一个新会话
+- `# CloseSession <SessionToken> <OuthenticationKey>`：显示地告知调度模块停止某个会话
 - `# ReRequest <SessionToken> <OperationToken> <OuthenticationKey>`：向服务端重新请求调取某次操作响应的缓存
-- `# Request <SessionToken> <OuthenticationKey> # <UserCommand>`：向引擎发送一个请求
+- `# Request <SessionToken> <OuthenticationKey> # <UserCommand>`：向后端发送一个请求
 
 ## 向用户提供的命令
 - `SU <UserName> <Password>`：登录某个用户（登录栈+1）
@@ -100,7 +100,7 @@ memoryriver类维护一个缓存，简单地缓存高频访问和连续访问；
 
 # 底层数据接口约定（类、结构体设计）
 ## 请求
-- 引擎接受：内部数据`struct RequestType { std::string SessionToKen, OperationToken, AuthenticationKey; std::any content; };`
+- 引擎接受：内部数据`struct RequestType { RequestKindType requestkind; std::any content; };`
 - 调度模块接受：`! <SessionToken> <OperationToken> <AuthenticationKey> ! <RequestContent>`
 - 内置交互模块（interactive模式）接受：字符串，`<RequestContent>`
 - 云命令行接受：字符串，`<RequestContent>`
@@ -108,7 +108,7 @@ memoryriver类维护一个缓存，简单地缓存高频访问和连续访问；
 
 ## 响应
 注意，对于申请Session时，响应用`<TempChannelID>`替代`<SessionToken`，返回信息内容是`SessionToken`和`AuthenticationKey`。
-- 引擎返回：内部数据，`struct ResponseType { int code; std::string SessionToken, OperationToken; std::any content; };`
+- 引擎返回：内部数据，`struct ResponseType { int code; std::any content; };`
 - 调度模块返回：字符串，`! <SessionToken> <OperationToken> <Code> ! <ResponseContent>`
 - 内置交互模块（interactive模式）返回：字符串，`<ResponseContent>`
 - 云命令行返回：字符串，`<ResponseContent>`