libfossscheduler.c

Go to the documentation of this file.

/***************************************************************
Copyright (C) 2010-2011 Hewlett-Packard Development Company, L.P.
Copyright (C) 2015 Siemens AG

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.

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.,
51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

***************************************************************/

/* local includes */
#include "libfossscheduler.h"
#include "libfossdb.h"
#include "fossconfig.h"

/* unix includes */
#include <stdio.h>
#include <getopt.h>
#include <libgen.h>
#include <glib.h>

/* ************************************************************************** */
/* **** Locals ************************************************************** */
/* ************************************************************************** */

volatile gint items_processed; 
volatile int alive;            
char buffer[2048];   
int valid;           
int sscheduler;      
int userID;          
int groupID;         
int jobId;           
char* module_name = NULL;   

const static char* sql_check = "\
  SELECT * FROM agent \
    WHERE agent_name = '%s' AND agent_rev='%s.%s'";

const static char* sql_insert = "\
  INSERT INTO agent (agent_name, agent_rev, agent_desc) \
    VALUES ('%s', '%s.%s', '%s')";

fo_conf* sysconfig = NULL;
char* sysconfigdir = NULL;

/* these will be freed in fo_scheduler_disconnect */
extern GRegex* fo_conf_parse;
extern GRegex* fo_conf_replace;

int agent_verbose;

void fo_heartbeat()
{
  int processed = g_atomic_int_get(&items_processed);
  // TODO these functions are not safe for a signal handler
  fprintf(stdout, "HEART: %d %d\n", processed, alive);
  fflush(stdout);
  fflush(stderr);
  alarm(ALARM_SECS);
  alive = FALSE;
}

void fo_check_agentdb(PGconn* db_conn)
{
  PGresult* db_result = NULL;
  char* db_sql = NULL;

  db_sql = g_strdup_printf(sql_check, module_name,
    fo_config_get(sysconfig, module_name, "VERSION", NULL),
    fo_config_get(sysconfig, module_name, "COMMIT_HASH", NULL));
  db_result = PQexec(db_conn, db_sql);
  if (PQresultStatus(db_result) != PGRES_TUPLES_OK)
  {
    fprintf(stderr, "FATAL %s.%d: unable to check agent table: %s",
      __FILE__, __LINE__, PQresultErrorMessage(db_result));
    fflush(stderr);
    PQfinish(db_conn);
    PQclear(db_result);
    g_free(db_sql);
    exit(252);
  }

  if (PQntuples(db_result) != 1)
  {
    g_free(db_sql);
    PQclear(db_result);

    db_sql = g_strdup_printf(sql_insert, module_name,
      fo_config_get(sysconfig, module_name, "VERSION", NULL),
      fo_config_get(sysconfig, module_name, "COMMIT_HASH", NULL),
      fo_config_get(sysconfig, module_name, "DESCRIPTION", NULL));
    db_result = PQexec(db_conn, db_sql);
    if (PQresultStatus(db_result) != PGRES_COMMAND_OK)
    {
      fprintf(stderr, "FATAL %s.%d: unable to insert into agent table: %s",
        __FILE__, __LINE__, PQresultErrorMessage(db_result));
      fflush(stderr);
      PQfinish(db_conn);
      PQclear(db_result);
      g_free(db_sql);
      exit(251);
    }
  }

  g_free(db_sql);
  PQclear(db_result);
}

/* ************************************************************************** */
/* **** Global Functions **************************************************** */
/* ************************************************************************** */

void fo_scheduler_heart(int i)
{
  g_atomic_int_add(&items_processed, i);
  alive = TRUE;

  fflush(stdout);
  fflush(stderr);
}

void fo_scheduler_connect_conf(int* argc, char** argv, PGconn** db_conn, char** db_conf)
{
  /* locals */
  GError* error = NULL;
  GOptionContext* parsed;
  fo_conf* version;
  char fname[FILENAME_MAX + 1];

  char* db_config = NULL;
  char* db_error = NULL;

  /* command line options */
  GOptionEntry options[] =
    {
      {"config", 'c', 0, G_OPTION_ARG_STRING, &sysconfigdir, ""},
      {"userID", 0, 0, G_OPTION_ARG_INT, &userID, ""},
      {"groupID", 0, 0, G_OPTION_ARG_INT, &groupID, ""},
      {"scheduler_start", 0, 0, G_OPTION_ARG_NONE, &sscheduler, ""},
      {"jobId", 0, 0, G_OPTION_ARG_INT, &jobId, ""},
      {NULL}
    };

  /* initialize memory associated with agent connection */
  module_name = g_strdup(basename(argv[0]));
  sysconfigdir = DEFAULT_SETUP;
  items_processed = 0;
  valid = 0;
  sscheduler = 0;
  userID = -1;
  groupID = -1;
  agent_verbose = 0;
  memset(buffer, 0, sizeof(buffer));

  if (sysconfig != NULL)
  {
    LOG_WARNING("fo_scheduler_connect() has already been called.");
    sscheduler = 1;
    return;
  }

  if (getenv("FO_SYSCONFDIR"))
    sysconfigdir = getenv("FO_SYSCONFDIR");

  /* parse command line options */
  parsed = g_option_context_new("");
  g_option_context_add_main_entries(parsed, options, NULL);
  g_option_context_set_ignore_unknown_options(parsed, TRUE);
  g_option_context_set_help_enabled(parsed, FALSE);
  g_option_context_parse(parsed, argc, &argv, NULL);
  g_option_context_free(parsed);

  /* load system configuration */
  if (sysconfigdir)
  {
    snprintf(fname, FILENAME_MAX, "%s/%s", sysconfigdir, "fossology.conf");
    sysconfig = fo_config_load(fname, &error);
    if (error)
    {
      fprintf(stderr, "FATAL %s.%d: unable to open system configuration: %s\n",
        __FILE__, __LINE__, error->message);
      exit(255);
    }

    snprintf(fname, FILENAME_MAX, "%s/mods-enabled/%s/VERSION",
      sysconfigdir, module_name);

    version = fo_config_load(fname, &error);
    if (error)
    {
      fprintf(stderr, "FATAL %s.%d: unable to open VERSION configuration: %s\n",
        __FILE__, __LINE__, error->message);
      exit(254);
    }

    fo_config_join(sysconfig, version, &error);
    if (error)
    {
      fprintf(stderr, "FATAL %s.%d: unable to join configuration files: %s\n",
        __FILE__, __LINE__, error->message);
      exit(250);
    }


    fo_config_free(version);
  }

  /* create the database connection */
  if (db_conn)
  {
    db_config = g_strdup_printf("%s/Db.conf", sysconfigdir);
    (*db_conn) = fo_dbconnect(db_config, &db_error);
    if (db_conf)
      *db_conf = db_config;
    else
      g_free(db_config);
    if (db_error)
    {
      fprintf(stderr, "FATAL %s.%d: unable to open database connection: %s\n",
        __FILE__, __LINE__, db_error);
      fflush(stderr);
      exit(253);
    }
  }

  /* send "OK" to the scheduler */
  if (sscheduler)
  {
    /* check that the agent record exists */
    if (db_conn)
      fo_check_agentdb(*db_conn);

    if (fo_config_has_key(sysconfig, module_name, "VERSION"))
      fprintf(stdout, "VERSION: %s\n",
        fo_config_get(sysconfig, module_name, "VERSION", &error));
    else fprintf(stdout, "VERSION: unknown\n");
    fprintf(stdout, "\nOK\n");
    fflush(stdout);

    /* set up the heartbeat() */
    signal(SIGALRM, fo_heartbeat);
    alarm(ALARM_SECS);
  }

  fflush(stdout);
  fflush(stderr);

  alive = TRUE;
}

void fo_scheduler_connect(int* argc, char** argv, PGconn** db_conn)
{
  fo_scheduler_connect_conf(argc, argv, db_conn, NULL);
}

void fo_scheduler_connect_dbMan(int* argc, char** argv, fo_dbManager** dbManager)
{
  char* dbConf;
  PGconn* dbConnection;
  fo_scheduler_connect_conf(argc, argv, &dbConnection, &dbConf);
  *dbManager = fo_dbManager_new_withConf(dbConnection, dbConf);
  free(dbConf);
}

void fo_scheduler_disconnect(int retcode)
{
  if (module_name != NULL) {
    /* send "CLOSED" to the scheduler */
    if (sscheduler)
    {
      fo_heartbeat();
      fprintf(stdout, "\nBYE %d\n", retcode);
      fflush(stdout);

      valid = 0;
      sscheduler = 0;

      g_free(module_name);
    }

    if (strcmp(sysconfigdir, DEFAULT_SETUP))
      g_free(sysconfigdir);

    fo_config_free(sysconfig);
  }
  g_regex_unref(fo_conf_parse);
  g_regex_unref(fo_conf_replace);

  sysconfigdir = NULL;
  sysconfig = NULL;
  fo_conf_parse = NULL;
  fo_conf_replace = NULL;
  module_name = NULL;

  fflush(stdout);
  fflush(stderr);
}

char* fo_scheduler_next()
{
  fflush(stdout);

  /* get the next line from the scheduler and possibly WAIT */
  while (fgets(buffer, sizeof(buffer), stdin) != NULL)
  {
    if (agent_verbose)
      printf("\nNOTE: received %s\n", buffer);
    if (strncmp(buffer, "CLOSE", 5) == 0)
      break;
    if (strncmp(buffer, "END", 3) == 0)
    {
      fprintf(stdout, "\nOK\n");
      fflush(stdout);
      fflush(stderr);
      valid = 0;
      continue;
    }
    else if (strncmp(buffer, "VERBOSE", 7) == 0)
    {
      agent_verbose = atoi(&buffer[8]);
      valid = 0;
      continue;
    }
    else if (strncmp(buffer, "VERSION", 7) == 0)
    {
      if (fo_config_has_key(sysconfig, module_name, "VERSION"))
        fprintf(stdout, "VERSION: %s\n",
          fo_config_get(sysconfig, module_name, "VERSION", NULL));
      else fprintf(stdout, "VERSION: unknown\n");
      fflush(stdout);
      fflush(stderr);
      valid = 0;
      continue;
    }

    buffer[strlen(buffer) - 1] = '\0';
    valid = 1;
    return buffer;
  }

  valid = 0;

  fflush(stdout);
  fflush(stderr);

  return NULL;
}

char* fo_scheduler_current()
{
  return valid ? buffer : NULL;
}

void fo_scheduler_set_special(int option, int value)
{
  fprintf(stdout, "SPECIAL: %d %d\n", option, value);
  fflush(stdout);
}

int fo_scheduler_get_special(int option)
{
  int value;

  fprintf(stdout, "GETSPECIAL: %d\n", option);
  fflush(stdout);

  if (fscanf(stdin, "VALUE: %d\n", &value) != 1)
    return 0;
  return value;
}

int fo_scheduler_jobId()
{
  return jobId;
}

int fo_scheduler_userID()
{
  return userID;
}

int fo_scheduler_groupID()
{
  return groupID;
}

char* fo_sysconfig(const char* sectionname, const char* variablename)
{
  GError* error = NULL;
  char* ret;

  ret = fo_config_get(
    sysconfig,
    sectionname,
    variablename,
    &error);

  fflush(stdout);
  fflush(stderr);

  if (error)
  {
    g_clear_error(&error);
    ret = NULL;
  }

  return ret;
}