use replxx instead of readline

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "deps/3rd/benchmark"]
 	path = deps/3rd/benchmark
 	url = https://github.com/google/benchmark
+[submodule "deps/3rd/replxx"]
+	path = deps/3rd/replxx
+	url = https://github.com/AmokHuginnsson/replxx

CMakeLists.txt

@@ -34,7 +34,6 @@ OPTION(USE_SIMD "Use SIMD" OFF)
 OPTION(USE_MUSL_LIBC "Use musl libc" OFF)
 OPTION(WITH_CPPLINGS "Compile cpplings" ON)
 
-
 MESSAGE(STATUS "HOME dir: $ENV{HOME}")
 #SET(ENV{变量名} 值)
 IF(WIN32)
@@ -172,6 +171,11 @@ SET(CMAKE_C_FLAGS ${CMAKE_COMMON_FLAGS})
 
 MESSAGE(STATUS "CMAKE_CXX_FLAGS is " ${CMAKE_CXX_FLAGS})
 
+# Line Reading configs
+MESSAGE(STATUS "Using replxx for line reading")
+FIND_PACKAGE(Threads REQUIRED)
+FIND_PACKAGE(replxx REQUIRED)
+
 # ADD_SUBDIRECTORY(src bin)  bin 为目标目录， 可以省略
 # ADD_SUBDIRECTORY(deps)
 ADD_SUBDIRECTORY(src)
@@ -184,4 +188,3 @@ ENDIF(WITH_BENCHMARK)
 IF(WITH_UNIT_TESTS)
     ADD_SUBDIRECTORY(unittest)
 ENDIF(WITH_UNIT_TESTS)
-

build.sh

@@ -108,7 +108,15 @@ function do_init
     mkdir -p build && \
     cd build && \
     ${CMAKE_COMMAND_THIRD_PARTY} -DJSONCPP_WITH_TESTS=OFF -DJSONCPP_WITH_POST_BUILD_UNITTEST=OFF .. && \
-    ${MAKE_COMMAND} && \
+    ${MAKE_COMMAND} -j4 && \
+    ${MAKE_COMMAND} install
+
+  # build replxx
+  cd ${TOPDIR}/deps/3rd/replxx && \
+    mkdir -p build && \
+    cd build && \
+    ${CMAKE_COMMAND_THIRD_PARTY} .. -DCMAKE_BUILD_TYPE=Release -DREPLXX_BUILD_EXAMPLES=OFF -DREPLXX_BUILD_PACKAGE=OFF && \
+    ${MAKE_COMMAND} -j4 && \
     ${MAKE_COMMAND} install
 
   cd $current_dir

docker/Dockerfile

@@ -19,7 +19,7 @@ RUN apt-get update && apt-get install -y locales apt-utils && rm -rf /var/lib/ap
 #     && apt-get update
 
 RUN apt-get update \
-    && apt-get install -y build-essential gdb cmake git wget flex texinfo libreadline-dev diffutils bison \
+    && apt-get install -y build-essential gdb cmake git wget flex texinfo diffutils bison \
     && apt-get install -y clang-format vim sudo
 
 RUN apt-get install -y openssh-server

src/common/CMakeLists.txt

@@ -12,6 +12,9 @@ IF(USE_MUSL_LIBC)
     TARGET_LINK_LIBRARIES(common execinfo)
 ENDIF(USE_MUSL_LIBC)
 
+TARGET_LINK_LIBRARIES(common replxx::replxx)
+MESSAGE(STATUS "common uses replxx")
+
 # 编译静态库时，自动会把同名的动态库给删除， 因此需要临时设置一下
 SET_TARGET_PROPERTIES(common PROPERTIES CLEAN_DIRECT_OUTPUT 1)
 

src/common/linereader/line_reader.cpp

@@ -0,0 +1,87 @@
+/* Copyright (c) 2021 OceanBase and/or its affiliates. All rights reserved.
+miniob is licensed under Mulan PSL v2.
+You can use this software according to the terms and conditions of the Mulan PSL v2.
+You may obtain a copy of Mulan PSL v2 at:
+         http://license.coscl.org.cn/MulanPSL2
+THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+See the Mulan PSL v2 for more details. */
+
+//
+// Created by Willaaaaaaa in 2025
+//
+
+#include "common/linereader/line_reader.h"
+#include "common/lang/string.h"
+
+namespace common {
+MiniobLineReader::MiniobLineReader() : history_file_(""), previous_history_save_time_(0), history_save_interval_(5) {}
+
+MiniobLineReader::~MiniobLineReader() { reader_.history_save(history_file_); }
+
+MiniobLineReader &MiniobLineReader::instance()
+{
+  static MiniobLineReader instance;
+  return instance;
+}
+
+void MiniobLineReader::init(const std::string &history_file)
+{
+  history_file_ = history_file;
+  reader_.history_load(history_file_);
+}
+
+std::string MiniobLineReader::my_readline(const std::string &prompt)
+{
+  const char *cinput = nullptr;
+  cinput             = reader_.input(prompt);
+  if (cinput == nullptr) {
+    return "";
+  }
+
+  std::string line = cinput;
+  cinput           = nullptr;
+
+  if (line.empty()) {
+    return "";
+  }
+
+  bool is_valid_input = false;
+  for (auto c : line) {
+    if (!isspace(c)) {
+      is_valid_input = true;
+      break;
+    }
+  }
+
+  if (is_valid_input) {
+    reader_.history_add(line);
+    check_and_save_history();
+  }
+
+  return line;
+}
+
+bool MiniobLineReader::is_exit_command(const std::string &cmd)
+{
+  std::string lower_cmd = cmd;
+  common::str_to_lower(lower_cmd);
+
+  bool is_exit = lower_cmd.compare(0, 4, "exit") == 0 || lower_cmd.compare(0, 3, "bye") == 0 ||
+                 lower_cmd.compare(0, 2, "\\q") == 0 || lower_cmd.compare(0, 11, "interrupted") == 0;
+
+  return is_exit;
+}
+
+bool MiniobLineReader::check_and_save_history()
+{
+  time_t current_time = time(nullptr);
+  if (current_time - previous_history_save_time_ > history_save_interval_) {
+    reader_.history_save(history_file_);
+    previous_history_save_time_ = current_time;
+    return true;
+  }
+  return false;
+}
+}  // namespace common

src/common/linereader/line_reader.h

@@ -0,0 +1,75 @@
+/* Copyright (c) 2021 OceanBase and/or its affiliates. All rights reserved.
+miniob is licensed under Mulan PSL v2.
+You can use this software according to the terms and conditions of the Mulan PSL v2.
+You may obtain a copy of Mulan PSL v2 at:
+         http://license.coscl.org.cn/MulanPSL2
+THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+See the Mulan PSL v2 for more details. */
+
+//
+// Created by Willaaaaaaa in 2025
+//
+
+#ifndef COMMON_LINE_READER_H
+#define COMMON_LINE_READER_H
+
+#include "replxx.hxx"
+
+namespace common {
+/**
+ * @brief A singleton class for line-reading, providing an interface to replxx。
+ */
+class MiniobLineReader
+{
+  // The following private methods guarantee it's Singleton pattern
+private:
+  MiniobLineReader();
+  ~MiniobLineReader();
+  MiniobLineReader(const MiniobLineReader &)            = delete;
+  MiniobLineReader &operator=(const MiniobLineReader &) = delete;
+
+public:
+  /**
+   * @brief Get the singleton instance
+   * @return Reference to the singleton instance
+   */
+  static MiniobLineReader &instance();
+
+  /**
+   * @brief Initialize the lineReader with history file
+   * @param history_file path/to/file
+   */
+  void init(const std::string &history_file);
+
+  /**
+   * @brief Read a line from input
+   * @param prompt The prompt to display
+   * @return input string
+   */
+  std::string my_readline(const std::string &prompt);
+
+  /**
+   * @brief Check if the command is an exit command
+   * @param cmd The input command
+   * @return True if the command is an exit command
+   */
+  bool is_exit_command(const std::string &cmd);
+
+private:
+  /**
+   * @brief Check if history should be auto-saved
+   * @return True if history should be saved due to time interval
+   */
+  bool check_and_save_history();
+
+private:
+  replxx::Replxx reader_;
+  std::string    history_file_;
+  time_t         previous_history_save_time_;
+  int            history_save_interval_;
+};
+}  // namespace common
+
+#endif  // COMMON_LINE_READER_H

src/obclient/CMakeLists.txt

@@ -1,18 +1,6 @@
 ADD_EXECUTABLE(obclient)
 MESSAGE("Begin to build " obclient)
 
-INCLUDE(readline)
-MINIOB_FIND_READLINE()
-
-IF (HAVE_READLINE)
-    TARGET_LINK_LIBRARIES(obclient ${READLINE_LIBRARY})
-    TARGET_INCLUDE_DIRECTORIES(obclient PRIVATE ${READLINE_INCLUDE_DIR})
-    ADD_DEFINITIONS(-DUSE_READLINE)
-    MESSAGE ("obclient use readline")
-ELSE ()
-    MESSAGE ("readline is not found")
-ENDIF()
-
 FILE(GLOB_RECURSE ALL_SRC *.cpp)
 FOREACH (F ${ALL_SRC})
 

src/obclient/client.cpp

@@ -29,72 +29,16 @@ See the Mulan PSL v2 for more details. */
 
 #include "common/defs.h"
 #include "common/lang/string.h"
-
-#ifdef USE_READLINE
-#include "readline/history.h"
-#include "readline/readline.h"
-#endif
+#include "common/linereader/line_reader.h"
+#include "common/log/log.h"
 
 #define MAX_MEM_BUFFER_SIZE 8192
 #define PORT_DEFAULT 6789
 
 using namespace std;
 using namespace common;
 
-#ifdef USE_READLINE
-const string HISTORY_FILE            = string(getenv("HOME")) + "/.miniob.history";
-time_t       last_history_write_time = 0;
-
-char *my_readline(const char *prompt)
-{
-  int size = history_length;
-  if (size == 0) {
-    read_history(HISTORY_FILE.c_str());
-
-    FILE *fp = fopen(HISTORY_FILE.c_str(), "a");
-    if (fp != nullptr) {
-      fclose(fp);
-    }
-  }
-
-  char *line = readline(prompt);
-  if (line != nullptr && line[0] != 0) {
-    add_history(line);
-    if (time(NULL) - last_history_write_time > 5) {
-      write_history(HISTORY_FILE.c_str());
-    }
-    // append_history doesn't work on some readlines
-    // append_history(1, HISTORY_FILE.c_str());
-  }
-  return line;
-}
-#else   // USE_READLINE
-char *my_readline(const char *prompt)
-{
-  char *buffer = (char *)malloc(MAX_MEM_BUFFER_SIZE);
-  if (nullptr == buffer) {
-    fprintf(stderr, "failed to alloc line buffer");
-    return nullptr;
-  }
-  fprintf(stdout, "%s", prompt);
-  char *s = fgets(buffer, MAX_MEM_BUFFER_SIZE, stdin);
-  if (nullptr == s) {
-    fprintf(stderr, "failed to read message from console");
-    free(buffer);
-    return nullptr;
-  }
-  return buffer;
-}
-#endif  // USE_READLINE
-
-/* this function config a exit-cmd list, strncasecmp func truncate the command from terminal according to the number,
-   'strncasecmp("exit", cmd, 4)' means that obclient read command string from terminal, truncate it to 4 chars from
-   the beginning, then compare the result with 'exit', if they match, exit the obclient.
-*/
-bool is_exit_command(const char *cmd)
-{
-  return 0 == strncasecmp("exit", cmd, 4) || 0 == strncasecmp("bye", cmd, 3) || 0 == strncasecmp("\\q", cmd, 2);
-}
+const std::string LINE_HISTORY_FILE = "./.obclient.history";
 
 int init_unix_sock(const char *unix_sock_path)
 {
@@ -188,26 +132,24 @@ int main(int argc, char *argv[])
 
   char send_buf[MAX_MEM_BUFFER_SIZE];
 
-  char *input_command = nullptr;
-  while ((input_command = my_readline(prompt_str)) != nullptr) {
-    if (common::is_blank(input_command)) {
-      free(input_command);
-      input_command = nullptr;
+  std::string input_command = "";
+  MiniobLineReader::instance().init(LINE_HISTORY_FILE);
+
+  while (true) {
+    input_command = MiniobLineReader::instance().my_readline(prompt_str);
+
+    if (input_command.empty() || common::is_blank(input_command.c_str())) {
       continue;
     }
 
-    if (is_exit_command(input_command)) {
-      free(input_command);
-      input_command = nullptr;
+    if (MiniobLineReader::instance().is_exit_command(input_command)) {
       break;
     }
 
-    if ((send_bytes = write(sockfd, input_command, strlen(input_command) + 1)) == -1) {  // TODO writen
+    if ((send_bytes = write(sockfd, input_command.c_str(), input_command.length() + 1)) == -1) {  // TODO writen
       fprintf(stderr, "send error: %d:%s \n", errno, strerror(errno));
       exit(1);
     }
-    free(input_command);
-    input_command = nullptr;
 
     memset(send_buf, 0, sizeof(send_buf));
 
@@ -237,11 +179,9 @@ int main(int argc, char *argv[])
     }
   }
 
-  if (input_command != nullptr) {
-    free(input_command);
-    input_command = nullptr;
-  }
   close(sockfd);
 
+  LOG_INFO("Command history saved to: %s", LINE_HISTORY_FILE.c_str());
+
   return 0;
 }