agent.h

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
*/
 
#ifndef AGENT_H_INCLUDE
#define AGENT_H_INCLUDE
 
/* local includes */
#include <host.h>
#include <job.h>
#include <scheduler.h>
 
/* unix library includes */
#include <sys/types.h>
 
/* glib includes */
#include <gio/gio.h>
#include <glib.h>
 
/* ************************************************************************** */
/* **** Data Types ********************************************************** */
/* ************************************************************************** */
 
#define MAX_CMD     1023 
#define MAX_NAME    255  
#define MAX_ARGS    32   
#define DEFAULT_RET -1   
 
#define LOCAL_HOST "localhost"
 
#define SAG_NOKILL     (1 << 0) 
#define SAG_EXCLUSIVE  (1 << 1) 
#define SAG_NOEMAIL    (1 << 2) 
#define SAG_LOCAL      (1 << 3) 
 
#define AGENT_STATUS_TYPES(apply)                                   \
                          \
  apply(FAILED)                                                     \
                 \
  apply(CREATED)                                                    \
       \
  apply(SPAWNED)                                                    \
                               \
  apply(RUNNING)                                                    \
 \
  apply(PAUSED)                                                     \
   \
  apply(CLOSED)                                                     \
 
#define SELECT_ENUM(passed) AG_##passed,
typedef enum { AGENT_STATUS_TYPES(SELECT_ENUM) } agent_status;
#undef SELECT_ENUM
 
extern const char* agent_status_strings[];
 
typedef int agent_pk;
 
typedef struct
{
    char name[256];             
    char raw_cmd[MAX_CMD + 1];  
    int max_run;                
    int special;                
    char* version_source;       
    char* version;              
    int valid;                  
    int run_count;              
} meta_agent_t;
 
typedef struct
{
    /* we need all the information on creating the agent */
    meta_agent_t* type; 
    host_t*       host; 
 
    /* thread management */
    agent_status status;    
    GThread*     thread;    
    time_t       check_in;  
    uint8_t      n_updates; 
    pid_t        pid;       
 
    /* pipes connecting to the child */
    int from_parent;  
    int to_child;     
    int from_child;   
    int to_parent;    
    FILE* read;       
    FILE* write;      
 
    /* data management */
    job_t*   owner;           
    gchar*   data;            
    gboolean updated;         
    uint64_t total_analyzed;  
    gboolean alive;           
    uint8_t  return_code;     
    uint32_t special;         
} agent_t;
 
/* ************************************************************************** */
/* **** Constructor Destructor ********************************************** */
/* ************************************************************************** */
 
/* meta agent */
meta_agent_t* meta_agent_init(char* name, char* cmd, int max, int spc);
void meta_agent_destroy(meta_agent_t* meta_agent);
 
/* agent */
agent_t* agent_init(scheduler_t* scheduler, host_t* host, job_t* owner);
void agent_destroy(agent_t* agent);
 
/* ************************************************************************** */
/* **** Modifier Functions and events *************************************** */
/* ************************************************************************** */
 
void agent_death_event(scheduler_t* scheduler, pid_t* pids);
void agent_create_event(scheduler_t* scheduler, agent_t* agent);
void agent_ready_event(scheduler_t* scheduler, agent_t* agent);
void agent_update_event(scheduler_t* scheduler, void* unused);
void agent_fail_event(scheduler_t* scheduler, agent_t* agent);
void list_agents_event(scheduler_t* scheduler, GOutputStream* ostr);
 
void agent_transition(agent_t* agent, agent_status new_status);
void agent_pause(agent_t* agent);
void agent_unpause(agent_t* agent);
void agent_print_status(agent_t* agent, GOutputStream* ostr);
void agent_kill(agent_t* agent);
int  aprintf(agent_t* agent, const char* fmt, ...);
ssize_t agent_write(agent_t* agent, const void* buf, int count);
 
/* ************************************************************************** */
/* **** static functions and meta agents ************************************ */
/* ************************************************************************** */
 
void test_agents(scheduler_t* scheduler);
int  add_meta_agent(GTree* meta_agents, char* name, char* cmd, int max, int spc);
 
void kill_agents(scheduler_t* scheduler);
 
int  is_meta_special(meta_agent_t* ma, int special_type);
int  is_agent_special(agent_t* agent, int special_type);
 
void meta_agent_increase_count(meta_agent_t*);
void meta_agent_decrease_count(meta_agent_t*);
 
#endif /* AGENT_H_INCLUDE */