application_config.cpp

Go to the documentation of this file.

#ifndef APPLICATION_CONFIG_IMPLEMENTATION_FILE
#define APPLICATION_CONFIG_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : application_config                                                *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2000 By Author.  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 is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "application_config.h"

#include <basis/auto_synch.h>
#include <basis/istring.h>
#include <basis/log_base.h>
#include <basis/mutex.h>
#include <basis/set.cpp>
#include <data_struct/section_manager.h>
#include <data_struct/string_table.h>
#include <opsystem/ini_config.h>
#include <textual/parser_bits.h>
#include <textual/tokenizer.h>

//#define DEBUG_APP_CONFIG
  // uncomment for noisier debugging version.

#undef LOG
#define LOG(to_print) program_wide_logger().log(to_print)


const char *PRODUCT_HEADING() { return "product"; }
  // the string used for our startup entries as a prefix to the product.

const char *ASSIGN_TOKEN() { return "="; }
  // how we distinguish the key from the value for startup entries.

const char *SEPARATOR_TOKEN() { return ","; }
  // the character between separate key/value pairs in the startup string.

const char *SEPARATOR_TEXT() { return ", "; }
  // the string we use for the separator when printing it.

const char *PARMS_HEADING() { return "parms"; }
  // the tag for parameters in the startup entry.

const char *ONESHOT_HEADING() { return "oneshot"; }
  // the key name for startup entries' flag for once only execution.


application_config::application_config(const istring &config_file,
    const istring &basename)
: _lock(new mutex),
  _config(new ini_configurator(config_file, ini_configurator::RETURN_ONLY,
      ini_configurator::APPLICATION_DIRECTORY)),
  _sector(new section_manager(*_config, istring(basename) + "_TOC",
      istring(PRODUCT_HEADING()) + "_"))
{
  FUNCDEF("constructor");
  string_table startup_info;
  if (!find_section(STARTUP_SECTION(), startup_info)) {
    // if there's no startup section, we do nothing right now.
    LOG("the startup section doesn't exist yet; adding it now.");
    istring entry = make_startup_entry(basename, "", false);
    startup_info.add(STARTUP_APP_NAME(), entry);
    add_section(STARTUP_SECTION(), startup_info);
  }
}

application_config::~application_config()
{
  WHACK(_sector);
  WHACK(_config);
  WHACK(_lock);
}

const char *application_config::STARTUP_SECTION()
{ return "PRIVATE_STARTUP_LNCH1.0"; }

const char *application_config::STARTUP_APP_NAME()
{ return "placeholder"; }

bool application_config::product_exists(const istring &product)
{
  auto_synchronizer l(*_lock);
  if (!_sector->section_exists(product)) return false;
  return true;
}

istring application_config::find_program(const istring &product,
    const istring &app_name, int &level)
{
  auto_synchronizer l(*_lock);
  istring heading = _sector->make_section_heading(product);
  istring found = _sector->config().load(heading, app_name, "");
//overly specific bits here...
//hmmm: add this in as a specialization provided by real owner of class.
  if (!found) {
    // we didn't find the entry under the section we wanted to find it in.
    // there are a couple cases where we can kludge this section to a
    // different name, based on legacy requirements, and still find the
    // right item possibly.
    if (product.iequals("supervisor")) {
      // for some older installs, they say "supervisor" but mean "core".
      heading = _sector->make_section_heading("core");
      found = _sector->config().load(heading, app_name, "");
    } else if (product.iequals("lightlink")) {
      heading = _sector->make_section_heading("core");
      found = _sector->config().load(heading, app_name, "");
      if (!found) {
        // we can take one more remedial step for this phrase.
        heading = _sector->make_section_heading("server");
        found = _sector->config().load(heading, app_name, "");
      }
    }
  }
//end of overly specific.
  found = parser_bits::substitute_env_vars(found);

  int comma_loc = found.find(",");
  if (negative(comma_loc)) return "";  // couldn't find our priority.
  level = found.convert(0);
  found.zap(0, comma_loc);

  return found;
}

bool application_config::add_program(const istring &product,
    const istring &app_name, const istring &full_path, int level)
{
  FUNCDEF("add_program");
  auto_synchronizer l(*_lock);
  bool existed = true;
  // lookup the section, if it exists.
  string_table info_table;
  if (!_sector->section_exists(product)) {
    existed = false;
  } else
    find_section(product, info_table);
#ifdef DEBUG_APP_CONFIG
  if (existed) {
    LOG(istring("section for ") + product + " found:");
    for (int i = 0; i < info_table.symbols(); i++)
      LOG(istring("key=") + info_table.name(i) + " value=" + info_table[i]);
  } else LOG(istring("section for ") + product + " not found.");
#endif
  // remove any existing entry.
  info_table.whack(app_name);
  // plug in our new entry.
  isprintf full_entry("%d,%s", level, full_path.s());
  info_table.add(app_name, full_entry);
#ifdef DEBUG_APP_CONFIG
  LOG(istring("new section for ") + product + " has:");
  for (int i = 0; i < info_table.symbols(); i++)
    LOG(istring("key=") + info_table.name(i) + " value=" + info_table[i]);
#endif
  // now call the proper storage function based on whether the section
  // existed before or not.
  if (existed) return replace_section(product, info_table);
  else return add_section(product, info_table);
}

bool application_config::remove_program(const istring &product,
    const istring &app_name)
{
  FUNCDEF("remove_program");
  auto_synchronizer l(*_lock);
  // if the section's missing, there's nothing to remove...
  string_table info_table;
  if (!find_section(product, info_table)) return true;
  // the section did exist, so remove any existing entry.
  info_table.whack(app_name);
  // now call the proper storage function based on whether the section
  // existed before or not.
  return replace_section(product, info_table);
}

bool application_config::find_section(const istring &section_name,
    string_table &info_found)
{
  FUNCDEF("find_section");
  info_found.reset();
  auto_synchronizer l(*_lock);
  if (!_sector->find_section(section_name, info_found)) {
    LOG(section_name + " was not found in the configuration.");
    return false;
  }
  return true;
}

bool application_config::add_section(const istring &section_name,
    const string_table &info_found)
{
  auto_synchronizer l(*_lock);
  return _sector->add_section(section_name, info_found);
}

bool application_config::replace_section(const istring &section_name,
    const string_table &info_found)
{
  auto_synchronizer l(*_lock);
  return _sector->replace_section(section_name, info_found);
}

istring application_config::make_startup_entry(const istring &product,
    const istring &parms, bool one_shot)
{
  return istring(PRODUCT_HEADING()) + ASSIGN_TOKEN() + product
      + SEPARATOR_TEXT() + PARMS_HEADING() + ASSIGN_TOKEN()
      + parms + SEPARATOR_TEXT() + ONESHOT_HEADING() + ASSIGN_TOKEN()
      + istring(istring::SPRINTF, "%d", one_shot);
}

bool application_config::parse_startup_entry(const istring &info,
    istring &product, istring &parms, bool &one_shot)
{
  FUNCDEF("parse_startup_section");
  // parse the items that are in the entry for this program.
  tokenizer entry_parser(SEPARATOR_TOKEN(), ASSIGN_TOKEN());
  entry_parser.parse(info);
  // grab the pertinent bits for the program to be started.
  product = entry_parser.find(PRODUCT_HEADING());
  parms = entry_parser.find(PARMS_HEADING());
//LOG(istring("parms=") + parms);
  istring once = entry_parser.find(ONESHOT_HEADING());
  one_shot = (bool)once.convert(0);
  // we require the product part at least.
  if (!product) return false;
  return true;
}

bool application_config::find_entry(const string_table &table,
    const istring &name, istring &location)
{
  // seek the entry in the table specified.
  istring *found = table.find(name);
  if (!found) return false;
  // found the entry using the name.
  location = *found;
  return true;
}

bool application_config::add_startup_entry(const istring &product,
    const istring &app_name, const istring &parameters, int one_shot)
{
  FUNCDEF("add_startup_entry");
  auto_synchronizer l(*_lock);

  LOG(istring("product \"") + product + "\", application \"" + app_name
      + (one_shot? istring("\", OneShot") : istring("\", MultiUse")));

  string_table startup_info;
  if (!find_section(STARTUP_SECTION(), startup_info)) {
    // if there's no startup section, we can't go on.  that should have been
    // created during startup of this program.
    LOG("internal startup section not found!");
    return false;
  }

  istring new_entry = make_startup_entry(product, parameters,
      one_shot);
  startup_info.add(app_name, new_entry);
  if (!replace_section(STARTUP_SECTION(), startup_info))
    return false;
//hmmm: that's a bogus error; this is really an internal fup error.

  return true;
}

bool application_config::remove_startup_entry(const istring &product,
    const istring &app_name)
{
  FUNCDEF("remove_startup_entry");
  auto_synchronizer l(*_lock);

  LOG(istring("product \"") + product + "\", application \"" + app_name + "\"");

  string_table startup_info;
  if (!find_section(STARTUP_SECTION(), startup_info)) {
    // if there's no startup section, we try to add one.
    add_section(STARTUP_SECTION(), startup_info);
    // if it still doesn't exist afterwards, we're hosed.
    if (!find_section(STARTUP_SECTION(), startup_info)) {
//massive fup of some unanticipated sort.
//complain.
      return false;
    }
  }

  // check that the entry already exists for this program.
  istring entry_found;
  if (!find_entry(startup_info, app_name, entry_found)) {
//    COMPLAIN_APPLICATION;
    LOG(istring("no entry was found for ") + app_name);
    return false;
  }

  startup_info.whack(app_name);
  if (!replace_section(STARTUP_SECTION(), startup_info)) {
//what happened with that?
    return false;
  }

  return true;
}


#endif //APPLICATION_CONFIG_IMPLEMENTATION_FILE

---