host.c

Go to the documentation of this file.

/*
 SPDX-FileCopyrightText: © 2010, 2011, 2012 Hewlett-Packard Development Company, L.P.
 
 SPDX-License-Identifier: GPL-2.0-only
*/
/* local includes */
#include <host.h>
#include <logging.h>
#include <scheduler.h>
 
/* ************************************************************************** */
/* **** Locals ************************************************************** */
/* ************************************************************************** */
 
static int print_host_all(gchar* host_name, host_t* host, GOutputStream* ostr)
{
  host_print(host, ostr);
  return 0;
}
 
/* ************************************************************************** */
/* **** Contructor Destructor *********************************************** */
/* ************************************************************************** */
 
host_t* host_init(char* name, char* address, char* agent_dir, int max)
{
  host_t* host = g_new0(host_t, 1);
 
  host->name = g_strdup(name);
  host->address = g_strdup(address);
  host->agent_dir = g_strdup(agent_dir);
  host->max = max;
  host->running = 0;
 
  return host;
}
 
void host_destroy(host_t* host)
{
  g_free(host->name);
  g_free(host->address);
  g_free(host->agent_dir);
 
  host->name = NULL;
  host->address = NULL;
  host->agent_dir = NULL;
  host->max = 0;
  host->running = 0;
 
  g_free(host);
}
 
/* ************************************************************************** */
/* **** Functions and events ************************************************ */
/* ************************************************************************** */
 
void host_insert(host_t* host, scheduler_t* scheduler)
{
  g_tree_insert(scheduler->host_list, host->name, host);
  scheduler->host_queue = g_list_append(scheduler->host_queue, host);
}
 
void host_increase_load(host_t* host)
{
  host->running++;
  V_HOST("HOST[%s] load increased to %d\n", host->name, host->running);
}
 
void host_decrease_load(host_t* host)
{
  host->running--;
  V_HOST("HOST[%s] load decreased to %d\n", host->name, host->running);
}
 
void host_print(host_t* host, GOutputStream* ostr)
{
  char* buf;
 
  buf = g_strdup_printf("host:%s address:%s max:%d running:%d\n",
      host->name, host->address, host->max, host->running);
  g_output_stream_write(ostr, buf, strlen(buf), NULL, NULL);
 
  g_free(buf);
}
 
host_t* get_host(GList** queue, uint8_t num)
{
  GList*  host_queue = *queue;
  GList*  curr       = NULL;
  host_t* ret        = NULL;
 
  for(curr = host_queue; curr != NULL; curr = curr->next)
  {
    ret = curr->data;
    if(ret->max - ret->running >= num)
      break;
  }
 
  if(curr == NULL)
    return NULL;
 
  host_queue = g_list_remove(host_queue, ret);
  host_queue = g_list_append(host_queue, ret);
 
  *queue = host_queue;
  return ret;
}
 
void print_host_load(GTree* host_list, GOutputStream* ostr)
{
  g_tree_foreach(host_list, (GTraverseFunc)print_host_all, ostr);
  g_output_stream_write(ostr, "\nend\n", 5, NULL, NULL);
}