[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

@@ -22,13 +22,16 @@
 
 #ident "$Id$"
 
+
+
 #include "config.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <time.h>
+#include <memory>
 
 #if defined(_AIX)
 #include <sys/select.h>
@@ -73,6 +76,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);
@@ -1130,6 +1134,17 @@ main (int argc, char **argv)
   const char *msg_format;
   bool util_config_ret;
 
+  // TODO : When non-HA server do not exists in HA environment, server_monitor should not be initialized.
+  //        In this issue, server_monitor is initialized only when HA is disabled. After all sub-tasks of
+  //        CBRD-24741 is 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*
+  server_monitor& server_monitoring_manager = server_monitor::get_instance();
+// *INDENT-ON*
+    }
   if (utility_initialize () != NO_ERROR)
     {
       return EXIT_FAILURE;

src/executables/master_server_monitor.cpp

@@ -0,0 +1,105 @@
+/*
+ *
+ * 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 "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: Server_entry selection which need_revive value is true. (Will be implemented in CBRD-25438 issue.)
+      }
+  });
+  fprintf (stdout, "server_monitor_thread is created.\n");
+}
+
+
+// When server_monitor is deleted, it should guerentee that
+// monitoring_thread is terminated before 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 deleted.\n");
+  m_monitor_list.reset();
+  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}
+{
+  this->m_argv = new char *[HB_MAX_NUM_PROC_ARGV];
+  proc_make_arg (this->m_argv, args);
+}
+
+server_monitor::server_entry::~server_entry()
+{
+  if (m_argv)
+    {
+      for (char **arg = m_argv; *arg; ++arg)
+	{
+	  delete[] * arg;
+	}
+      delete[] m_argv;
+    }
+}
+
+
+void
+server_monitor::server_entry::proc_make_arg (char **arg, char *args)
+{
+  char *tok, *save;
+
+  tok = strtok_r (args, " \t\n", &save);
+
+  while (tok)
+    {
+      (*arg++) = tok;
+      tok = strtok_r (NULL, " \t\n", &save);
+    }
+  return;
+}
+
+
+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,114 @@
+/*
+ *
+ * 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 -
+ */
+
+
+#include <cstring>
+#include <thread>
+#include <algorithm>
+#include <memory>
+#include <time.h>
+#include "heartbeat.h"
+#include "system_parameter.h"
+#include "connection_defs.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+class server_monitor
+{
+  public:
+
+    class server_entry;
+    class server_monitor_list;
+
+    static server_monitor &get_instance ()
+    {
+      static server_monitor instance;
+      return instance;
+    }
+
+    server_monitor (const server_monitor &) = delete;
+    server_monitor (server_monitor &&) = delete;
+
+    server_monitor &operator = (const server_monitor &) = delete;
+    server_monitor &operator = (server_monitor &&) = delete;
+
+    using server_entry_uptr_t = std::unique_ptr<server_monitor::server_entry>;
+
+    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:
+	int m_pid;
+	std::string m_server_name;
+	std::string m_exec_path;
+	char **m_argv;
+	CSS_CONN_ENTRY *m_conn;
+	timeval m_last_revive_time;
+	bool m_need_revive;
+
+      private:
+	void proc_make_arg (char **argv, char *args);
+    };
+
+    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;
+	int m_unacceptable_proc_restart_timediff;
+	int m_max_process_start_confirm;
+    };
+
+  private:
+    server_monitor ();
+    ~server_monitor ();
+
+    std::unique_ptr<std::thread> m_monitoring_thread;
+    std::unique_ptr<server_monitor_list> m_monitor_list;
+    bool m_thread_shutdown;
+};
+
+#ifdef __cplusplus
+}
+#endif