Rx3/liblog-bdm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Première version

Browse Source
This commit is contained in:
smas 2000-07-31 13:15:35 +00:00
commit 43e6f0ee89
16 changed files with 10505 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

638
lib/liblog.3 Normal file
View File

@ -0,0 +1,638 @@
'\" t
.\" @(#)LIBLOG.3 1.0 00/07/04 SMA;
.TH LIBLOG 3 "07 Apr 2000"
.SH NOM
LIBLOG (librairie d'interface avec le systeme de suivi et de pilotage)
.SH SYNOPSIS
.LP
.BI "cc [flag ...] file ... -lver -ldl -lnode -lshmem -ldatastr -lmsg -ladm -lgen -llog [library ...]"
.LP
.BI "#include <log.h>"
.LP
.BI "LOGT_Status LOG_Library_Open ( int " Instance ", LOGT_Flags " Open_Mode ");"
.LP
.BI "LOGT_Status LOG_Library_Close ( LOGT_Flags " Close_Mode ");"
.LP
.BI "LOGT_Status LOG_Library_Stderr_Set ( FILE * " Out ");"
.LP
.BI "LOGT_Status LOG_Channel_Open ( LOGT_Channel ** " Channel ", int " Pid ", int " Channel_Id ", char * " Module_Name ", char * " Master_Module_Name ");"
.LP
.BI "LOGT_Status LOG_Channel_Enter ( LOGT_Channel * " Channel ", char * " Sub_Module_Name ");"
.LP
.BI "LOGT_Status LOG_Channel_Leave ( LOGT_Channel * " Channel ", char * " Sub_Module_Name ");"
.LP
.BI "LOGT_Status LOG_Channel_Close ( LOGT_Channel * " Channel ");"
.LP
.BI "LOGT_Status LOG_RTab_Alloc ( LOGT_RTab ** " Rtab ", char * " Name " );"
.LP
.BI "LOGT_Status LOG_RTab_Setup ( LOGT_RTab * " RTab ", LOGT_RuleClass " Rule_Class ", LOGT_Rule " Rule ", LOGT_Rooting " Value ");"
.LP
.BI "LOGT_Status LOG_RTab_Add ( LOGT_Channel * " Channel ", LOGT_RTab * " RTab ");"
.LP
.BI "LOGT_Status LOG_RTab_Remove ( LOGT_Channel * " Channel ", LOGT_RTab * " RTab ");"
.LP
.BI "LOGT_Status LOG_RTab_Free ( LOGT_RTab * " RTab ");"
.LP
.BI "LOGT_Status LOG_Trigger_Add ( LOGT_Trigger ** " Trigger ", LOGT_Channel * " Channel ", LOGT_RTab * " RTab ", char * " Event_Type ", LOGT_Flags " Trigger_Mode ");"
.LP
.BI "LOGT_Status LOG_Trigger_Remove ( LOGT_Trigger * " Trigger ");"
.LP
.BI "LOGT_Status LOG_Event_Send ( LOGT_Channel * " Channel ", LOGT_RC * " Return_Code ", char * " Cd_Support ", va_list " Data ");"
.LP
.BI "LOGT_RC LOG_Event_External_Send ( LOGT_Channel * " Channel ", char * " Cd_Support ", char * " Data ");"
.LP
.BI "LOGT_Status LOG_Event_Info_Get ( LOGT_Channel * " Channel ", LOGT_Info * " Info ", va_list " Data ");"
.LP
.BI "LOGT_Status LOG_Event_Cpt_Get ( LOGT_Channel * " Channel ", int * " Cpt "[LOGD_RC_SIZE], char * " Reg_Expr ");"
.LP
.SH FONCTIONS
.LP
.BI "LOGT_Status LOG_Library_Open ( int " Instance ", LOGT_Flags " Open_Mode ");"
.LP
.RS 3
La librairie LIBLOG met en place des ressources partagees par tous les traitements qui utilise la meme instance de la librairie LIBLOG :
.LP
.RS 3
- les tables de routage systeme (GMRT et GDRT)
.LP
- le cache des modules
.LP
- le cache des formats d'evenement
.LP
- la queue de messages pour inserer les evenements en base
.RS -3
.LP
Cette fonction permet d'acceder a ces ressources partagees pour une instance particuliere de la librairie:
.LP
.RS 3
- en creation si
.I Open_Mode
vaut
.B LOGD_CREATE
.LP
- en ouverture simple si
.I Open_Mode
vaut
.B LOGD_OPEN
.RS -3
.LP
.I NB
: l'indicateur d'ouverture
.I Open_Mode
pourra etre combinee avec un mode de debugging (
.B MSGD_DEBUG_NONE
: aucun message d'erreur n'est affiche
.LP
.B MSGD_DEBUG
: les messages d'erreur generes par la librairie LIBMSG sont affiches sur la sortie standard d'erreur
.LP
.B MSGD_DEBUG_ALL
: les messages d'erreur generes par toutes les librairies sous-jacentes a la LIBMSG sont affiches sur la sortie standard d'erreur
.LP
.I NB
: l'appel a cette fonction est obligatoire avant d'utiliser toute autre fonction de la librairie LIBLOG.
.LP
Le mode
.B LOGD_CREATE
est exclusivement reserve aux administrateurs !
.LP
.RS -3
.BI "LOGT_Status LOG_Library_Close ( LOGT_Flags " Close_Mode " );"
.LP
.RS 3
Cette fonction permet de fermer ou de supprimer les ressources partagees de l'instance qu a ete ouverte :
.LP
.RS 3
- Suppression si
.I Close_Mode
vaut
.B LOGD_DESTROY
.LP
- Fermeture simple si
.I Close_Mode
vaut
.B LOGD_CLOSE
.RS -3
.LP
.I NB
: la fermeture de la librairie est absolument necessaire une fois qu'un traitement a fini de l'utiliser.
.LP
Le mode
.B LOGD_DESTROY
est exclusivement reserve aux administrateurs !
.LP
.RS -3
.BI "LOGT_Status LOG_Library_Stderr_Set ( FILE * " Out " );"
.LP
.RS 3
Cette fonction permet de definir
.I Out
comme la sortie standard des messages d'erreur de la librarie.
.RS -3
.LP
.BI "LOGT_Status LOG_Channel_Open ( LOGT_Channel ** " Channel ", int " Pid ", int " Channel_Id ", char * " Module_Name ", char * " Master_Module_Name ");"
.LP
.RS 3
Cette fonction permet de creer un channel a travers lequel des evenements seront envoyes au systeme de suivi.
Elle requiert les arguments suivants :
.RS 3
.LP
* (Out)
.I Channel
: l'adresse du pointeur sur le channel a creer
.LP
* (In)
.I Pid
: l'identifiant du processus proprietaire du channel
.LP
* (In)
.I Channel_Id
: l'identifiant du channel
.LP
* (In)
.I Module_Name
: le nom du module proprietaire du channel
.LP
* (In)
.I Master_Module_Name
: le nom du module maitre (facultatif)
.RS -3
.LP
.I Pour info
:
Le nom du module proprietaire du channel permet de connaitre le traitement qui est a l'origine des evenements qui sont envoyes au suivi. Le nom du module maitre permet de connaitre le contexte de lancement de ce traitement.
.LP
Le numero du processus permet de distinguer differents processus realisant un meme traitement.
.LP
L'identifiant du channel permet de distinguer les differents channels d'un meme processus.
.LP
.I NB
: si le numero de processus passe en parametre vaut 0, alors c'est le processus courant qui sera considere comme processus proprietaire.
Ce parametre doit surtout etre renseigne pour les programmes shell, afin que ce ne soit pas le numero de processus demon qui soit pris en compte.
.LP
Par convention, en fonctionnement mono-thread, l'identifiant du channel sera fixe a 0. En fonctionnement multi-thread, l'utilisateur est libre de fixer ce parametre comme il le veut.
.LP
.I NB
: si le nom du module maitre vaut NULL, alors il sera renseigne avec le nom du module proprietaire du channel.
.LP
.RS -3
.BI "LOGT_Status LOG_Channel_Enter ( LOGT_Channel * " Channel ", char * " Sub_Module_Name " );"
.LP
.RS 3
Cette fonction permet d'affecter un sous-module a un channel.
Un sous-module correspond en general au nom d'une fonction du traitement. Il permet de mieux identifier la partie du traitement qui genere les evenements.
.LP
Elle requiert les arguments suivants :
.RS 3
.LP
* (In)
.I Channel
: le pointeur sur le channel de communication
.LP
* (In)
.I Sub_Module_Name
: le nom du sous-module a attacher au channel
.RS -3
.LP
.RS -3
.BI "LOGT_Status LOG_Channel_Leave ( LOGT_Channel * " Channel ", char * " Sub_Module_Name " );"
.LP
.RS 3
Cette fonction permet de supprimer un sous-module d'un channel.
Le sous-module qui lui avait ete precedemment affecte est devient alors le sous-module actif.
.LP
Elle requiert les arguments suivants :
.RS 3
.LP
* (In)
.I Channel
: le pointeur sur le channel de communication
.LP
* (In)
.I Sub_Module_Name
: le nom du sous-module a supprimer du channel
.RS -3
.LP
.RS -3
.BI "LOGT_Status LOG_Channel_Close ( LOGT_Channel * " Channel " );"
.LP
.RS 3
Cette fonction permet de fermer un channel.
.LP
.I Channel
est un pointeur sur le channel a fermer
.LP
.RS -3
.BI "LOGT_Status LOG_RTab_Alloc ( LOGT_RTab ** " Rtab ", char * " Name " );"
.LP
.RS 3
Cette fonction permet de creer une table de routage utilisateur.
.LP
Elle requiert les arguments suivants :
.RS 3
.LP
* (Out) RTab
: adresse d'un pointeur sur la table de routage a creer.
.LP
* (In) Name
: nom de la table de routage.
.RS -3
.LP
.RS -3
.BI "LOGT_Status LOG_RTab_Setup ( LOGT_RTab * " RTab ", LOGT_RuleClass " Rule_Class ", LOGT_Rule " Rule ", LOGT_Rooting " Value " );"
.LP
.RS 3
Cette fonction permet de parametrer une table de routage utilisateur, par ajout d'une regle de routage.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I RTab
: un pointeur sur la table de routage
.LP
* (In)
.I Rule_Class
: la classe de la nouvelle regle
.LP
* (In)
.I Rule
: la nouvelle regle
.LP
* (In)
.I Value
: la valeur de la nouvelle regle
.RS -3
.LP
La classe de regle designe la maniere de selectionner les types d'evenement concernes par la nouvelle regle :
.LP
.RS 3
-
.B LOGD_SELECT_ALL
: selection de tous les types d'evenements
.LP
-
.B LOGD_SELECT_GRV
: selection des types d'evenement selon leur gravite
.LP
-
.B LOGD_SELECT_RC
: selection des types d'evenement selon le code retour qui y est associe
.LP
-
.B LOGD_SELECT_TYPE
: selection des types d'evenement selon leur nom
.RS -3
.LP
La regle depend de la classe de regle choisie:
.LP
.RS 3
- NULL pour la classe
.B LOGD_SELECT_ALL
.LP
- code gravite pour la classe
.B LOGD_SELECT_GRV
.LP
- code retour pour la classe
.B LOGD_SELECT_RC
.LP
- nom du type d'evenement (expression reguliere) pour la classe
.B LOGD_SELECT_TYPE
.RS -3
.LP
La valeur de la regle est le type de routage a appliquer aux types d'evenement concernes par la regle :
.RS 3
.LP
-
.B LOGD_NULL
: routage vers /dev/null (aucun traitement de l'evenement)
.LP
-
.B LOGD_STDERR
: affichage de l'evenement sur la sortie standard d'erreur
.LP
-
.B LOGD_DATABASE
: insertion de l'evenement dans la base de donnees du suivi
.LP
-
.B LOGD_DEFAULT
: routage par defaut
.LP
-
.B LOGD_PREVIOUS
: routage defini dans la table de routage precedente
.RS -3
.LP
Pour parametrer une table de routage utilisateur, on commencera par definir les regles les plus generales (LOGD_ALL) et finir avec les regles les plus specifiques.
.LP
.RS -3
.BI "LOGT_Status LOG_RTab_Add ( LOGT_Channel * " Channel ", LOGT_RTab * " RTab " );"
.LP
.RS 3
Cette fonction permet d'affecter une nouvelle table de routage utilisateur a un channel.
.LP
Elle requiert les arguments suivants :
.RS 3
.LP
* (In)
.I Channel
: un pointeur sur le channel
.LP
* (In)
.I RTab
: un pointeur sur la table de routage
.RS -3
.LP
.RS -3
.BI "LOGT_Status LOG_RTab_Remove ( LOGT_Channel * " Channel ", LOGT_RTab * " RTab " );"
.LP
.RS 3
Cette fonction permet de supprimer l'association d'une table de routage utilisateur a un channel.
.LP
Elle requiert les arguments suivants :
.RS 3
.LP
* (In)
.I Channel
: un pointeur sur le channel
.LP
* (In)
.I RTab
: un pointeur sur la table de routage
.RS -3
.LP
L'utilisateur pourra utiliser la constante LOGD_TOP_RTAB comme deuxieme argument, pour supprimer la table de routage de tete (la plus recemment associee au channel).
.LP
.RS -3
.BI "LOGT_Status LOG_RTab_Free ( LOGT_RTab * " RTab " );"
.LP
.RS 3
Cette fonction permet de supprimer une table de routage utilisateur.
.LP
.I RTab
est un pointeur sur la table de routage a supprimer.
.LP
NB : avant de supprimer une table de routage, on verifiera qu'elle n'est attachee a aucun channel.
.LP
.RS -3
.BI "LOGT_Status LOG_Trigger_Add ( LOGT_Trigger ** " Trigger ", LOGT_Channel * " Channel ", LOGT_RTab * "RTab ", char * " Event_Type ", LOGT_Flags " Trigger_Mode " );"
.LP
.RS 3
Cette fonction permet d'ajouter un trigger a un channel.
.LP
Elle requiert les arguments suivants :
.RS 3
.LP
* (Out)
.I Trigger
: l'adresse du pointeur sur le nouveau trigger
.LP
* (In)
.I Channel
: un pointeur sur le channel
.LP
* (In)
.I RTab
: un pointeur sur la table de routage concernee
.LP
* (In)
.I Event_Type
: le type d'evenement declencheur (expression reguliere)
.LP
* (In)
.I Trigger_Mode
: le mode de fonctionnement du trigger
.RS -3
.LP
.I Rappel
:
.LP
Si un trigger fonctionne sur le mode
.B LOGD_ONESHOT
, il est automatiquement supprime des lors qu'il a ete active. En mode
.B LOGD_PERMANENT
, le trigger reste active en permanence.
.LP
Si un trigger fonctionne sur le mode
.B LOGD_ADD
, l'activation du trigger provoque l'association de la table de routage avec le channel. Avec le mode
.B LOGD_REMOVE
, l'activation du trigger correspond a leur dissociation.
.LP
Les differents modes de fonctionnement peuvent etre combines par addition binaire.
.LP
.I NB
: plusieurs triggers peuvent etre poses sur un meme channel.
.LP
.RS -3
.BI "LOGT_Status LOG_Trigger_Remove ( LOGT_Trigger * " Trigger " );"
.LP
.RS 3
Cette fonction permet de supprimer un trigger positionne sur un channel.
.LP
.I Trigger
est un pointeur sur le trigger a supprimer.
.LP
.RS -3
.BI "LOGT_Status LOG_Event_Send ( LOGT_Channel * " Channel ", LOGT_RC * " Return_Code ", char * " Cd_Support ", va_list " Data ");"
.LP
.RS 3
Cette fonction permet d'envoyer un evenement a travers un channel et de recuperer le code retour associe au type d'evenement (pilotage).
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I Channel
: un pointeur sur le channel
.LP
* (Out)
.I RC
: un pointeur sur le code retour
.LP
* (In)
.I Cd_Support
: le code du support source
.LP
* (In)
.I Data
: une liste d'arguments contenant les donnees de l'evenement
.RS -3
.LP
.RS -3
.BI "LOGT_RC LOG_Event_External_Send ( LOGT_Channel * " Channel ", char * " Cd_Support ", char * " Data ");"
.LP
.RS 3
Cette fonction est definie pour tous les appels a partir de programmes ecrits en PL/SQL.
Elle permet d'envoyer un evenement a travers un channel et de recuperer le code retour associe au type d'evenement (pilotage).
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I Channel
: un pointeur sur le channel
.LP
* (In)
.I Cd_Support
: le code du support source
.LP
* (In)
.I Data
: une chaine de caracteres contenant les donnees de l'evenement
.RS -3
.LP
.I NB
: la fonction retourne le code retour associe au type d'evenement.
.LP
.RS -3
.BI "LOGT_Status LOG_Event_Info_Get ( LOGT_Channel * " Channel ", LOGT_Info * " Info ", va_list " Data " );"
.LP
.RS 3
Cette fonction permet de simuler l'envoi d'un evenement et de recuperer toutes les informations concernant le type par lequel il a ete resolu.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I Channel
: un pointeur sur le channel
.LP
* (Out)
.I Info
: un pointeur sur les informations a recuperer
.LP
* (In)
.I Data
: une liste d'arguments contenant les donnees de l'evenement a tester
.RS -3
.LP
.I NB
: le type LOGT_Info est une structure qui contient les informations suivantes :
.LP
.RS 3
-
.B EvtType
(type d'evenement par lequel l'evenement est resolu) de type char *
.LP
-
.B RC
(code retour associe) de type
.B LOGT_RC
.LP
-
.B Gravite
(code gravite associe) de type
.B LOGT_Gravite
.LP
-
.B Rooting
(routage associe) de type
.B LOGT_Rooting
.RS -3
.LP
.RS -3
.BI "LOGT_Status LOG_Event_Info_External_Get ( LOGT_Channel * " Channel ", LOGT_Info * " Info ", char * " Event_Name " );"
.LP
.RS 3
Cette fonction permet de simuler l'envoi d'un evenement et de recuperer toutes les informations concernant le type par lequel il a ete resolu.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I Channel
: un pointeur sur le channel
.LP
* (Out)
.I Info
: un pointeur sur les informations a recuperer
.LP
* (In)
.I Event_Name
: le nom de l'evenement a tester
.RS -3
.LP
.RS -3
.BI "LOGT_Status LOG_Event_Cpt_Get ( LOGT_Channel * " Channel ", int * " Cpt " [LOGD_RC_SIZE], char * " Reg_Expr " );"
.LP
.RS 3
Cette fonction permet de recuperer les compteurs d'evenements dont le nom correspond a une expression reguliere.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I Channel
: un pointeur sur le channel
.LP
* (Out)
.I Cpt
: un pointeur sur un tableau de compteurs
.LP
* (In)
.I Reg_Expr
: une expression reguliere
.RS -3
.LP
.I NB
: le tableau de compteurs doit etre alloue par l'utilisateur.
.LP
La fonction retourne dans ce tableau le nombre d'evenements correspondant a l'expression reguliere ayant ete envoyes via le channel pour chacun des codes retour.
.LP
.I Exemple
: Cpt[LOGD_RC_OK] contiendra le nombre d'evenements envoyes ayant retourne le code LOGD_RC_OK.
.SH CODES RETOUR
.LP
Toutes les fonctions constituant l'API de la librairie LIBLOG retournent un code de type
.B LOGT_Status
:
.LP
.RS 3
-
.B LOGS_OK
: la fonction s'est correctement executee et a produit un resultat
.LP
-
.B LOGS_KO
: la fonction s'est correctement executee mais n'a pas produit de resultat
.LP
-
.B LOGS_ERRAPI
: la fonction a ete appelee avec des arguments de valeur incorrecte
.LP
-
.B LOGS_ERRMEM
: la fonction ne s'est pas correctement executee pour un probleme d'allocation memoire
.LP
-
.B LOGS_ERRSHM
: la fonction ne s'est pas correctement executee pour un probleme relatif a la memoire partagee
.LP
-
.B LOGS_ERRSIG
: une operation sur semaphore a ete interrompue par un signal
.LP
-
.B LOGS_ERRSEM
: la fonction ne s'est pas correctement executee pour un probleme relatif a l'utilisation des semaphores
.LP
-
.B DSS_ERRDLL
: la fonction ne s'est pas correctement executee pour un probleme de chargement dynamique d'objet
.LP
.RS -3
.I NB
: la macro
.B LOG_ERROR()
permet de tester si un code retour correspond a une erreur.
.LP
En cas d'erreur, la variable
.B LOG_Error_Msg
contient un message du type :
.LP
.RS 3
Error <Nom fonction> : <message d'erreur>
.RS -3
.LP

4725
lib/liblog.c Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
lib/liblog.doc Normal file
View File

Binary file not shown.

179
lib/liblog.h Normal file
View File

@ -0,0 +1,179 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>
#include <ctype.h>
#include <ver.h>
#include <log.h>
/* Expressions régulières */
#ifdef LINUX
#include <regex.h>
typedef regex_t RegExp_t;
#define RegExp_Size sizeof (regex_t)
#define RegExp_Compile(s, e) regcomp (e, s, REG_NOSUB) == 0
#define RegExp_Match(s, e) regexec (e, s, 0, NULL, 0) != REG_NOMATCH
#else
#include <regexpr.h>
typedef char RegExp_t;
#define RegExp_Size 256
#define RegExp_Compile(s, e) compile (s, e, e + RegExp_Size)
#define RegExp_Match(s, e) step (s, e)
#endif
extern char * strdup (const char *);
/* Nom de la variable d'environnement définissant la valeur par défaut du module maître */
#define MASTER_MODULE_ENV "MASTER"
#define LOG_FILE_MANAGER "liblog.so"
/* Tous les heaps et data structures générés par la librairie LIBLOG sont préfixés */
#define LOG_PREFIX "LOG"
/* Port de messages d'envoi des événements */
MSGT_Port * Send_Port;
/* Elément du cache des modules */
typedef struct {
char * Name; /* Nom du module (sert à la recherche) */
int Id; /* Identifiant numérique du type d'événement */
} LOGT_Module;
/* Elément de la table de routage GDRT */
typedef struct {
char * Name; /* Nom du type d'événement (base de recherche) */
int Terminal; /* Signifie que le type d'événement existe sans contexte */
int Id; /* Identifiant numérique du type d'événement */
LOGT_Gravite Gravite; /* Code gravité */
LOGT_RC RC; /* Code de retour servant au pilotage */
LOGT_Rooting Rooting; /* Type de routage par défaut */
NDT_Root * Next_Dim; /* Dimension suivante = pointeur sur un arbre */
} LOGT_GDRT_Evt;
#define EVENT_NB_DIM 4
/* Elément d'une table de routage quelconque (hormis la GDRT) */
typedef struct {
int Id; /* Identifiant numérique du type d'événement (sert à la recherche) */
LOGT_Rooting Rooting; /* Type de routage */
} LOGT_RTab_Evt;
/* Définition du nom des différentes ressources de la librairie */
/*
Heap dans lequel sera stockée la base de la librairie LIBLOG :
Ce heap ne contient que la structure LOGT_Base qui permet de référencer
les autres ressources système de la librairie.
Ce heap ne sera constitué que d'une unique segment très petit.
*/
#define LOGD_BASE_HEAP_NAME "BASE"
#define LOGD_BASE_HEAP_SEGMENT_SIZE 100
/*
Heap dans lequel sont stockées les caches :
Ces heaps contiennent à priori un grand nombre de valeurs.
On les crée donc avec des segments de données suffisamment grands.
*/
#define LOGD_KMOD_SEGMENT_SIZE 50000
#define LOGD_KMOD_NAME "KMOD"
#define LOGD_KFORMAT_SEGMENT_SIZE 1100000
#define LOGD_KFORMAT_NAME "KFORMAT"
#define LOGD_GDRT_SEGMENT_SIZE 400000
#define LOGD_GDRT_NAME "GDRT"
/*
En règle générale, les tables de routage suivantes resteront vides :
Leur heap sont donc créés avec des segments de données relativement petits.
*/
#define LOGD_EMPTY_RTAB_SEGMENT_SIZE 3000
#define LOGD_GMRT_NAME "GMRT"
#define LOGD_LDRT_NAME "LDRT"
#define LOGD_LMRT_NAME "LMRT"
/*
Heap dans lequel sera stockée les listes de tables de routage :
Ces liste ne contiendront pas à priori un grand nombre de valeurs.
Les heaps sous-jacents n'ont donc pas besoin besoin d'être très grands.
*/
#define LOGD_RTAB_LIST_SEGMENT_SIZE 100240
#define LOGD_CHANNEL_LIST_NAME "CHANNEL_REF"
#define LOGD_LDRT_LIST_NAME "LDRT_REF"
#define LOGD_LMRT_LIST_NAME "LMRT_REF"
#define LOGD_URT_LIST_NAME "URT_REF"
/* Elément d'une structure de compteurs d'événement */
typedef struct {
char * Name; /* Nom du type d'événement */
int Total; /* Nombre total d'envois */
} LOGT_Event_Cpt;
SMT_Heap * LOG_Base_Heap;
/* Compteur d'ouverture de la librairie */
unsigned int LOG_Open_Counter = 0;
/* Flux de sortie des messages d'erreur générés par la librairie */
FILE * LOG_stderr;
/* Entêtes des fonctions privées */
NDT_Status LOG_Base_RTabList_Manager (va_list args_ptr);
NDT_Status LOG_Base_ChannelList_Manager (va_list args_ptr);
NDT_Status LOG_GDRT_Manager (va_list);
NDT_Status LOG_GDRT_Dim_Manager (va_list);
LOGT_Status LOG_GDRT_Event_Find (LOGT_GDRT_Evt **, char **, char *);
LOGT_Status LOG_GDRT_Recursive_Find (char **, NDT_Root *, int, LOGT_GDRT_Evt **, char **);
LOGT_Status LOG_GDRT_Event_Create (const char *, int, LOGT_Gravite, LOGT_RC, LOGT_Rooting, int *);
LOGT_Status LOG_GDRT_Recursive_Select (int, NDT_Root *, LOGT_RTab *, LOGT_RuleClass, LOGT_Rule *, LOGT_Rooting, const char *, char *);
NDT_Status LOG_KMOD_Manager (va_list);
NDT_Status LOG_KFORMAT_Manager (va_list);
NDT_Status LOG_KFORMAT_DataList_Manager (va_list);
NDT_Status LOG_Channel_RTabList_Manager (va_list);
NDT_Status LOG_Channel_Event_CptList_Manager (va_list);
NDT_Status LOG_Channel_SubModuleList_Manager (va_list);
NDT_Status LOG_Channel_TriggerList_Manager (va_list);
LOGT_Status LOG_Channel_Rooting_Find (LOGT_Channel *, int, LOGT_Rooting *);
NDT_Status LOG_RTab_Manager (va_list);
#define DATA_ARG_LIST 1
#define DATA_STRING 2
LOGT_Status LOG_Event_Internal_Send (int, LOGT_Channel *, LOGT_RC *, char *, va_list, char *);
LOGT_Status LOG_Event_Data_Get (int, char *, char **, size_t *, va_list *, char *);
LOGT_Status LOG_Event_Data_Tag_Get (int, va_list *, char **, int *, char *);
LOGT_Status LOG_Event_Data_Macro_Get (int, va_list *, char **, char *, char *);
int LOG_NextString_Get (char ** ptr, char * result);
char * LOG_RTType_Label_Get (LOGT_RTType);
char * LOG_RC_Label_Get (LOGT_RC);
char * LOG_Rooting_Label_Get (LOGT_Rooting);
void LOG_Error_Print(void);
static char * LOG_Name_Prefix (const char *);

424
lib/libtool.3 Normal file
View File

@ -0,0 +1,424 @@
'\" t
.\" @(#)LIBTOOL.3 1.0 00/22/02 SMA;
.TH LIBTOOL 3 "22 Feb 2000"
.SH NOM
LIBTOOL (utilitaires pour la librairie LIBLOG)
.SH SYNOPSIS
.LP
.BI "cc [flag ...] file ... -lver -ldl -lnode -lshmem -ldatastr -ladm -llog -ltool [library ...]"
.LP
.BI "#include <tool.h>"
.LP
.BI "TLT_Status TL_Library_Stderr_Set ( FILE * " Out ");"
.LP
.BI "TLT_Status TL_LIBLOG_Load ( TL_Cache " To_Load " );"
.LP
.BI "TLT_Status TL_LIBLOG_Unload ( TL_Cache " To_Unload " );"
.LP
.BI "TLT_Status TL_Channel_RTab_Add ( LOGT_Channel * " Channel ", char * " Kunf_Name " );"
.LP
.BI "TLT_Status TL_Channel_Trigger_Add ( LOGT_Channel * " Channel ", char * " Kunf_Name " );"
.LP
.SH DESCRIPTION
.LP
La bibliotheque LIBTOOL fournit un ensemble d'utilitaires lies a la librairie LIBLOG :
.LP
.RS 3
- Creation de tables de routage et de triggers a partir de fichiers de configuration KUNF
.LP
- Mise a jour des caches de donnees de la librairie LIBLOG (cache des modules, cache des formats d'evenement, table de routage par defaut
.RS -3
.LP
.SH FONCTIONS
.LP
.BI "TLT_Status TL_Library_Stderr_Set ( FILE * " Out " );"
.LP
.RS 3
Cette fonction permet de definir
.I Out
comme la sortie standard des messages d'erreur de la librarie.
.RS -3
.LP
.BI "TLT_Status TL_LIBLOG_Load ( TL_Cache " To_Load " );"
.LP
.RS 3
Cette fonction permet de charger les caches de donnees de la base de la librairie LIBLOG
.LP
L'argument
.I To_Load
represente la liste des caches de donnees a charger
, sous forme d'une combinaison binaire des trois valeurs suivantes :
.LP
.RS 3
-
.B TLD_KMOD
: pour charger le cache de modules
.LP
-
.B TLD_KFORMAT
: pour charger le cache de formats d'evenement
.LP
-
.B TLD_GDRT
: pour charger la table de routage par defaut
.LP
.RS -3
NB : les caches doivent etre prealablement vides avant d'etre charges.
.LP
.RS -3
.BI "TLT_Status TL_LIBLOG_Unload ( TL_Cache " To_Unload " );"
.LP
.RS 3
Cette fonction permet de vider les caches de donnees de la base de la librairie LIBLOG
.LP
L'argument
.I To_Unload
represente la liste des caches de donnees a vider
, sous forme d'une combinaison binaire des trois valeurs suivantes :
.RS 3
.LP
-
.B TLD_KMOD
: pour vider le cache de modules
.LP
-
.B TLD_KFORMAT
: pour vider le cache de formats d'evenement
.LP
-
.B TLD_GDRT
: pour vider la table de routage par defaut
.RS -3
.LP
.RS -3
.BI "TLT_Status TL_Channel_RTab_Add ( LOGT_Channel * " Channel ", char * " Kunf_Name " );"
.LP
.RS 3
Cette fonction permet d'ajouter toutes les tables de routage d'une section KUNF a un channel.
.LP
Elle attend les parametres suivants :
.LP
.RS 3
* (In)
.I Channel
: un pointeur sur le channel
.LP
* (In)
.I Kunf_Name
: le nom de la section KUNF
.RS -3
.LP
.RS -3
.BI "TLT_Status TL_Channel_Trigger_Add ( LOGT_Channel * " Channel ", char * " Kunf_Name " );"
.LP
.RS 3
Cette fonction permet d'ajouter tous les triggers d'une section KUNF a un channel.
.LP
Elle attend les parametres suivants :
.RS 3
.LP
* (In)
.I Channel
: un pointeur sur le channel
.LP
* (In)
.I Kunf_Name
: le nom de la section KUNF
.RS -3
.LP
.SH FICHIER DE CONFIGURATION
.LP
Le fichier KUNF contient deux types de sections:
.RS 3
.LP
-
.B [ROOTING_TABLE]
: liste des tables de routage
.LP
-
.B [TRIGGER]
: liste des triggers
.RS -3
.LP
Chaque table de routage est identifiee par une sous-section de la forme
.B [ROOTING_TABLE:<table_name>]
.
.LP
Les regles de routage sont designees par une section de la forme
.B [ROOTING_TABLE:<table_name>:<rule_name>]
.
.LP
Une regle de routage definit les proprietes suivantes :
.RS 3
.LP
*
.B class
: ce tag definit la classe de la regle et peut prendre les valeurs suivantes :
.LP
.RS 3
-
.B ALL
pour selectionner tous les evenements
.LP
-
.B GRV
pour selectionner les evenements selon leur gravite
.LP
-
.B RC
pour selectionner les evenements selon leur code retour associe
.LP
-
.B TYPE
pour selectionner les evenements selon leur type
.RS -3
.LP
*
.B rule
: ce tag definit la regle elle-meme et peut prendre les valeurs suivantes :
.LP
.RS 3
- pour la classe
.B ALL
: aucune valeur a definir
.LP
- pour la classe
.B GRV
:
.B INFO
,
.B TRACE
,
.B FONCT
,
.B DETAIL
,
.B STAT
,
.B ERR
,
.B REJDON
,
.B REJENR
,
.B WARNING
,
.B RECYCLE
,
.B EXIT
,
.B ABEND
.LP
- pour la classe
.B RC
:
.B OK
,
.B ANOERR
,
.B REJDON
,
.B REJENR
,
.B WARNING
,
.B RECYCLE
,
.B EXIT
,
.B ABEND
.LP
- pour la classe
.B TYPE
: expression reguliere sur le type d'evenement
.LP
.I Attention
: le caractere ':' etant interdit dans les sections kunf, on le notera conventionnellement par "{2pts}".
.LP
Les expressions regulieres seront notees selon le standard UNIX (voir regexp).
.LP
.RS -3
*
.B rooting
: ce tag definit le routage associe a la regle et peut prendre les valeurs suivantes :
.LP
.RS 3
-
.B DATABASE
: routage de l'evenement vers la base de suivi
.LP
-
.B STDERR
: routage de l'evenement vers la sortie standard d'erreur
.LP
-
.B NULL
: routage de l'evenement vers /dev/null (i.e l'evenement n'est pas traite)
.LP
-
.B DEFAULT
: routage par defaut
.LP
-
.B PREVIOUS
: routage de la table precedente du channel
.RS -3
.LP
.RS -3
Chaque trigger est identifie par une section de la forme
.B [ROOTING_TABLE:<trigger_name>]
.
.LP
A un trigger sont associees plusieurs proprietes :
.RS 3
.LP
*
.B event
: ce tag designe le type d'evenement declencheur du trigger (expression reguliere)
.LP
*
.B type
: ce tag definit le type du trigger et peut prendre les valeurs suivantes :
.RS 3
.LP
-
.B ADD
pour un trigger qui ajoute une table de routage a un channel
.LP
-
.B REMOVE
pour un trigger qui supprime une table de routage d'un channel
.RS -3
.LP
*
.B mode
: ce tag designe la persistance du trigger et peut prendre les valeurs suivantes :
.RS 3
.LP
-
.B ONE_SHOT
pour un trigger qui ne fonctionne qu'une seule fois
.LP
-
.B PERMANENT
pour un trigger qui fonctionne tant qu'il n'est pas desactive
.RS -3
.LP
*
.B rooting_table
: ce tag definit le nom de la table de routage concernee par le trigger
.RS -3
.LP
.LP
.I Exemple
:
.LP
.RS 3
[ROOTING_TABLE]
.LP
[ROOTING_TABLE:TOTO]
.LP
[ROOTING_TABLE:TOTO:RULE1]
.LP
class=ALL
.LP
rooting=DATABASE
.LP
[ROOTING_TABLE:TOTO:RULE2]
.LP
class=RC
.LP
rule=REJENR
.LP
rooting=STDERR+DATABASE
.LP
[ROOTING_TABLE:TOTO:RULE3]
.LP
class=TYPE
.LP
rule=COMPTEUR.*
.LP
rooting=NULL
.LP
[ROOTING_TABLE:TITI]
.LP
[ROOTING_TABLE:TOTO:RULE1]
.LP
class=ALL
.LP
rooting=PREVIOUS
.LP
[ROOTING_TABLE:TOTO:RULE2]
.LP
class=GRV
.LP
rule=WARNING
.LP
rooting=DEFAULT
.LP
[ROOTING_TABLE:TOTO:RULE3]
.LP
class=RC
.LP
rule=ABEND
.LP
rooting=STDERR
.LP
[ROOTING_TABLE:TOTO:RULE4]
.LP
class=TYPE
.LP
rule=*SQLERR*
.LP
rooting=STDERR
.LP
[TRIGGER]
.LP
[TRIGGER:TATA]
.LP
event=COMPTEUR.*@.*{2pts}.*{2pts}TB.*
.LP
type=ADD
.LP
rooting_table=TOTO
.LP
mode=ONE_SHOT
.LP
.RS -3
Dans l'exemple ci-dessus, le fichier de configuration definit deux tables de routage nommees TOTO (3 regles) et TITI (4 regles) et un trigger nomme TATA.
.LP
.I NB
: les noms des regles de routage sont libres. Ils doivent seulement etre differents les uns des autres pour une meme table de routage.
.LP
Pour davantage de precisions sur la notion de table de routage ou de trigger, le lecteur se referera a la documentation de la librairie LIBLOG.
.LP
.RS -3
.SH CODES RETOUR
.LP
Toutes les fonctions constituant l'API de la librairie LIBTOOL retournent un code de type
.B TLT_Status
:
.LP
.RS 3
-
.B TLS_OK
si la fonction s'est correctement executee
.LP
-
.B TLS_KO
si une erreur s'est produite
.RS -3
.LP
En cas d'erreur, la variable
.B TL_Error_Msg
contient un message du type :
.LP
.RS 3
Error <Nom fonction> : <message d'erreur>
.RS -3
.LP
Dans une prochaine version, la librairie proposera des codes retour plus explicites, permettant de distinguer les differents types d'erreur.
.LP
.SH VOIR AUSSI
.B liblog
(3)

BIN
lib/libtool.doc Normal file
View File

Binary file not shown.

49
lib/libtool.h Normal file
View File

@ -0,0 +1,49 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ver.h>
#include <kunf.h>
#include <shmem.h>
#include <log.h>
#include <tool.h>
extern char * strdup (const char *);
FILE * TL_stderr = NULL;
char TL_Info_Msg[256];
/* Déclarations pour ORACLE */
void pipo(void);
void pipo(void)
{
unsigned int x;
x = sqlstm.sqlvsn;
}
#define sqlstm _sqlstm
extern void sqlglm(char *, size_t *, size_t *);
#define SQL_OK 0
#define SQL_NO_DATA_FOUND 1403
#define SQL_FETCHED_COLUMN_NULL -1405
char * oracx = NULL;
void TL_Info_Print (void);
void TL_Error_Print (void);
TLT_Status TL_RTab_Add (LOGT_Channel *, char *);
TLT_Status TL_Trigger_Add (LOGT_Channel *, char *);
TLT_Status TL_GDRT_Load(void);
TLT_Status TL_KMOD_Load(void);
TLT_Status TL_KFORMAT_Load(void);
TLT_Status TL_GDRT_Unload(void);
TLT_Status TL_KMOD_Unload(void);
TLT_Status TL_KFORMAT_Unload(void);
TLT_Status TL_Param_Get (void);
TLT_Status TL_Database_Connect (void);
char * Oracle_Message_Get (void);
char * trim (char *);

1369
lib/libtool.pc Normal file
View File

File diff suppressed because it is too large Load Diff

516
lib/log.h Normal file
View File

@ -0,0 +1,516 @@
#ifndef _LIBLOG
#define _LIBLOG
#ifdef __cplusplus
extern "C" {
#endif
#include <node.h>
#include <shmem.h>
#include <datastr.h>
#include <msg.h>
/*********** Anciennes librairies **************
#include <logevt.h>
#include <GetEvt.h>
************************************************/
/* Codes retour des fonctions de l'API */
typedef int LOGT_Status;
#define LOGS_OK DSS_OK /* La fonction s'est correctement exécutée et a produit un résultat */
#define LOGS_KO DSS_KO /* La fonction s'est correctement exécutée mais n'a pas produit de résultat */
#define LOGS_ERRMEM MSGS_ERRMEM /* Problème d'allocation mémoire */
#define LOGS_ERRAPI MSGS_ERRAPI /* Utilisation incorrecte des API */
#define LOGS_ERRSHM MSGS_ERRSHM /* Problème relatif aux segments de mémoire partagée */
#define LOGS_ERRSEM MSGS_ERRSEM /* Problème relatif à l'utilisation des sémaphores */
#define LOGS_ERRSIG MSGS_ERRSIG /* Opération sur sémpahore interrompue par un signal système */
#define LOGS_ERRDLL MSGS_ERRDLL /* Problème de chargement dynamique de librairie */
#define LOG_ERROR(s) (s < 0) /* Tous les codes retour négatifs correspondent à des erreurs */
/* Notion de routage (possibilité de les combiner par addition binaire) */
typedef int LOGT_Rooting;
#define LOGD_ROOTING_DATABASE 0x01 /* Routage vers la base de suivi */
#define LOGD_ROOTING_STDERR 0x02 /* Routage vers la sortie standard d'erreur */
#define LOGD_ROOTING_DEFAULT 0x04 /* Routage de la table de routage par défaut */
#define LOGD_ROOTING_PREVIOUS 0x08 /* Routage de la table de routage précédente */
#define LOGD_ROOTING_NULL 0x10 /* Routage vers /dev/null */
#define LOGD_ROOTING_DATABASE_MSK(a) (LOGD_ROOTING_DATABASE & a)
#define LOGD_ROOTING_STDERR_MSK(a) (LOGD_ROOTING_STDERR & a)
/* Notion de gravité (classe d'événement) */
typedef int LOGT_Gravite;
#define LOGD_GRV_INFO 'I'
#define LOGD_GRV_TRACE 'T'
#define LOGD_GRV_FONCT 'F'
#define LOGD_GRV_DETAIL 'L'
#define LOGD_GRV_STAT 'S'
#define LOGD_GRV_ERR 'E'
#define LOGD_GRV_REJDON 'D'
#define LOGD_GRV_REJENR 'R'
#define LOGD_GRV_WARNING 'W'
#define LOGD_GRV_RECYCLE 'Y'
#define LOGD_GRV_EXIT 'X'
#define LOGD_GRV_ABEND 'A'
/* Notion de code retour (pour le pilotage) */
typedef int LOGT_RC;
#define LOGD_RC_OK 0 /* Continuation */
#define LOGD_RC_ANOERR 4 /* Anomalie */
#define LOGD_RC_REJDON 6 /* Rejet de la donnée */
#define LOGD_RC_REJENR 7 /* Rejet de l'enregistrement */
#define LOGD_RC_WARNING 8 /* Evénement inconnu */
#define LOGD_RC_RECYCLE 10 /* Recyclage de l'enregistrement */
#define LOGD_RC_EXIT 14 /* Sortie du traitement */
#define LOGD_RC_ABEND 16 /* Interruption du traitement */
#define LOGD_RC_SIZE 17 /* Taille des tableaux de codes retour (voir fonction LOG_Event_Cpt_Get) */
/* Type de table de routage */
typedef int LOGT_RTType;
#define LOGD_GMRT 0 /* Global Master Rooting Table */
#define LOGD_LMRT 1 /* Local Master Rooting Table */
#define LOGD_URT 2 /* User Rooting Table */
#define LOGD_LDRT 3 /* Local Default Rooting Table */
#define LOGD_GDRT 4 /* Global Default Rooting Table */
/* Notion de table de routage */
typedef struct {
char * Name; /* Nom de la table de routage */
LOGT_RTType Type; /* Type de la table de routage */
NDT_Root * Root; /* Pointeur sur la structure contenant les événements */
int Nb_Channel; /* Nombre de canaux auquels est rattachée la table */
pid_t Pid; /* Processus propriétaire de la table de routage (utile au garbage collector) */
} LOGT_RTab;
#define LOGD_RTAB_DEFAULT 0 /* Référence à la table de routage par défaut */
#define LOGD_RTAB_PREVIOUS 1 /* Référence à la table de routage précédente */
/* Notion de classe de règle de sélection des événements */
typedef int LOGT_RuleClass;
#define LOGD_SELECT_ALL 1 /* Règle appliquée à tous les événements */
#define LOGD_SELECT_GRV 2 /* Règle appliquée aux événements d'une certaine gravité */
#define LOGD_SELECT_RC 3 /* Règle appliquée aux événements associés à un certain code retour */
#define LOGD_SELECT_TYPE 4 /* Règle appliquée aux événements d'un certain type */
/* Notion de règle de sélection des événements */
typedef void LOGT_Rule; /* Contient le code gravité, code retour ou type d'événement selon la classe de la règle */
/* Différents indicateurs */
typedef int LOGT_Flags;
/* Modes d'ouverture et de fermeture */
#define LOGD_CREATE SMD_CREATE /* Création */
#define LOGD_OPEN SMD_OPEN /* Ouverture simple */
#define LOGD_DESTROY SMD_DESTROY /* Destruction */
#define LOGD_CLOSE SMD_CLOSE /* Fermeture simple */
/* Flags de debug sur l'ouverture de la librairie */
#define LOGD_DEBUG_NONE SMD_DEBUG_NONE /* pour n'afficher aucun message généré par les diverses librairies */
#define LOGD_DEBUG SMD_DEBUG /* pour afficher les messages générés par la librairie */
#define LOGD_DEBUG_ALL SMD_DEBUG_ALL /* pour afficher les messages générés par toutes les librairies sous-jacentes */
#define LOGD_DEBUG_MSK (MSGD_DEBUG & MSGD_DEBUG_ALL)
/* Mode de fonctionnement d'un trigger */
#define LOGD_ADD 0x01 /* Trigger d'ajout de table de routage */
#define LOGD_REMOVE 0x02 /* Trigger de suppression de table de routage */
#define LOGD_ONE_SHOT 0x04 /* Trigger actif une seul fois */
#define LOGD_PERMANENT 0x08 /* Trigger actif en permanence */
#define LOGD_ADD_MSK(a) (LOGD_ADD & a)
#define LOGD_REMOVE_MSK(a) (LOGD_REMOVE & a)
#define LOGD_ONE_SHOT_MSK(a) (LOGD_ONE_SHOT & a)
#define LOGD_PERMANENT_MSK(a) (LOGD_PERMANENT & a)
/* Notion de channel */
typedef struct {
pid_t Pid; /* Processus propriétaire du channel */
int Id; /* Identifiant du channel */
int ModuleId; /* Identifiant du module envoyeur */
int Master_ModuleId; /* Identifiant du module primaire */
NDT_Root * RTab_List; /* Liste de tables de routage */
NDT_Root * SubModule_List; /* Liste des sous-modules */
NDT_Root * Trigger_List; /* Liste des triggers posés sur le channel */
NDT_Root * Event_Cpt_List; /* Liste de compteurs d'événements */
} LOGT_Channel;
/* Notion de trigger (ajout ou suppression dynamique de tables de routage) */
typedef struct LOGT_Trigger
{
char * Event_Name; /* Evénement déclencheur du trigger */
LOGT_RTab * RTab; /* Table de routage utilisateur concernée */
LOGT_Flags Mode; /* Mode de fonctionnement du trigger */
LOGT_Channel * Channel; /* Channel auquel est rattaché le trigger */
} LOGT_Trigger;
/* Base système de la librairie LIBLOG */
typedef struct {
NDT_Root * KMOD; /* Cache des modules */
NDT_Root * KFORMAT; /* Cache des formats d'événement */
LOGT_RTab * GDRT; /* Table GDRT */
LOGT_RTab * GMRT; /* Table GMRT */
NDT_Root * LMRT_List; /* Liste des LMRT */
NDT_Root * LDRT_List; /* Liste des LDRT */
NDT_Root * URT_List; /* Liste des URT */
NDT_Root * Channel_List; /* Liste des channels */
} LOGT_Base;
LOGT_Base * LOG_Base = NULL;
/* Informations sur un type d'événement */
typedef struct {
unsigned int Event_Type; /* Identifiant du type d'événement */
char * Event_Name; /* Nom du type d'événément */
LOGT_Rooting Rooting; /* Routage associé */
LOGT_Gravite Gravite; /* Code gravité associé */
LOGT_RC RC; /* Code retour associé */
NDT_Root * Data_List; /* Liste des données du format de l'événement */
} LOGT_Info;
/* Format d'un type d'événement */
typedef struct {
unsigned int Event_Type; /* Type d'événement */
NDT_Root * Data_List; /* Liste des données du format */
} LOGT_Event_Format;
/* Message explicite des erreurs générées par la librairie LINLOG */
char LOG_Error_Msg [256];
/* Identifiant du port de messages pour l'envoi des événements */
#define LOGD_EVENT_PORT_NAME "EVENT_PORT"
/* Type des messages qui contiennent les événements */
#define LOGD_EVENT_MSG_TYPE 100
/*
Formatage des événements par les clients de la LIBLOG :
EVEN1[.EVEN2[.EVEN3]]@[MODULE1[.MODULE2[.MODULE3]]]:[MODE1[.MODE2[.MODE3]]]:[GEO1[.GEO2[.GEO3]]]
*/
#define EVEN1 0x00000101
#define EVEN2 0x00000102
#define EVEN3 0x00000103
#define MODULE1 0x00000201
#define MODULE2 0x00000202
#define MODULE3 0x00000203
#define MODE1 0x00000301
#define MODE2 0x00000302
#define MODE3 0x00000303
#define GEO1 0x00000401
#define GEO2 0x00000402
#define GEO3 0x00000403
#define DEFAULT -1L
#define CHAR 0L
#define STRING 1L
#define SHORT 2L
#define INT 3L
#define LONG 4L
#define FLOAT 5L
#define DOUBLE 6L
#define END_NAME -1
#define END_DATA "END_DATA"
/* Format d'un message contenant un événement */
#define EVENT_FORMAT_VERSION_SIZE 10 /* sur 10 caractères max */
#define EVENT_FORMAT_VERSION "V1.0"
/* Zone de données du message :
- Version de format de message : 10 octets |
- Numéro de processus envoyeur : 4 octets | Entête
- Identifiant du module envoyeur : 4 octets |
- Identifiant du module primaire : 4 octets |
- Identifiant du type d'événement : 4 octets
- Taille du nom de l'événement : 1 octet |
- Nom de l'événement |
- Taille du code support : 1 octet |
- Code support |
- Taille du nom de la macro-donnée : 1 octet | Evénement |
- Nom de la macro-donnée | |
- Taille de la valeur de la macro-donnée : 1 octet | | N fois
- Valeur de la macro-donnée | |
*/
typedef struct {
char Version [EVENT_FORMAT_VERSION_SIZE];
unsigned int Sending_Pid;
unsigned int ModuleId;
unsigned int Master_ModuleId;
} LOGT_Event_Msg_Header;
typedef struct {
LOGT_Event_Msg_Header Header;
unsigned int Event_Type;
size_t Data_Size;
char Event_Data;
} LOGT_Event_Msg_Data;
/* Définition des alias de l'API */
#ifndef LOG_MODE
#define LOG_MODE 0
#endif
#if LOG_MODE == 1
/* API sans vérification des arguments */
# define LOG_Library_Open LOG_Library_Open_I
# define LOG_Library_Close LOG_Library_Close_I
# define LOG_Library_Stderr_Set LOG_Library_Stderr_Set_I
# define LOG_Channel_Open LOG_Channel_Open_I
# define LOG_Channel_Enter LOG_Channel_Enter_I
# define LOG_Channel_Leave LOG_Channel_Leave_I
# define LOG_Channel_Close LOG_Channel_Close_I
# define LOG_RTab_Alloc LOG_RTab_Alloc_I
# define LOG_RTab_Setup LOG_RTab_Setup_I
# define LOG_RTab_Add LOG_RTab_Add_I
# define LOG_RTab_Remove LOG_RTab_Remove_I
# define LOG_RTab_Free LOG_RTab_Free_I
# define LOG_Trigger_Add LOG_Trigger_Add_I
# define LOG_Trigger_Remove LOG_Trigger_Remove_I
# define LOG_Event_Send LOG_Event_Send_I
# define LOG_Event_External_Send LOG_Event_External_Send_I
# define LOG_Event_Info_Get LOG_Event_Info_Get_I
# define LOG_Event_Cpt_Get LOG_Event_Cpt_Get_I
#else
/* API avec vérification des arguments */
# define LOG_Library_Open LOG_Library_Open_C
# define LOG_Library_Close LOG_Library_Close_C
# define LOG_Library_Stderr_Set LOG_Library_Stderr_Set_C
# define LOG_Channel_Open LOG_Channel_Open_C
# define LOG_Channel_Enter LOG_Channel_Enter_C
# define LOG_Channel_Leave LOG_Channel_Leave_C
# define LOG_Channel_Close LOG_Channel_Close_C
# define LOG_RTab_Alloc LOG_RTab_Alloc_C
# define LOG_RTab_Setup LOG_RTab_Setup_C
# define LOG_RTab_Add LOG_RTab_Add_C
# define LOG_RTab_Remove LOG_RTab_Remove_C
# define LOG_RTab_Free LOG_RTab_Free_C
# define LOG_Trigger_Add LOG_Trigger_Add_C
# define LOG_Trigger_Remove LOG_Trigger_Remove_C
# define LOG_Event_Send LOG_Event_Send_C
# define LOG_Event_External_Send LOG_Event_External_Send_C
# define LOG_Event_Info_Get LOG_Event_Info_Get_C
# define LOG_Event_Cpt_Get LOG_Event_Cpt_Get_C
#endif
/*------------------------------------------------------------------------------*/
/* Ouverture de la librairie */
/*------------------------------------------------------------------------------*/
/* (I) Instance : numéro de l'instance à ouvrir */
/* (I) Context : contexte d'utilisation de la librairie */
/* (I) Open_Mode : mode d'ouverture de la librairie */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Library_Open_I ( int Instance, const char * Context, LOGT_Flags Open_Mode );
LOGT_Status LOG_Library_Open_C ( int Instance, const char * Context, LOGT_Flags Open_Mode );
/*------------------------------------------------------------------------------*/
/* Fermeture de l'instance de la librairie */
/*------------------------------------------------------------------------------*/
/* (I) Close_Mode : mode de fermeture de la librairie */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Library_Close_I ( LOGT_Flags Close_Mode );
LOGT_Status LOG_Library_Close_C ( LOGT_Flags Close_Mode );
/*------------------------------------------------------------------------------*/
/* Définition de la sortie standard des messages d'erreur de la librairie */
/*------------------------------------------------------------------------------*/
/* (I) Out : flux de sortie des messages d'erreur */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Library_Stderr_Set_I ( FILE * Out );
LOGT_Status LOG_Library_Stderr_Set_C ( FILE * Out );
/*------------------------------------------------------------------------------*/
/* Création d'un canal de communication */
/*------------------------------------------------------------------------------*/
/* (O) Channel : adresse du pointeur sur le canal créé */
/* (I) Pid : numéro du processus propriétaire du canal */
/* (I) Channel_Id : identifiant du canal au sein du processus */
/* (I) Module_Name : nom du module propriétaire du canal */
/* (I) Master_Module_Name : nom du module primaire */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Channel_Open_I (LOGT_Channel ** Channel, int Pid, int Channel_Id, const char * Module_Name, const char * Master_Module_Name);
LOGT_Status LOG_Channel_Open_C (LOGT_Channel ** Channel, int Pid, int Channel_Id, const char * Module_Name, const char * Master_Module_Name);
/*------------------------------------------------------------------------------*/
/* Entrée dans un sous-module pour un canal de communication */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur le canal */
/* (I) SubModule_Name : nom du sous-module */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Channel_Enter_I ( LOGT_Channel * Channel, const char * SubModule_Name );
LOGT_Status LOG_Channel_Enter_C ( LOGT_Channel * Channel, const char * SubModule_Name );
/*------------------------------------------------------------------------------*/
/* Sortie d'un sous-module pour un canal de communication */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur le canal */
/* (I) SubModule_Name : nom du sous-module */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Channel_Leave_I ( LOGT_Channel * Channel, const char * SubModule_Name );
LOGT_Status LOG_Channel_Leave_C ( LOGT_Channel * Channel, const char * SubModule_Name );
/*------------------------------------------------------------------------------*/
/* Fermeture d'un canal de communication */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur le canal à fermer */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Channel_Close_I ( LOGT_Channel * Channel);
LOGT_Status LOG_Channel_Close_C ( LOGT_Channel * Channel);
/*------------------------------------------------------------------------------*/
/* Création d'une table de routage utilisateur */
/*------------------------------------------------------------------------------*/
/* (O) RTab : adresse du pointeur sur la table de routage */
/* (I) Name : nom de la table de routage */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_RTab_Alloc_I ( LOGT_RTab ** RTab, char * Name );
LOGT_Status LOG_RTab_Alloc_C ( LOGT_RTab ** RTab, char * Name );
/*------------------------------------------------------------------------------*/
/* Ajout d'une règle à une table de routage */
/*------------------------------------------------------------------------------*/
/* (I) RTab : pointeur sur la table de routage */
/* (I) RuleClass : classe de la nouvelle règle */
/* (I) Rule : pointeur sur la nouvelle règle */
/* (I) Value : valeur de la nouvelle règle */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_RTab_Setup_I ( LOGT_RTab * RTab, LOGT_RuleClass RuleClass, LOGT_Rule * Rule, LOGT_Rooting Value );
LOGT_Status LOG_RTab_Setup_C ( LOGT_RTab * RTab, LOGT_RuleClass RuleClass, LOGT_Rule * Rule, LOGT_Rooting Value );
/*------------------------------------------------------------------------------*/
/* Ajout d'une table de routage à un canal de communication */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur le canal de communication */
/* (I) RTab : pointeur sur la table de routage */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_RTab_Add_I ( LOGT_Channel * Channel, LOGT_RTab * RTab );
LOGT_Status LOG_RTab_Add_C ( LOGT_Channel * Channel, LOGT_RTab * RTab );
/*------------------------------------------------------------------------------*/
/* Suppression d'une table de routage d'un canal de communication */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur le canal de communication */
/* (I) RTab : pointeur sur la table de routage */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_RTab_Remove_I ( LOGT_Channel * Channel, LOGT_RTab * RTab );
LOGT_Status LOG_RTab_Remove_C ( LOGT_Channel * Channel, LOGT_RTab * RTab );
/*------------------------------------------------------------------------------*/
/* Destruction d'une table de routage */
/*------------------------------------------------------------------------------*/
/* (I) RTab : pointeur sur la table de routage */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_RTab_Free_I ( LOGT_RTab * RTab );
LOGT_Status LOG_RTab_Free_C ( LOGT_RTab * RTab );
/*------------------------------------------------------------------------------*/
/* Ajout d'un trigger */
/*------------------------------------------------------------------------------*/
/* (O) Trigger : adresse du pointeur sur le trigger mis en place */
/* (I) Channel : pointeur sur le canal de communication */
/* (I) RTab : pointeur sur la table de routage à appliquer */
/* (I) Type_Evt : type d'événement déclencheur ( expression régulière ) */
/* (I) Mode : mode de fonctionnement du trigger */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Trigger_Add_I ( LOGT_Trigger ** Trigger, LOGT_Channel * Channel, LOGT_RTab * RTab, char * Type_Evt, LOGT_Flags Mode );
LOGT_Status LOG_Trigger_Add_C ( LOGT_Trigger ** Trigger, LOGT_Channel * Channel, LOGT_RTab * RTab, char * Type_Evt, LOGT_Flags Mode );
/*------------------------------------------------------------------------------*/
/* Suppression d'un trigger */
/*------------------------------------------------------------------------------*/
/* (I) Trigger : pointeur sur le trigger mis en place */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Trigger_Remove_I ( LOGT_Trigger * Trigger );
LOGT_Status LOG_Trigger_Remove_C ( LOGT_Trigger * Trigger );
/*------------------------------------------------------------------------------*/
/* Envoi d'un événement */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur un canal de communication */
/* (O) RC : pointeur sur le code retour associé à l'événement */
/* (I) Cd_Support : code du support source */
/* (I) Data : données de l'événement */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Event_Send_I ( LOGT_Channel * Channel, LOGT_RC * RC, char * Cd_Support, va_list Data );
LOGT_Status LOG_Event_Send_C ( LOGT_Channel * Channel, LOGT_RC * RC, char * Cd_Support, va_list Data );
/*------------------------------------------------------------------------------*/
/* Envoi d'un événement ( PL/SQL ou shell ) */
/*------------------------------------------------------------------------------*/
/* (I) Channel : identifiant du channel */
/* (I) Cd_Support : code du support source */
/* (I) Data : données de l'événement */
/*------------------------------------------------------------------------------*/
/* (O) Retourne le code retour associé au type d'événement */
/*------------------------------------------------------------------------------*/
LOGT_RC LOG_Event_External_Send_I ( LOGT_Channel * Channel, char * Cd_Support, char * Data );
LOGT_RC LOG_Event_External_Send_C ( LOGT_Channel * Channel, char * Cd_Support, char * Data );
/*------------------------------------------------------------------------------*/
/* Retourne les informations du type par lequel un événement est résolu */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur un canal de communication */
/* (O) Info : pointeur sur les informations à récupérer */
/* (I) Event_Name : nom de l'événement */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Event_Info_Get_I ( LOGT_Channel * Channel, LOGT_Info ** Info, char * Event_Name );
LOGT_Status LOG_Event_Info_Get_C ( LOGT_Channel * Channel, LOGT_Info ** Info, char * Event_Name );
/*------------------------------------------------------------------------------*/
/* Retourne le nombre d'événements envoyés par code retour */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur un canal de communication */
/* (O) Cpt : pointeur sur un tableau de compteurs d'événement */
/* (I) RegExpr : expression régulière sur le nom d'événement */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Event_Cpt_Get_I ( LOGT_Channel * Channel, int * Cpt [LOGD_RC_SIZE], char * RegExpr );
LOGT_Status LOG_Event_Cpt_Get_C ( LOGT_Channel * Channel, int * Cpt [LOGD_RC_SIZE], char * RegExpr );
#ifdef __cplusplus
}
#endif
#endif

68
lib/tool.h Normal file
View File

@ -0,0 +1,68 @@
#ifndef _LIBTOOL
#define _LIBTOOL
#ifdef __cplusplus
extern "C" {
#endif
#include <log.h>
/* Codes retour des fonctions de l'API */
typedef int TLT_Status;
#define TLS_OK LOGS_OK
#define TLS_KO LOGS_KO
typedef int TLT_Cache;
#define TLD_KMOD 0001
#define TLD_KFORMAT 0010
#define TLD_GDRT 0100
char TL_Error_Msg[256];
/*------------------------------------------------------------------------------*/
/* Définition de la sortie standard des messages d'erreur de la librairie */
/*------------------------------------------------------------------------------*/
/* (I) Out : flux de sortie des messages d'erreur */
/*------------------------------------------------------------------------------*/
TLT_Status TL_Library_Stderr_Set ( FILE * Out );
/*------------------------------------------------------------------------------*/
/* Chargement des caches de la librairie LIBLOG */
/*------------------------------------------------------------------------------*/
/* (I) ToLoad : liste des caches de données à charger */
/* (combinaison de TLD_KMOD, TLD_KFORMAT et TLD_GDRT) */
/*------------------------------------------------------------------------------*/
TLT_Status TL_LIBLOG_Load (TLT_Cache ToLoad);
/*------------------------------------------------------------------------------*/
/* Déchargement des caches de la librairie LIBLOG */
/*------------------------------------------------------------------------------*/
/* (I) ToUnload : liste des caches de données à décharger */
/* (combinaison de TLD_KMOD, TLD_KFORMAT et TLD_GDRT) */
/*------------------------------------------------------------------------------*/
TLT_Status TL_LIBLOG_Unload (TLT_Cache ToUnload);
/*------------------------------------------------------------------------------*/
/* Affectation de toutes les tables de routage d'une section KUNF à un channel */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur le channel */
/* (I) Kunf_Nm : nom de la section KUNF */
/*------------------------------------------------------------------------------*/
TLT_Status TL_Channel_RTab_Add (LOGT_Channel * My_Channel, const char * Kunf_Nm);
/*------------------------------------------------------------------------------*/
/* Affectation de tous les triggers d'une section KUNF à un channel */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur le channel */
/* (I) Kunf_Nm : nom de la section KUNF */
/*------------------------------------------------------------------------------*/
TLT_Status TL_Channel_Trigger_Add (LOGT_Channel * My_Channel, const char * Kunf_Nm);
#ifdef __cplusplus
}
#endif
#endif

426
util/logadmin.c Normal file
View File

@ -0,0 +1,426 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <sys/time.h>
#include <log.h>
#include <tool.h>
VER_INFO_EXPORT (logadmin, "$Revision: 1.1 $", "$Name: $", __FILE__, "$Author: smas $")
#define USAGE "Usage : %s [ --help | --version [-v] | --create | --destroy | --load [1|2|3] ] | --unload [1|2|3] ]\n"
typedef struct {
double sec;
struct timeval start;
struct timeval stop;
} cpt;
#define t_start(x){gettimeofday(&(x.start), NULL);}
#define t_stop(x){gettimeofday(&(x.stop), NULL); x.sec = (double)(x.stop.tv_sec) - (double)(x.start.tv_sec) + ((double)(x.stop.tv_usec) - (double)(x.start.tv_usec)) / 1000000;}
cpt t_exec;
#define QUIT 0
#define BASE_INIT 1
#define BASE_OPEN 2
#define BASE_INFO 3
#define BASE_CLOSE 4
#define BASE_END 5
#define BASE_LOAD 6
#define BASE_UNLOAD 7
#define SHOW_CHANNEL_LIST 8
#define SHOW_RTAB_LIST 9
#define CHANNEL_DUMP 10
#define RTAB_DUMP 11
#define TEST_EVENT 12
char menu [1000];
char tmp [100];
void init_menu (void);
int print_menu (void);
char * Get_Rooting (LOGT_Rooting);
char * Get_RC (LOGT_RC);
int main (int argc, char ** argv)
{
int choice, i;
char Name [100];
LOGT_Channel * My_Channel;
char Answer[10];
NDT_Node * Node;
NDT_Root * Root;
LOGT_RTab RTab;
int Mode;
LOGT_Info * Info;
TL_Library_Stderr_Set (stderr);
/* Lancement de commande d'administration ? */
if (argc >= 2)
{
if (!strcmp (argv [1], "--help"))
{
fprintf (stderr, USAGE, argv [0]);
return -1;
}
else if (!strcmp (argv [1], "--version"))
{
if (argc >= 3 && !strcmp (argv [2], "-v"))
return VER_Object_Print (stdout, VERD_VERBOSE);
else
return VER_Object_Print (stdout, VERD_MINIMAL);
}
else if (!strcmp (argv [1], "--create"))
{
if (SM_Library_Open (0, NULL, SMD_OPEN | SMD_DEBUG_ALL) != SMS_OK)
{
fprintf (stderr, "=> Impossible d'ouvrir l'instance de la LIBSHMEM\n");
return -1;
}
if (LOG_Library_Open (0, NULL, LOGD_CREATE | SMD_DEBUG_ALL) != LOGS_OK)
{
fprintf (stderr, "=> Création de la LIBLOG impossible\n");
return -1;
}
return 0;
}
else if (!strcmp (argv [1], "--load"))
{
Mode = 0;
if (argc > 2)
{
if (strchr (argv [2], '1')) Mode += TLD_KMOD;
if (strchr (argv [2], '2')) Mode += TLD_KFORMAT;
if (strchr (argv [2], '3')) Mode += TLD_GDRT;
}
if (LOG_Library_Open (0, NULL, LOGD_OPEN | SMD_DEBUG_ALL) != LOGS_OK)
{
fprintf (stderr, "=> Ouverture de la LIBLOG impossible\n");
return -1;
}
if (TL_LIBLOG_Load (Mode) != LOGS_OK)
{
fprintf (stderr, "=> Chargement de la LIBLOG impossible\n");
return -1;
}
return 0;
}
else if (!strcmp (argv [1], "--unload"))
{
Mode = 0;
if (argc > 2)
{
if (strchr (argv [2], '1')) Mode += TLD_KMOD;
if (strchr (argv [2], '2')) Mode += TLD_KFORMAT;
if (strchr (argv [2], '3')) Mode += TLD_GDRT;
}
if (LOG_Library_Open (0, NULL, LOGD_OPEN | SMD_DEBUG_ALL) != LOGS_OK)
{
fprintf (stderr, "=> Ouverture de la LIBLOG impossible\n");
return -1;
}
if (TL_LIBLOG_Unload (Mode) != LOGS_OK)
{
fprintf (stderr, "=> Déchargement de la LIBLOG impossible\n");
return -1;
}
return 0;
}
else if (!strcmp (argv [1], "--destroy"))
{
if (LOG_Library_Open (0, NULL, LOGD_OPEN | SMD_DEBUG_ALL) != LOGS_OK)
{
fprintf (stderr, "=> Ouverture de la LIBLOG à détruire impossible\n");
return -1;
}
if (LOG_Library_Close (LOGD_DESTROY) != LOGS_OK)
{
fprintf (stderr, "=> Destruction de la LIBLOG impossible\n");
return -1;
}
return 0;
}
else
{
fprintf (stderr, USAGE, argv [0]);
return -1;
}
}
/* Lancement du menu intercatif */
init_menu ();
choice = print_menu ();
while (choice != QUIT)
{
strcpy (Answer, "yes");
switch (choice)
{
case BASE_INIT:
fprintf (stdout, "\nReturn code = %s\n", \
LOG_Library_Open (0, NULL, LOGD_CREATE | SMD_DEBUG_ALL) == LOGS_OK ? "OK" : "NOK" );
break;
case BASE_OPEN:
fprintf (stdout, "\nReturn code = %s\n", \
LOG_Library_Open (0, NULL, LOGD_OPEN | SMD_DEBUG_ALL) == LOGS_OK ? "OK" : "NOK" );
break;
case BASE_END:
fprintf (stdout, "\nReturn code = %s\n", \
LOG_Library_Close (LOGD_DESTROY) == LOGS_OK ? "OK" : "NOK" );
break;
case BASE_CLOSE:
fprintf (stdout, "\nReturn code = %s\n", \
LOG_Library_Close (LOGD_CLOSE) == LOGS_OK ? "OK" : "NOK" );
break;
case BASE_INFO:
DS_DataStruct_Info_Print (LOG_Base->KMOD, stdout);
DS_DataStruct_Info_Print (LOG_Base->KFORMAT, stdout);
DS_DataStruct_Info_Print (LOG_Base->GDRT->Root, stdout);
DS_DataStruct_Info_Print (LOG_Base->LMRT_List, stdout);
DS_DataStruct_Info_Print (LOG_Base->LDRT_List, stdout);
DS_DataStruct_Info_Print (LOG_Base->URT_List, stdout);
DS_DataStruct_Info_Print (LOG_Base->Channel_List, stdout);
break;
case BASE_LOAD:
fprintf (stdout, "\nCache to load ? (KMOD=1, KFORMAT=2, GDRT=3) ");
gets (Name);
Mode = 0;
if (strchr (Name, '1')) Mode |= TLD_KMOD;
if (strchr (Name, '2')) Mode += TLD_KFORMAT;
if (strchr (Name, '3')) Mode += TLD_GDRT;
fprintf (stdout, "\nReturn code = %s\n", TL_LIBLOG_Load (Mode) == LOGS_OK ? "OK" : "NOK" );
break;
case BASE_UNLOAD:
fprintf (stdout, "\nCache to unload ? (KMOD=1, KFORMAT=2, GDRT=3) ");
gets (Name);
Mode = 0;
if (strchr (Name, '1')) Mode += TLD_KMOD;
if (strchr (Name, '2')) Mode += TLD_KFORMAT;
if (strchr (Name, '3')) Mode += TLD_GDRT;
fprintf (stdout, "\nReturn code = %s\n", TL_LIBLOG_Unload (Mode) == LOGS_OK ? "OK" : "NOK" );
break;
case SHOW_RTAB_LIST:
DS_DataStruct_Print (LOG_Base->LMRT_List, stdout);
DS_DataStruct_Print (LOG_Base->LDRT_List, stdout);
DS_DataStruct_Print (LOG_Base->URT_List, stdout);
break;
case SHOW_CHANNEL_LIST:
DS_DataStruct_Print (LOG_Base->Channel_List, stdout);
break;
case CHANNEL_DUMP:
fprintf (stdout, "\nChannel address ? ");
gets (Name);
i = atoi (Name);
if (DS_Node_Find (LOG_Base->Channel_List, &Node, (void *)i, NULL) != DSS_OK)
fprintf (stdout, "Unable to find channel at address %d\n", i);
else
{
My_Channel = (LOGT_Channel *)(Node->Value);
ND_Manager_Exec (LOG_Base->Channel_List->Manager, NDD_CMD_PRINT_VALUE, &My_Channel, stdout);
if (fprintf (stdout, "\n\nShow rooting tables ? (y/n) ") && gets (tmp) && *tmp == 'y')
DS_DataStruct_Print (My_Channel->RTab_List, stdout);
if (fprintf (stdout, "\nShow submodules ? (y/n) ") && gets (tmp) && *tmp == 'y')
DS_DataStruct_Print (My_Channel->SubModule_List, stdout);
if (fprintf (stdout, "\nShow triggers ? (y/n) ") && gets (tmp) && *tmp == 'y')
DS_DataStruct_Print (My_Channel->Trigger_List, stdout);
if (fprintf (stdout, "\nShow event counters ? (y/n) ") && gets (tmp) && *tmp == 'y')
DS_DataStruct_Print (My_Channel->Event_Cpt_List, stdout);
}
break;
case RTAB_DUMP:
fprintf (stdout, "\nTable Name ? ");
gets (Name);
RTab.Name = Name;
if ((DS_Node_Find (LOG_Base->LMRT_List, &Node, &RTab, NULL) == DSS_OK && (Root = LOG_Base->LMRT_List)) ||
(DS_Node_Find (LOG_Base->LDRT_List, &Node, &RTab, NULL) == DSS_OK && (Root = LOG_Base->LDRT_List)) ||
(DS_Node_Find (LOG_Base->URT_List, &Node, &RTab, NULL) == DSS_OK && (Root = LOG_Base->URT_List)))
{
ND_Manager_Exec (Root->Manager, NDD_CMD_PRINT_VALUE, (void **)&(Node->Value), stdout);
if (fprintf (stdout, "\n\nShow events ? (y/n) ") && gets (tmp) && *tmp == 'y')
DS_DataStruct_Print (((LOGT_RTab *)(Node->Value))->Root, stdout);
}
else
fprintf (stdout, "\nUnable to find rooting table \"%s\"\n", Name);
break;
case TEST_EVENT:
fprintf (stdout, "\nEvent name ? ");
gets (Name);
Info = (LOGT_Info *)malloc(sizeof(LOGT_Info));
t_start (t_exec);
if (LOG_Event_Info_Get(NULL, &Info, Name) != LOGS_OK)
{
fprintf (stdout, "\nEvénement \"%s\" non résolu\n", Name);
t_stop (t_exec);
}
else
{
t_stop (t_exec);
fprintf (stdout, "\nEvénement \"%s\" résolu en %.4f sec :\n", Name, t_exec.sec);
fprintf (stdout, "\t- Type : %s (%d)\n", Info->Event_Name, Info->Event_Type);
fprintf (stdout, "\t- Routage : %s\n", Get_Rooting(Info->Rooting));
fprintf (stdout, "\t- Gravité : %c\n", (char)Info->Gravite);
fprintf (stdout, "\t- Code retour : %s\n", Get_RC(Info->RC));
fprintf (stdout, "\t- Format :");
if (Info->Data_List)
{
ND_Node_First_Get(Info->Data_List, &Node);
i = 0;
while (Node)
{
if (i > 0) fprintf (stdout, ",");
fprintf (stdout, " %s", (char *)(Node->Value));
ND_Node_Next_Get (Node, &Node);
i++;
}
}
fprintf (stdout, "\n\n");
}
free(Info);
break;
case QUIT:
fprintf (stdout, "\nExiting program ...\n");
break;
default:
fprintf (stdout, "\nUndefined choice %d\n", choice);
}
choice = print_menu ();
}
return 0;
}
void init_menu (void)
{
sprintf (menu, "Menu :\n");
sprintf (tmp, " - %2d) %-25s", QUIT, "Quit"); strcat (menu, tmp);
sprintf (tmp, " - %2d) %-25s\n", BASE_INIT, "Init library"); strcat (menu, tmp);
sprintf (tmp, " - %2d) %-25s", BASE_OPEN, "Open library"); strcat (menu, tmp);
sprintf (tmp, " - %2d) %-25s\n", BASE_INFO, "Info library"); strcat (menu, tmp);
sprintf (tmp, " - %2d) %-25s", BASE_CLOSE, "Close library"); strcat (menu, tmp);
sprintf (tmp, " - %2d) %-25s\n", BASE_END, "End library"); strcat (menu, tmp);
sprintf (tmp, " - %2d) %-25s", BASE_LOAD, "Load library cache"); strcat (menu, tmp);
sprintf (tmp, " - %2d) %-25s\n", BASE_UNLOAD, "Unload library cache"); strcat (menu, tmp);
sprintf (tmp, " - %2d) %-25s", SHOW_CHANNEL_LIST, "Show channels"); strcat (menu, tmp);
sprintf (tmp, " - %2d) %-25s\n", SHOW_RTAB_LIST, "Show rooting tables"); strcat (menu, tmp);
sprintf (tmp, " - %2d) %-25s", CHANNEL_DUMP, "Dump a channel"); strcat (menu, tmp);
sprintf (tmp, " - %2d) %-25s\n", RTAB_DUMP, "Dump a rooting table"); strcat (menu, tmp);
sprintf (tmp, " - %2d) %-25s\n", TEST_EVENT, "Test an event"); strcat (menu, tmp);
}
int print_menu (void)
{
fprintf (stdout, "---------------------------------------------------------------------------\n%s", menu);
tmp[0] = '\0';
while (tmp[0] == '\0')
{
printf ("\nChoice ? ");
gets (tmp);
}
return atoi (tmp);
}
char *Get_Rooting(LOGT_Rooting Rooting)
{
static char lib[20];
switch ((int)Rooting)
{
case LOGD_ROOTING_NULL:
strcpy(lib, "NULL");
break;
case LOGD_ROOTING_STDERR:
strcpy(lib, "STDERR");
break;
case LOGD_ROOTING_DATABASE:
strcpy(lib, "BASE");
break;
case LOGD_ROOTING_DEFAULT:
strcpy(lib, "DEFAULT");
break;
case LOGD_ROOTING_PREVIOUS:
strcpy(lib, "PREVIOUS");
break;
default:
strcpy(lib, "unknown");
break;
}
return lib;
}
char *Get_RC(LOGT_RC RC)
{
static char lib[20];
switch ((int)RC)
{
case LOGD_RC_OK:
strcpy(lib, "OK");
break;
case LOGD_RC_ANOERR:
strcpy(lib, "ANOERR");
break;
case LOGD_RC_REJDON:
strcpy(lib, "REJDON");
break;
case LOGD_RC_REJENR:
strcpy(lib, "REJENR");
break;
case LOGD_RC_WARNING:
strcpy(lib, "WARNING");
break;
case LOGD_RC_RECYCLE:
strcpy(lib, "RECYCLE");
break;
case LOGD_RC_EXIT:
strcpy(lib, "EXIT");
break;
case LOGD_RC_ABEND:
strcpy(lib, "ABEND");
break;
default:
strcpy(lib, "unknown");
break;
}
return lib;
}

504
util/logagent.c Normal file
View File

@ -0,0 +1,504 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <ver.h>
#define MSG_MODE 1
#include <msg.h>
#include <log.h>
#include <logagent.h>
VER_INFO_EXPORT (logagent, "$Revision: 1.1 $", "$Name: $", __FILE__, "$Author: smas $")
void Parse_Arg (int , char **);
void Event_Msg_Process ( MSGT_Message * );
void System_Msg_Process ( MSGT_Message * );
void Info_Trace ( void );
unsigned int End_Agent, Nb_Event, Nb_System_Msg;
MSGT_Port * Private_Port, * Event_Port;
MSGT_PortList * Private_PortList;
unsigned int Num_Agent, Status, Debug;
char Debug_Trace [512];
/*--------------------------------------------------------------------------------------------------*/
/* Fonction principale */
/*--------------------------------------------------------------------------------------------------*/
int main ( int argc, char ** argv )
{
MSGT_Message * Msg;
char Private_Port_Name [256];
/* Récupération des arguments de la ligne de commande */
Parse_Arg (argc, argv);
/* Démarrage de l'agent */
Status = ACTIVE;
/* Ouverture de la librairie LIBMSG */
if (MSG_Library_Open (NULL, NULL, MSGD_OPEN) != MSGS_OK)
{
strcpy (Debug_Trace, "impossible d'ouvrir la librairie LIBMSG");
Info_Trace ();
return KO;
}
/* Ouverture du port de message dans lequel sont envoyés les événements */
if (MSG_Port_Open (LOGD_EVENT_PORT_NAME, &Event_Port, MSGD_OPEN | MSGD_CREATE) != MSGS_OK)
{
strcpy (Debug_Trace, "impossible d'ouvrir le port de messages des événements");
Info_Trace ();
MSG_Library_Close (MSGD_CLOSE);
return KO;
}
/* Ouverture (cas du restart) ou création du port privé de l'agent */
sprintf (Private_Port_Name, "Agent_%d_port", Num_Agent);
if (MSG_Port_Open (Private_Port_Name, &Private_Port, MSGD_OPEN | MSGD_CREATE) != MSGS_OK)
{
strcpy (Debug_Trace, "impossible de d'ouvrir ou de créer mon port de messages privé");
Info_Trace ();
MSG_Port_Close (Event_Port, MSGD_CLOSE);
MSG_Library_Close (MSGD_CLOSE);
return KO;
}
/* Création d'une liste de ports (port public + port privé) que l'agent va écouter */
if (MSG_PortList_Open (&Private_PortList) != MSGS_OK)
{
strcpy (Debug_Trace, "impossible de créer ma liste de ports");
Info_Trace ();
MSG_Port_Close (Event_Port, MSGD_CLOSE);
MSG_Port_Close (Private_Port, MSGD_DESTROY);
MSG_Library_Close (MSGD_CLOSE);
return KO;
}
if (MSG_PortList_Port_Add (Private_PortList, Private_Port) != MSGS_OK || MSG_PortList_Port_Add (Private_PortList, Event_Port) != MSGS_OK)
{
strcpy (Debug_Trace, "impossible d'ajouter les ports privé et public à ma liste de ports");
Info_Trace ();
MSG_PortList_Close (Private_PortList);
MSG_Port_Close (Event_Port, MSGD_CLOSE);
MSG_Port_Close (Private_Port, MSGD_DESTROY);
MSG_Library_Close (MSGD_CLOSE);
return KO;
}
sprintf (Debug_Trace, "démarrage en mode trace %s", Debug == TRUE ? "activé" : "désactivé");
Info_Trace ();
/* Boucle principale */
Nb_System_Msg = 0;
Nb_Event = 0;
End_Agent = FALSE;
while (End_Agent == FALSE)
{
unsigned int Expected_Type;
if (Status == ACTIVE)
{
/* Quand l'agent est actif, il traite tous les types de messages */
Expected_Type = MSGD_NO_TYPE;
}
else
{
/* Quand l'agent est stoppé, il ne traite que les messages système */
Expected_Type = MSGD_SYSTEM_GENERIC;
}
/* Ecoute des ports de messages de la liste */
if (MSG_PortList_Listen (Private_PortList, Expected_Type, &Msg, MSGD_WAIT) != MSGS_OK)
{
strcpy (Debug_Trace, "impossible de réceptionner un message depuis l'un des ports écoutés");
Info_Trace ();
MSG_PortList_Close (Private_PortList);
MSG_Port_Close (Private_Port, MSGD_DESTROY);
MSG_Library_Close (MSGD_CLOSE);
return KO;
}
/* Traitement du message */
switch (Msg->Type)
{
case LOGD_EVENT_MSG_TYPE:
/* Il s'agit d'un événement */
Event_Msg_Process (Msg);
Nb_Event ++;
break;
default:
/* Il s'agit d'un message système */
System_Msg_Process (Msg);
Nb_System_Msg ++;
break;
}
}
/* Suppression de la liste de ports de l'agent */
if (MSG_PortList_Close (Private_PortList) != MSGS_OK)
{
strcpy (Debug_Trace, "impossible de supprimer ma liste de ports");
Info_Trace ();
MSG_Port_Close (Private_Port, MSGD_DESTROY);
MSG_Library_Close (MSGD_CLOSE);
return KO;
}
/* Suppression du port privé de l'agent */
if (MSG_Port_Close (Private_Port, MSGD_DESTROY) != MSGS_OK)
{
strcpy (Debug_Trace, "impossible de supprimer mon port de messages privé");
Info_Trace ();
MSG_Library_Close (MSGD_CLOSE);
return KO;
}
/* Fermeture de la librairie */
if (MSG_Library_Close (MSGD_CLOSE) != MSGS_OK)
{
strcpy (Debug_Trace, "impossible de fermer la librairie LIBMSG");
Info_Trace ();
return KO;
}
strcpy (Debug_Trace, "terminé");
Info_Trace ();
return OK;
}
/*--------------------------------------------------------------------------------------------------*/
/* Récupération de la ligne de commande */
/*--------------------------------------------------------------------------------------------------*/
void Parse_Arg (int argc, char ** argv)
{
int i;
Debug = FALSE;
for (i = 1; i < argc; i++)
{
if (!strcmp (argv[i], "--help") || !strcmp (argv[i], "-h"))
{
fprintf (stderr, "Usage : %s [ [--help|-h] | --version [-v] | -id <id_agent> [--debug] ]\n", argv [0]);
exit (1);
}
if (!strcmp (argv[i], "-id"))
{
i++;
if (i == argc)
{
fprintf (stderr, "Argument manquant après \"%s\"\n", argv[i - 1]);
exit (0);
}
Num_Agent = atoi (argv[i]);
continue;
}
if (!strcmp (argv[i], "--version"))
{
if (i+1 < argc && !strcmp (argv[i+1], "-v"))
{
VER_Object_Print (stdout, VERD_VERBOSE);
exit (0);
}
else
{
VER_Object_Print (stdout, VERD_MINIMAL);
exit (0);
}
}
if (!strcmp (argv[i], "--debug"))
{
Debug = TRUE;
continue;
}
fprintf (stderr, "Option invalide \"%s\"\n", argv[i]);
exit (0);
}
if (Num_Agent == 0)
{
fprintf (stderr, "Option \"-id\" manquante ou bien valeur incorrecte (doit être > 0)\n");
exit (0);
}
}
/*--------------------------------------------------------------------------------------------------*/
/* Traitement d'un message contenant un événement */
/*--------------------------------------------------------------------------------------------------*/
void Event_Msg_Process (MSGT_Message * Msg)
{
LOGT_Event_Msg_Data * Msg_Data;
unsigned int Length, Event_Type;
char Event_Name [256];
char Cd_Support [256];
char Data_Name [256];
char Data_Value [256];
unsigned int i;
char * Event_Data_Ptr;
/* Récupération des données de l'entête de l'événement */
Msg_Data = (LOGT_Event_Msg_Data *)(Msg->Data);
/* Vérification de la version du format */
if (strcmp (Msg_Data->Header.Version, EVENT_FORMAT_VERSION))
{
sprintf (Debug_Trace, "version du format de message \"%s\" incorrect (\"%s\" attendu)", Msg_Data->Header.Version, EVENT_FORMAT_VERSION);
Info_Trace ();
/* Suppression du message */
MSG_Message_Free (Msg);
return;
}
sprintf (Debug_Trace, "réception d'un événement de la part du processus %d (module %d/%d)",
Msg_Data->Header.Sending_Pid,
Msg_Data->Header.ModuleId,
Msg_Data->Header.Master_ModuleId);
/* Récupération de l'identifiant du type d'événement */
Event_Type = Msg_Data->Event_Type;
/* Récupération du nom de l'événement */
Event_Data_Ptr = &(Msg_Data->Event_Data);
i = 0;
Length = (unsigned int)(Event_Data_Ptr [i]);
strncpy (Event_Name, Event_Data_Ptr + i + 1, Length);
Event_Name [Length] = (char)0;
i += 1 + Length;
if (Debug == TRUE) fprintf (stderr, "%s\nEvénement \"%s\" (type=%d):", Debug_Trace, Event_Name, Event_Type);
Length = (unsigned int)(Event_Data_Ptr [i]);
strncpy (Cd_Support, Event_Data_Ptr + i + 1, Length);
Cd_Support [Length] = (char)0;
if (Debug == TRUE) fprintf (stderr, "%s\n\t- support=\"%s\"\n", Debug_Trace, Cd_Support);
i += 1 + Length;
/* Récupération des macro-données */
while (i < Msg_Data->Data_Size)
{
/* Récupération du nom de la macro-donnée */
Length = (unsigned int)(Event_Data_Ptr [i]);
strncpy (Data_Name, Event_Data_Ptr + i + 1, Length);
Data_Name [Length] = (char)0;
i += 1 + Length;
if (i < Msg->Size)
{
/* Récupération de la valeur de la macro-donnée */
Length = (unsigned int)(Event_Data_Ptr [i]);
strncpy (Data_Value, Event_Data_Ptr + i + 1, Length);
Data_Value [Length] = (char)0;
i += 1 + Length;
}
else
{
strcpy (Debug_Trace, "mauvais format d'événement");
Info_Trace ();
}
if (Debug == TRUE) fprintf (stderr, "\t- %s=%s\n", Data_Name, Data_Value);
}
/* Traitement de l'événement
...
...
...
*/
/* Renvoi du message à l'envoyeur */
if (MSG_Message_Reply (Msg) != MSGS_OK)
{
strcpy (Debug_Trace, "impossible de renvoyer le message de l'événement à son envoyeur");
Info_Trace ();
}
}
/*--------------------------------------------------------------------------------------------------*/
/* Traitement d'un message système par un agent */
/*--------------------------------------------------------------------------------------------------*/
void System_Msg_Process (MSGT_Message * Msg)
{
/* Pour accuser réception du message système, on commence par remplir les données liées à l'agent */
((Agent_Stat *)(Msg->Data))->Num_Agent = Num_Agent;
((Agent_Stat *)(Msg->Data))->Pid = getpid ();
switch (Msg->Type)
{
case MSGD_SYSTEM_STOP_REQUEST:
if (Status == ACTIVE)
{
/* On indique que la requête a bien été prise en compte */
((Agent_Stat *)(Msg->Data))->Answer = TRUE;
/* Pause de l'agent jusqu'à réception d'un message MSGD_SYSTEM_CONTINUE_REQUEST */
Status = STOPPED;
strcpy (Debug_Trace, "pause");
Info_Trace ();
}
else
{
/* On indique que la requête n'a pas été prise en compte */
((Agent_Stat *)(Msg->Data))->Answer = FALSE;
}
break;
case MSGD_SYSTEM_CONTINUE_REQUEST:
if (Status == STOPPED)
{
/* On indique que la requête a bien été prise en compte */
((Agent_Stat *)(Msg->Data))->Answer = TRUE;
/* Reprise de l'agent */
Status = ACTIVE;
strcpy (Debug_Trace, "reprise");
Info_Trace ();
}
else
{
/* On indique que la requête n'a pas été prise en compte */
((Agent_Stat *)(Msg->Data))->Answer = FALSE;
}
break;
case MSGD_SYSTEM_SHUTDOWN_REQUEST:
/* Fin de la boucle principale de l'agent */
End_Agent = TRUE;
strcpy (Debug_Trace, "terminaison en cours...");
Info_Trace ();
break;
case MSGD_SYSTEM_STATUS_REQUEST:
/* On informe le superviseur sur l'état dans lequel on se trouve */
((Agent_Stat *)(Msg->Data))->Status = Status;
((Agent_Stat *)(Msg->Data))->Debug = Debug;
break;
case MSGD_SYSTEM_INFO_REQUEST:
/* On informe le superviseur sur le nombre de messages (système et événement) traités */
((Agent_Stat *)(Msg->Data))->Cpt_Event = Nb_Event;
((Agent_Stat *)(Msg->Data))->Cpt_System = Nb_System_Msg;
break;
case MSGD_SYSTEM_TRACEON_REQUEST:
Debug = TRUE;
strcpy (Debug_Trace, "activation du mode trace");
Info_Trace ();
break;
case MSGD_SYSTEM_TRACEOFF_REQUEST:
strcpy (Debug_Trace, "désactivation du mode trace");
Info_Trace ();
Debug = FALSE;
break;
default :
/* On indique que la requête n'a pas été prise en compte */
((Agent_Stat *)(Msg->Data))->Answer = FALSE;
break;
}
/* On accuse réception du message */
MSG_Message_Reply (Msg);
}
/*--------------------------------------------------------------------------------------------------*/
/* Affichage sur la sortie standard d'erreur d'un message généré par un agent */
/*--------------------------------------------------------------------------------------------------*/
void Info_Trace ( void )
{
time_t dts;
struct tm * dt;
char Current_Date [25];
if (Debug == TRUE)
{
/* Récupère la date courante */
time (&dts);
dt = localtime (&dts);
sprintf (Current_Date, "%02d/%02d/%04d %02d:%02d:%02d", dt->tm_mday, dt->tm_mon + 1, dt->tm_year + 1900, dt->tm_hour, dt->tm_min, dt->tm_sec);
fprintf (stderr, "[%s] Agent n°%d : %s\n", Current_Date, Num_Agent, Debug_Trace);
}
}

24
util/logagent.h Normal file
View File

@ -0,0 +1,24 @@
#define ANSWER_SIZE 1000 /* Taille minimale des messages système adressés au superviseur */
#define DEFAULT_TIMEOUT 5 /* Nombre de secondes avant lesquelles les agents devront répondre aux requêtes du superviseur */
#define NB_MAX_AGENT 50 /* Nombre maximal d'agents pouvant être suivis par le superviseur */
/* Etats possibles d'un agent */
#define STOPPED 0
#define ACTIVE 1
#define OK 1
#define KO -1
/* Structure contenant les informations qu'un agent renvoie au superviseur */
typedef struct {
unsigned int Num_Agent; /* Numéro de l 'agent */
pid_t Pid; /* Identifiant du processus de l'agent */
unsigned int Status; /* Etat dans lequel se trouve l'agent */
unsigned int Debug; /* Mode debug dans lequel se trouve l'agent */
unsigned int Cpt_Event; /* Nombre d'événements traités */
unsigned int Cpt_System; /* Nombre de messages système traités */
unsigned int Answer; /* Réponse de l'agent à la requête */
} Agent_Stat;

150
util/logbench.c Normal file
View File

@ -0,0 +1,150 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <sys/time.h>
#define LOG_MODE 1
#include <log.h>
#include <tool.h>
typedef struct {
double sec;
long count;
struct timeval start;
struct timeval stop;
} cpt;
#define t_init(x) {x.sec = 0; x.count = 0;}
#define t_start(x) {gettimeofday(&(x.start), NULL);}
#define t_stop(x) {gettimeofday(&(x.stop), NULL); x.sec += (double)(x.stop.tv_sec) - (double)(x.start.tv_sec) + ((double)(x.stop.tv_usec) - (double)(x.start.tv_usec)) / 1000000; x.count++;}
int main (int argc, char ** argv)
{
LOGT_Channel * My_Channel;
char Line [1000], * Event_Data;
FILE * fid;
unsigned int Nb_Send, Line_Number, i;
cpt Compteur;
if (argc != 2)
{
fprintf (stderr, "Usage : %s <event_list>\n", argv [0]);
return -1;
}
/* Ouverture du fichier de test */
fid = fopen (argv [1], "r");
if (!fid)
{
fprintf (stderr, "Unable to open file \"%s\" for reading\n", argv [1]);
return -1;
}
/* Ouverture de la librairie */
if (LOG_Library_Open (0, NULL, LOGD_OPEN | LOGD_DEBUG_ALL) != LOGS_OK)
{
fprintf (stderr, "\n=> Impossible d'ouvrir la librairie LIBLOG\n");
return -1;
}
/* Ouverture d'un channel */
if (LOG_Channel_Open (&My_Channel, 0, 1, "IPR_CAVpopulate2.pc", "IPR_CAV") != LOGS_OK)
{
fprintf (stderr, "\n=> Impossible d'ouvrir un channel\n");
return -1;
}
/* Ajout des tables de routage utilisateur */
if (TL_Channel_RTab_Add (My_Channel, "UTILS:ROOTING:ROOTING_TABLE") != TLS_OK)
{
fprintf (stderr, "\n=> Impossible d'ajouter les tables de routage au channel\n");
LOG_Channel_Close (My_Channel);
return -1;
}
/* Ajout des triggers */
if (TL_Channel_Trigger_Add (My_Channel, "UTILS:ROOTING:TRIGGER") != TLS_OK)
{
fprintf (stderr, "\n=> Impossible d'ajouter les triggers au channel\n");
LOG_Channel_Close (My_Channel);
return -1;
}
/* Initialisation du compteur */
t_init (Compteur);
/* Envoi des événements paramétrés dans le fichier */
Line_Number = 1;
while (!feof (fid) && fgets (Line, 1000, fid))
{
/* Récupération des informations dans la ligne du fichier */
Event_Data = strchr (Line, '#');
if (Event_Data == NULL)
{
fprintf (stderr, "Warning ligne n°%d : format incorrect (caractère '#' manquant)\n", Line_Number);
}
else
{
*Event_Data = (char)0;
Nb_Send = atoi (Line);
if (Nb_Send <= 0)
{
fprintf (stderr, "Warning ligne n°%d : valeur (%d) incorrecte avant le caracatère '#'\n", Line_Number, Nb_Send);
Nb_Send = 1;
}
Event_Data++;
for (i = 0; i < Nb_Send; i++)
{
t_start (Compteur);
/* Envoi de l'événement proprement dit */
if (LOG_Event_External_Send (My_Channel, argv [1], Event_Data) == LOGD_RC_WARNING)
fprintf (stderr, "Warning ligne n°%d : code retour WARNING sur envoi de l'événement\n", Line_Number);
t_stop (Compteur);
}
}
Line_Number++;
}
fclose (fid);
/* Affichage du résultat du benchmark */
fprintf (stdout, "%ld événements envoyés en %.2f sec (%.2f évt/sec)\n", Compteur.count, Compteur.sec, Compteur.count / Compteur.sec);
/* Fermeture du channel */
if (LOG_Channel_Close (My_Channel) != LOGS_OK)
{
fprintf (stderr, "\n=> Impossible de fermer le channel\n");
return -1;
}
/* Fermeture de la librairie */
if (LOG_Library_Close (LOGD_CLOSE) != LOGS_OK)
{
fprintf (stderr, "\n=> Impossible de fermer la librairie LIBLOG\n");
return -1;
}
return 1;
}

187
util/logresolve.c Normal file
View File

@ -0,0 +1,187 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <stdarg.h>
#include <ver.h>
#define ND_MODE 1
#include <node.h>
#define LOG_MODE 1
#include <log.h>
VER_INFO_EXPORT (logresolve, "$Revision: 1.1 $", "$Name: $", __FILE__, "$Author: smas $")
typedef struct {
double sec;
struct timeval start;
struct timeval stop;
} cpt;
#define t_start(x){gettimeofday (&(x.start), NULL);}
#define t_stop(x){gettimeofday (&(x.stop), NULL); x.sec = (double)(x.stop.tv_sec) - (double)(x.start.tv_sec) + \
((double)(x.stop.tv_usec) - (double)(x.start.tv_usec)) / 1000000;}
cpt t_exec;
char * Get_Rooting (LOGT_Rooting);
char * Get_RC (LOGT_RC);
#define USAGE "Usage : %s [ --help | --version [-v] | --event <event name> ]\n"
int main (int argc, char **argv)
{
LOGT_Info * Info;
char * Event;
int i;
if (argc >= 2)
{
if (!strcmp (argv [1], "--help"))
{
fprintf (stderr, USAGE, argv [0]);
return 1;
}
else if (!strcmp (argv [1], "--version"))
{
if (argc >= 3 && !strcmp (argv [2], "-v"))
return VER_Object_Print (stdout, VERD_VERBOSE);
else
return VER_Object_Print (stdout, VERD_MINIMAL);
}
else if (!strcmp (argv [1], "--event"))
{
if (argc != 3)
{
fprintf (stderr, USAGE, argv [0]);
return 0;
}
Event = argv [2];
}
else
{
fprintf (stderr, USAGE, argv [0]);
return 0;
}
}
else
{
fprintf (stderr, USAGE, argv [0]);
return 0;
}
/* Récupération des informations sur un événement */
Info = (LOGT_Info *) malloc (sizeof (LOGT_Info));
if (LOG_Library_Open (0, NULL, LOGD_OPEN | LOGD_DEBUG_ALL) != LOGS_OK)
{
fprintf (stderr, "=> Ouverture de la librairie LIBLOG impossible\n");
return 0;
}
t_start (t_exec);
if (LOG_Event_Info_Get (NULL, &Info, Event) != LOGS_OK)
{
t_stop (t_exec);
fprintf (stderr, "=> Impossible de résoudre l'événement \"%s\"\n", Event);
}
else
{
NDT_Node * Node;
t_stop (t_exec);
fprintf (stdout, "\nEvénement \"%s\" résolu en %.4f sec :\n", Event, t_exec.sec);
fprintf (stdout, "\t- Type : %s (Id=%d)\n", Info->Event_Name, Info->Event_Type);
fprintf (stdout, "\t- Routage : %s\n", Get_Rooting (Info->Rooting));
fprintf (stdout, "\t- Gravité : %c\n", (char)Info->Gravite);
fprintf (stdout, "\t- Code retour : %s\n", Get_RC (Info->RC));
fprintf (stdout, "\t- Format :");
if (Info->Data_List)
{
ND_Node_First_Get (Info->Data_List, &Node);
i = 0;
while (Node)
{
if (i > 0) fprintf (stdout, ",");
fprintf (stdout, " %s", (char *)(Node->Value));
ND_Node_Next_Get (Node, &Node);
i++;
}
}
fprintf (stdout, "\n\n");
}
LOG_Library_Close (LOGD_CLOSE);
free (Info);
return 0;
}
char * Get_Rooting (LOGT_Rooting Rooting)
{
static char lib [20];
switch ((int)Rooting)
{
case LOGD_ROOTING_NULL:
strcpy (lib, "NULL");
break;
case LOGD_ROOTING_STDERR:
strcpy (lib, "STDERR");
break;
case LOGD_ROOTING_DATABASE:
strcpy (lib, "BASE");
break;
case LOGD_ROOTING_DEFAULT:
strcpy (lib, "DEFAULT");
break;
case LOGD_ROOTING_PREVIOUS:
strcpy (lib, "PREVIOUS");
break;
default:
strcpy (lib, "unknown");
break;
}
return lib;
}
char * Get_RC (LOGT_RC RC)
{
static char lib [20];
switch ((int)RC)
{
case LOGD_RC_OK:
strcpy (lib, "OK");
break;
case LOGD_RC_ANOERR:
strcpy (lib, "ANOERR");
break;
case LOGD_RC_REJDON:
strcpy (lib, "REJDON");
break;
case LOGD_RC_REJENR:
strcpy (lib, "REJENR");
break;
case LOGD_RC_WARNING:
strcpy (lib, "WARNING");
break;
case LOGD_RC_RECYCLE:
strcpy (lib, "RECYCLE");
break;
case LOGD_RC_EXIT:
strcpy (lib, "EXIT");
break;
case LOGD_RC_ABEND:
strcpy (lib, "ABEND");
break;
default:
strcpy (lib, "unknown");
break;
}
return lib;
}

1246
util/logsupervisor.c Normal file
View File

File diff suppressed because it is too large Load Diff