/* Copyright (C) 2004 MySQL 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
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

#ifdef __GNUC__
#pragma implementation
#endif

#include "instance_map.h"

#include "buffer.h"
#include "instance.h"

#include <m_ctype.h>
#include <mysql_com.h>
#include <m_string.h>

/*
  Note:  As we are going to suppost different types of connections,
  we shouldn't have connection-specific functions. To avoid it we could
  put such functions to the Command-derived class instead.
  The command could be easily constructed for a specific connection if
  we would provide a special factory for each connection.
*/

C_MODE_START

/* Procedure needed for HASH initialization */

static byte* get_instance_key(const byte* u, uint* len,
                          my_bool __attribute__((unused)) t)
{
  const Instance *instance= (const Instance *) u;
  *len= instance->options.instance_name_len;
  return (byte *) instance->options.instance_name;
}

static void delete_instance(void *u)
{
  Instance *instance= (Instance *) u;
  delete instance;
}

/*
  The option handler to pass to the process_default_option_files finction.

  SYNOPSYS
    process_option()
    ctx               Handler context. Here it is an instance_map structure.
    group_name        The name of the group the option belongs to.
    option            The very option to be processed. It is already
                      prepared to be used in argv (has -- prefix)

  DESCRIPTION

    This handler checks whether a group is an instance group and adds
    an option to the appropriate instance class. If this is the first
    occurence of an instance name, we'll also create the instance
    with such name and add it to the instance map.

  RETURN
    0 - ok
    1 - error occured
*/

static int process_option(void *ctx, const char *group, const char *option)
{
  Instance_map *map= NULL;
  Instance *instance= NULL;
  static const char prefix[]= { 'm', 'y', 's', 'q', 'l', 'd' };

  map = (Instance_map*) ctx;
  if (strncmp(group, prefix, sizeof prefix) == 0 &&
      ((my_isdigit(default_charset_info, group[sizeof prefix]))
       || group[sizeof(prefix)] == '\0'))
    {
      if ((instance= map->find(group, strlen(group))) == NULL)
      {
        if ((instance= new Instance) == 0)
          goto err_new_instance;
        if (instance->init(group))
          goto err;
        if (map->add_instance(instance))
          goto err;
      }

      if (instance->options.add_option(option))
        goto err;
    }

  return 0;

err:
  delete instance;
err_new_instance:
  return 1;
}

C_MODE_END


Instance_map::Instance_map(const char *default_mysqld_path_arg,
                           const char *first_option_arg):
mysqld_path(default_mysqld_path_arg), first_option(first_option_arg)
{
  pthread_mutex_init(&LOCK_instance_map, 0);
}


int Instance_map::init()
{
  if (hash_init(&hash, default_charset_info, START_HASH_SIZE, 0, 0,
                get_instance_key, delete_instance, 0))
    return 1;
  return 0;
}

Instance_map::~Instance_map()
{
  pthread_mutex_lock(&LOCK_instance_map);
  hash_free(&hash);
  pthread_mutex_unlock(&LOCK_instance_map);
  pthread_mutex_destroy(&LOCK_instance_map);
}


int Instance_map::lock()
{
  return pthread_mutex_lock(&LOCK_instance_map);
}


int Instance_map::unlock()
{
  return pthread_mutex_unlock(&LOCK_instance_map);
}


int Instance_map::flush_instances()
{
  int rc;

  guardian->lock();
  pthread_mutex_lock(&LOCK_instance_map);
  hash_free(&hash);
  hash_init(&hash, default_charset_info, START_HASH_SIZE, 0, 0,
            get_instance_key, delete_instance, 0);
  pthread_mutex_unlock(&LOCK_instance_map);
  rc= load();
  guardian->init();
  guardian->unlock();
  return rc;
}


int Instance_map::add_instance(Instance *instance)
{
  return my_hash_insert(&hash, (byte *) instance);
}


Instance *
Instance_map::find(const char *name, uint name_len)
{
  Instance *instance;
  pthread_mutex_lock(&LOCK_instance_map);
  instance= (Instance *) hash_search(&hash, (byte *) name, name_len);
  pthread_mutex_unlock(&LOCK_instance_map);
  return instance;
}


int Instance_map::complete_initialization()
{
  Instance *instance;
  uint i= 0;


  if (hash.records == 0)                        /* no instances found */
  {
    if ((instance= new Instance) == 0)
      goto err;

    if (instance->init("mysqld") || add_instance(instance))
      goto err_instance;


    /*
      After an instance have been added to the instance_map,
      hash_free should handle it's deletion => goto err, not
      err_instance.
    */
    if (instance->complete_initialization(this, mysqld_path, DEFAULT_SINGLE_INSTANCE))
      goto err;
  }
  else
    while (i < hash.records)
    {
      instance= (Instance *) hash_element(&hash, i);
      if (instance->complete_initialization(this, mysqld_path, USUAL_INSTANCE))
        goto err;
      i++;
    }

  return 0;
err:
  return 1;
err_instance:
  delete instance;
  return 1;
}


/* load options from config files and create appropriate instance structures */

int Instance_map::load()
{
  int argc= 1;
  /* this is a dummy variable for search_option_files() */
  uint args_used= 0;
  const char *argv_options[3];
  char **argv= (char **) &argv_options;


  /* the name of the program may be orbitrary here in fact */
  argv_options[0]= "mysqlmanager";
  if (first_option != NULL)
  {
    argc= 2;
    argv_options[1]= first_option;
    argv_options[2]= '\0';
  }
  else
    argv_options[1]= '\0';

  if (my_search_option_files("my", &argc, (char ***) &argv, &args_used,
                             process_option, (void*) this) ||
      complete_initialization())
    return 1;

  return 0;
}


/*--- Implementaton of the Instance map iterator class  ---*/


void Instance_map::Iterator::go_to_first()
{
  current_instance=0;
}


Instance *Instance_map::Iterator::next()
{
  if (current_instance < instance_map->hash.records)
    return (Instance *) hash_element(&instance_map->hash, current_instance++);

  return NULL;
}

