evaluationmanager.c

Go to the documentation of this file.

/*                                                                                                            
 * Copyright (c) Members of the EGEE Collaboration. 2004.
 * See http://eu-egee.org/partners/ for details on the copyright holders.
 * For license conditions see the license file or
 * http://eu-egee.org/license.html
 */

/*
 *   Copyright (c) 2003 EU DataGrid        http://www.eu-datagrid.org/
 *
 *   $Id: evaluationmanager.c,v 1.31 2005/03/01 17:05:10 venekamp Exp $
 *
 *   Copyright (c) 2003 by
 *      G.M. Venekamp <venekamp@nikhef.nl>
 *      NIKHEF Amsterdam, the Netherlands
 *
 *   This software is distributed under a BSD-style open source
 *   licence. For a complete description of the licence take a look
 *   at: http://eu-datagrid.web.cern.ch/eu-datagrid/license.html
 *
 */


#include <stdlib.h>
#include <string.h>

#include "_lcmaps_pluginmanager.h"
#include "lcmaps_log.h"
#include "evaluationmanager.h"

static lcmaps_db_entry_t* global_plugin_list = NULL;

int free_lcmaps_db_entry();


int startEvaluationManager(const char* name, int argc, char*argv[])
{
  if (pdl_init(name) < 0) {
    stopEvaluationManager();
    return -1;
  }

  SetSetOfRules(argc, argv);

  /*  Let's see if the config file makes sence.  */
  yyparse();

  /*
   *  Check if there were any errors. Ifo so, there is not much point
   *  on continuing.
   */
  if (yyparse_errors()) {
    stopEvaluationManager();
    return -1;
  }

  /*
   *  It might be that we have allocated policy rulez without any rules
   *  attachted to it. Before we can continue we must clean up the tree
   *  a free the allocated policy rules with an empty rule set.
   */
  cleanup_policies();

  /*
   *  Check to see if there are any recustions in the config file.
   *  If so, continuing might/will cause an infinite loop.
   */
  if (check_policies_for_recursion())
    return -1;


  /*
   *  We need to replace the variables found in the policy rules by
   *  their respective values.
   */
  reduce_policies();

  return 0;
}


int getPluginNameAndArgs(lcmaps_db_entry_t** plugins)
{
  const plugin_t* p_list, *tmp_p_list;
  lcmaps_db_entry_t* p=0;
  int path_length;
  char* path;
  BOOL string_too_long;

  string_too_long = FALSE;

  /*  Check if the plugins have been requested before.  */
  if (global_plugin_list) {
    *plugins = global_plugin_list;
    return 0;
  }

  /*  Set to a safe default value.  */
  *plugins = 0;

  if (!pdl_path()) {
    lcmaps_log(1, "Initialization of the EvaluationManager either failed or was not done.\n");
    return -1; 
  }

  path = strdup(pdl_path());
  path_length = strlen(path);

  if (path[path_length-1] != '/') {
    path = (char *)realloc(path, path_length+2);
    path[path_length] = '/';
    path[path_length+1] = '\0';

    path_length = strlen(path);
  }

  p_list = get_plugins();

  while (p_list) {
    if (!*plugins) {
      *plugins = (lcmaps_db_entry_t*)malloc(sizeof(lcmaps_db_entry_t));
      p = *plugins;
    } else {
      p->next = (lcmaps_db_entry_t*)malloc(sizeof(lcmaps_db_entry_t));
      p = p->next;
    }

    /*  Copy the name and arguments while respecting max. lengths.  */
    strncpy(p->pluginname, path, LCMAPS_MAXPATHLEN);
    strncpy(p->pluginname+path_length, p_list->name, LCMAPS_MAXPATHLEN-path_length);

    if ((strlen(path) + strlen(p_list->name))>=LCMAPS_MAXPATHLEN) {
      lcmaps_log(1, "String too long to copy. Max length = %d\n", LCMAPS_MAXPATHLEN);
      string_too_long = TRUE;
    }

    if (p_list->args) {
      strncpy(p->pluginargs, p_list->args, LCMAPS_MAXARGSTRING);
      if (strlen(p_list->args)>LCMAPS_MAXARGSTRING) {
        lcmaps_log(1, "String too long to copy. Max length = %d\n", LCMAPS_MAXARGSTRING);
        string_too_long = TRUE;
      }
    }
    else
      *p->pluginargs = '\0';
    p->next = 0;

    tmp_p_list = p_list->next;

//    if (p_list->name)  free(p_list->name);
//    if (p_list->args)  free(p_list->args);
//    free((plugin_t*)p_list);

    p_list = tmp_p_list;

    /*  Output some debug info.  */
    lcmaps_log_debug(1, "%s\n", p->pluginname);
    lcmaps_log_debug(1, "%s\n", p->pluginargs);
  }

  free(path);

  global_plugin_list = *plugins;

  return string_too_long ? -1 : 0;
}


int runEvaluationManager(int argc, char *argv[])
{
  const char* plugin_name;
  plugin_status_t result;
  const policy_t* policy;
  int policy_seen;

  policy_seen = 0;

  result = EVALUATION_START;
  while ((plugin_name=pdl_next_plugin(result))) {
    /*
     *  First check if we have to look for one specific policy rule.
     *  If it is not the case, the old behaviour is unaffected.
     */
    if (argc) {
      int i;
      int found = 0;
      policy = get_current_policy();
      /*
       *  Let us find out whether we have found the requested policy.
       */

      for (i=0; policy && (i<argc); ++i) {
        if (strcmp(policy->name, argv[i])==0) {
          found = 1;
          break;
        }
      }

      if (found) {
        /*
         *  Target policy has been found. Set a flag to indicate when
         *  the current policy is left, the search for next policy rules
         *  will be aborted.
         *
         */
        policy_seen = 1;
      } else {
        if (plugin_name) free((char *)plugin_name);

        /*
         *  We are looking for a specific policy rule and the current one
         *  is not the onw we are looking for. There are two situations in
         *  which we are here:
         *    - current policy is not the one we are looking for, and
         *      we have not yet seen it;
         *    - current policy is not the one we are looking for, and
         *      we have seen the one we wanted before.
         *  If we have seen the policy rule we are looking for, we are
         *  done. If not, we need to continue to look for it.
         *
         */
        if (policy_seen)
          break;
        else {
          /*
           *  Set the result to EVALUATION_FAILURE in order to fall through
           *  the next policy rule. This might take a few steps though!
           */
          result = EVALUATION_FAILURE;
          continue;
        }
      }
    }

    result = (runPlugin(plugin_name) ? EVALUATION_FAILURE : EVALUATION_SUCCESS);
    
    lcmaps_log_debug(1, "runEvaluationManager: running plugin: %s.\n", plugin_name);
    lcmaps_log_debug(1, "                    : result %s.\n", (result==EVALUATION_SUCCESS) ? "true" : "false");
    
    if (plugin_name) free((char *)plugin_name);
  }

  if (result==EVALUATION_START)
    lcmaps_log(1, "Initialization of the EvaluationManager either failed or was not done.\n");

  return result==EVALUATION_SUCCESS ? 0 : 1;
}


int stopEvaluationManager(void)
{
  lcmaps_log_debug(1, "stopEvaluationManager: cleaning up!\n");

  free_resources();

  free_lcmaps_db_entry();

  return 0;
}


int free_lcmaps_db_entry()
{
  lcmaps_db_entry_t* plugin = global_plugin_list;

  while (plugin) {
    lcmaps_db_entry_t* tmp = plugin->next;
    free(plugin);
    plugin = tmp;
  }

  global_plugin_list = NULL;

  return 0;
}

---