[CBRD-25436] Creating monitoring thread and data structures for cub_server monitoring

cs/CMakeLists.txt

@@ -30,6 +30,7 @@ set(EXECUTABLE_SOURCES
   ${EXECUTABLES_DIR}/unloaddb.c
   ${EXECUTABLES_DIR}/util_common.c
   ${EXECUTABLES_DIR}/util_cs.c
+  ${EXECUTABLES_DIR}/master_server_monitor.cpp
   )
 
 set(EXECUTABLE_HEADERS

src/executables/master.c

@@ -73,6 +73,7 @@
 #include "message_catalog.h"
 #include "dbi.h"
 #include "util_func.h"
+#include "master_server_monitor.hpp"
 
 static void css_master_error (const char *error_string);
 static int css_master_timeout (void);
@@ -104,6 +105,10 @@ static int css_check_master_socket_exception (fd_set * fd_var);
 static void css_master_loop (void);
 static void css_free_entry (SOCKET_QUEUE_ENTRY * entry_p);
 
+// *INDENT-OFF*
+std::unique_ptr < server_monitor > master_server_monitor = nullptr;
+// *INDENT-ON*
+
 #if !defined(WINDOWS)
 static void css_daemon_start (void);
 #endif
@@ -1223,6 +1228,18 @@ main (int argc, char **argv)
     }
 #endif
 
+  // TODO : When no non-HA server exists in HA environment, server_monitor should not be initialized.
+  //        In this issue, server_monitor is initialized only when HA is disabled. Once all sub-tasks of
+  //        CBRD-24741 are done, this condition will be removed. And server_monitor will be initialized wh
+  //        en first non-HA server is started in HA environment. (server_monitor will be finalized when last
+  //        non-HA server is stopped in HA environment.)
+  if (HA_DISABLED ())
+    {
+      // *INDENT-OFF*
+      master_server_monitor.reset(new server_monitor());
+      // *INDENT-ON*
+    }
+
   conn = css_make_conn (css_Master_socket_fd[0]);
   css_add_request_to_socket_queue (conn, false, NULL, css_Master_socket_fd[0], READ_WRITE, 0,
 				   &css_Master_socket_anchor);

src/executables/master_server_monitor.cpp

@@ -0,0 +1,89 @@
+/*
+ *
+ * Copyright 2016 CUBRID Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+//
+// master_server_monitor.cpp - Server Revive monitoring module
+//
+
+#include "master_server_monitor.hpp"
+#include <sstream>
+
+#include "util_func.h"
+
+server_monitor::server_monitor ()
+{
+  m_thread_shutdown = false;
+  m_monitor_list = std::make_unique<server_monitor_list>();
+  fprintf (stdout, "server_monitor_list is created. \n");
+
+  m_monitoring_thread = std::make_unique<std::thread> ([this]()
+  {
+    while (!m_thread_shutdown)
+      {
+	// TODO: select server_entry whose m_need_revive value is true. (Will be implemented in CBRD-25438 issue.)
+      }
+  });
+  fprintf (stdout, "server_monitor_thread is created. \n");
+  fflush (stdout);
+}
+
+// In server_monitor destructor, it should guerentee that
+// m_monitoring_thread is terminated before m_monitor_list is deleted.
+server_monitor::~server_monitor ()
+{
+  m_thread_shutdown = true;
+  if (m_monitoring_thread->joinable())
+    {
+      m_monitoring_thread->join();
+      fprintf (stdout, "server_monitor_thread is terminated. \n");
+    }
+  fprintf (stdout, "server_monitor_list is deleted. \n");
+  fflush (stdout);
+}
+
+server_monitor::server_entry::
+server_entry (int pid, const char *server_name, const char *exec_path, char *args, CSS_CONN_ENTRY *conn)
+  : m_pid {pid}
+  , m_server_name {server_name}
+  , m_exec_path {exec_path}
+  , m_conn {conn}
+  , m_last_revive_time {0, 0}
+  , m_need_revive {false}
+{
+  if (args != nullptr)
+    {
+      proc_make_arg (args);
+    }
+}
+
+void
+server_monitor::server_entry::proc_make_arg (char *args)
+{
+  std::istringstream iss (args);
+  std::string tok;
+  while (iss >> tok)
+    {
+      m_argv.push_back (tok);
+    }
+}
+
+server_monitor::server_monitor_list::server_monitor_list()
+{
+  m_unacceptable_proc_restart_timediff = prm_get_integer_value (PRM_ID_HA_UNACCEPTABLE_PROC_RESTART_TIMEDIFF_IN_MSECS);
+  m_max_process_start_confirm = prm_get_integer_value (PRM_ID_HA_MAX_PROCESS_START_CONFIRM);
+}

src/executables/master_server_monitor.hpp

@@ -0,0 +1,99 @@
+/*
+ *
+ * Copyright 2016 CUBRID Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+/*
+ * master_server_monitor.hpp -
+ */
+
+#ifndef _MASTER_SERVER_MONITOR_HPP_
+#define _MASTER_SERVER_MONITOR_HPP_
+
+#include <cstring>
+#include <thread>
+#include <algorithm>
+#include <memory>
+#include <mutex>
+#include <time.h>
+#include "heartbeat.h"
+#include "system_parameter.h"
+#include "connection_defs.h"
+
+class server_monitor
+{
+  public:
+    class server_entry
+    {
+      public:
+	server_entry (int pid, const char *server_name, const char *exec_path, char *args, CSS_CONN_ENTRY *conn);
+	~server_entry () {};
+
+	server_entry (const server_entry &) = delete;
+	server_entry (server_entry &&) = delete;
+
+	server_entry &operator = (const server_entry &) = delete;
+	server_entry &operator = (server_entry &&) = delete;
+
+      private:
+	void proc_make_arg (char *args);
+
+	const int m_pid;                              // process ID
+	const std::string m_server_name;              // server name
+	const std::string m_exec_path;                // executable path of server process
+	std::vector<std::string> m_argv;              // arguments of server process
+	CSS_CONN_ENTRY *m_conn;                       // connection entry of server process
+	timeval m_last_revive_time;                   // latest revive time
+	bool m_need_revive;                           // need to revive (true if the server is abnormally terminated)
+    };
+
+    using server_entry_uptr_t = std::unique_ptr<server_monitor::server_entry>;
+
+    class server_monitor_list
+    {
+      public:
+	server_monitor_list ();
+	~server_monitor_list () {};
+
+	server_monitor_list (const server_monitor_list &) = delete;
+	server_monitor_list (server_monitor_list &&) = delete;
+
+	server_monitor_list &operator = (const server_monitor_list &) = delete;
+	server_monitor_list &operator = (server_monitor_list &&) = delete;
+
+      private:
+	std::vector <server_entry_uptr_t> server_entry_list;      // list of server entries
+	int m_unacceptable_proc_restart_timediff;                 // unacceptable time difference between process restart
+	int m_max_process_start_confirm;                          // Maximum number of process restart confirmations
+    };
+
+    server_monitor ();
+    ~server_monitor ();
+
+  private:
+    server_monitor (const server_monitor &) = delete;
+    server_monitor (server_monitor &&) = delete;
+
+    server_monitor &operator = (const server_monitor &) = delete;
+    server_monitor &operator = (server_monitor &&) = delete;
+
+    std::unique_ptr<std::thread> m_monitoring_thread;                   // monitoring thread
+    std::unique_ptr<server_monitor_list> m_monitor_list;                // list of server entries
+    volatile bool m_thread_shutdown;                                    // flag to shutdown monitoring thread
+};
+
+extern std::unique_ptr<server_monitor> master_server_monitor;
+#endif