Intermediate commit - just to make new files visible to bk in the new

tree


server-tools/instance-manager/Makefile.am:
  Fixed IM linking to avoid using both mysys and libmysql as the define the
  same symbols and therefore conflict
server-tools/instance-manager/listener.cc:
  Added ability to listen network ports
server-tools/instance-manager/listener.h:
  Various additions to the Listener_thread_args
server-tools/instance-manager/log.cc:
  merge
server-tools/instance-manager/log.h:
  merge
server-tools/instance-manager/manager.cc:
  Fixes and additions to enable guardian functionality
server-tools/instance-manager/manager.h:
  Changed manager() signature
server-tools/instance-manager/mysqlmanager.cc:
  Various fixes
server-tools/instance-manager/options.cc:
  Added handling of default values for new options in the Options struct. (such
  as default_user, default_password, monitoring_interval e.t.c)
server-tools/instance-manager/options.h:
  Added new options to the Options struct
sql/net_serv.cc:
  Added MYSQL_INSTANCE_MANAGER defines to enable alarm handling in the IM
server-tools/instance-manager/buffer.cc:
  Simple implementation of variable-length buffer
server-tools/instance-manager/command.cc:
  Abstract command. All commands are derived from Command class
server-tools/instance-manager/commands.h:
  Interfaces for all commands we have
server-tools/instance-manager/factory.cc:
  Commands factory. This class hides command instantiation. The idea is to
  handle various protocols this way. (different commands for different
  protocols
server-tools/instance-manager/guardian.cc:
  Guardian thread implementation (monitor and restart instances in case of a
  failure
server-tools/instance-manager/guardian.h:
  Guardian_thread and Guardian_thread_args class interface. The
  Guardian_thread is responsible for monitoring and restarting instances
server-tools/instance-manager/instance.cc:
  Instance class contains methods and data to manage a single instance
server-tools/instance-manager/instance.h:
  This file contains class an instance class interface. The class is
  responsible for starting/stopping an instance
server-tools/instance-manager/instance_map.cc:
  The instance repository. This class is also responsible for initialization
  of Instance class objects.
server-tools/instance-manager/instance_options.cc:
  The Instance_options class contains all methods to get and  handle options
  of an instance
server-tools/instance-manager/mysql_connection.cc:
  The class responsible for handling MySQL client/server protocol connections
server-tools/instance-manager/mysql_manager_error.h:
  The list of Instance Manger-specific errors
server-tools/instance-manager/parse.cc:
  Simple query parser
server-tools/instance-manager/parse.h:
  Parser interface
server-tools/instance-manager/protocol.cc:
  Here implemented functions used to handle mysql client/server protocol
server-tools/instance-manager/protocol.h:
  Interface for MySQL client/server protocol
server-tools/instance-manager/thread_registry.cc:
  Thread registry stores information about every thread. It's main function is
  to provide graceful shutdown for all threads.
server-tools/instance-manager/user_map.h:
  User map contains hash with user names and passwords

1 files changed, 132 insertions, 11 deletions

diff --git a/server-tools/instance-manager/manager.cc b/server-tools/instance-manager/manager.cc
index 06e181d52d5..cb51197d52a 100644
--- a/server-tools/instance-manager/manager.cc
+++ b/server-tools/instance-manager/manager.cc
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
+/* Copyright (C) 2003 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -17,19 +17,68 @@
 #include "manager.h"
 
 #include <my_global.h>
+#include <my_sys.h>
+#include <m_string.h>
 #include <signal.h>
+#include <thr_alarm.h>
 
-#include "thread_repository.h"
+#include "thread_registry.h"
 #include "listener.h"
+#include "instance_map.h"
+#include "options.h"
+#include "user_map.h"
 #include "log.h"
+#include "guardian.h"
 
 
-void manager(const char *socket_file_name)
+/*
+  manager - entry point to the main instance manager process: start
+  listener thread, write pid file and enter into signal handling.
+  See also comments in mysqlmanager.cc to picture general Instance Manager
+  architecture.
+*/
+
+void manager(const Options &options)
 {
-  Thread_repository thread_repository;
-  Listener_thread_args listener_args(thread_repository, socket_file_name);
+  Thread_registry thread_registry;
+  /*
+    All objects created in the manager() function live as long as
+    thread_registry lives, and thread_registry is alive until there are
+    working threads.
+  */
+
+  User_map user_map;
+  Instance_map instance_map;
+  Guardian_thread guardian_thread(thread_registry,
+                                  &instance_map,
+                                  options.monitoring_interval);
+
+  instance_map.mysqld_path= options.default_mysqld_path;
+  instance_map.user= options.default_admin_user;
+  instance_map.password= options.default_admin_password;
+  instance_map.guardian= &guardian_thread;
+  instance_map.load();
+
+  Listener_thread_args listener_args(thread_registry, options, user_map,
+                                     instance_map);
+
+
+  if (user_map.load(options.password_file_name))
+    return;
 
   /* write pid file */
+  if (FILE *pid_file= my_fopen(options.pid_file_name,
+                               O_WRONLY | O_CREAT | O_BINARY, MYF(0)))
+  {
+    fprintf(pid_file, "%d\n", (int) getpid());
+    my_fclose(pid_file, MYF(0));
+  }
+  else
+  {
+    log_error("can't create pid file %s: errno=%d, %s",
+              options.pid_file_name, errno, strerror(errno));
+    return;
+  }
 
   /* block signals */
   sigset_t mask;
@@ -37,26 +86,98 @@ void manager(const char *socket_file_name)
   sigaddset(&mask, SIGINT);
   sigaddset(&mask, SIGTERM);
   sigaddset(&mask, SIGHUP);
+  /*
+    We want this signal to be blocked in all theads but the signal
+    one. It is needed for the thr_alarm subsystem to work.
+  */
+  sigaddset(&mask,THR_SERVER_ALARM);
 
   /* all new threads will inherite this signal mask */
   pthread_sigmask(SIG_BLOCK, &mask, NULL);
+
+  /* create the listener */
   {
-    /* create the listener */
     pthread_t listener_thd_id;
     pthread_attr_t listener_thd_attr;
+    int rc;
 
     pthread_attr_init(&listener_thd_attr);
     pthread_attr_setdetachstate(&listener_thd_attr, PTHREAD_CREATE_DETACHED);
-    if (pthread_create(&listener_thd_id, &listener_thd_attr, listener,
-                       &listener_args))
-      die("manager(): pthread_create(listener) failed");
+    rc= pthread_create(&listener_thd_id, &listener_thd_attr, listener,
+                       &listener_args);
+    pthread_attr_destroy(&listener_thd_attr);
+    if (rc)
+    {
+      log_error("manager(): pthread_create(listener) failed");
+      goto err;
+    }
+
+  }
+
+  /* create guardian thread */
+  {
+    pthread_t guardian_thd_id;
+    pthread_attr_t guardian_thd_attr;
+    int rc;
+
+    pthread_attr_init(&guardian_thd_attr);
+    pthread_attr_setdetachstate(&guardian_thd_attr, PTHREAD_CREATE_DETACHED);
+    rc= pthread_create(&guardian_thd_id, &guardian_thd_attr, guardian,
+                       &guardian_thread);
+    pthread_attr_destroy(&guardian_thd_attr);
+    if (rc)
+    {
+      log_error("manager(): pthread_create(guardian) failed");
+      goto err;
+    }
+
   }
+
   /*
     To work nicely with LinuxThreads, the signal thread is the first thread
     in the process.
   */
   int signo;
-  sigwait(&mask, &signo);
-  thread_repository.deliver_shutdown();
+  bool shutdown_complete;
+
+  shutdown_complete= FALSE;
+  /*
+     In our case the signal thread also implements functions of alarm thread.
+     Here we init alarm thread functionality. We suppose that we won't have
+     more then 10 alarms at the same time.
+  */
+  init_thr_alarm(10);
+  /*
+    Now we can init the list of guarded instances. We have to do it after
+    alarm structures initialization as we have to use net_* functions while
+    making the list. And they in their turn need alarms for timeout suppport.
+  */
+  instance_map.init_guardian();
+
+  while (!shutdown_complete)
+  {
+    sigwait(&mask, &signo);
+    switch (signo)
+    {
+      case THR_SERVER_ALARM:
+        process_alarm(signo);
+      break;
+      default:
+        thread_registry.deliver_shutdown();
+        shutdown_complete= TRUE;
+      break;
+    }
+  }
+
+err:
+  /* delete the pid file */
+  my_delete(options.pid_file_name, MYF(0));
+
+  /* close permanent connections to the running instances */
+  instance_map.cleanup();
+
+  /* free alarm structures */
+  end_thr_alarm(1);
   /* don't pthread_exit to kill all threads who did not shut down in time */
 }
+