pshandler.h

Go to the documentation of this file.

/*
** Copyright (C) 2004 Russell Leighton
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/




#ifndef __AWHANDLER_PS__
#define __AWHANDLER_PS__

#include <dirent.h>

#include "monitor.h"
#include "wire.h"

#include "regexmatch.h"

/****
     moved below comment out of above because the "wire"
     interface does not allow you to set these currently
****/
/*
Options:
<ul>
<li> AW_PSHANDLER_GROUP : Watch a group of processes defined by
matching the regex. Only send 'up' events when the first
match appears and only send 'down' events when the last match disappears.
This is useful for applications like Apache which fork/kill
child processes regularly. 
<li> AW_PSHANDLER_COUNTONCHANGE : Only send 'count' events when the
count of the processes matching the regex changes. By default, the
'count' events are generated every cycle. This option is useful is you
are interested in notification if the number of processes gets
below or above a certain number (used with the rfilterhandler).
</ul>

\endhtmlonly

*/

/* 

Changes:

02/11/04 Russell Leighton
Port to handler

03/12/02 Russell Leighton
Fix small buglet if FILE_TO_BUF fails.

*/

typedef enum {

  AW_PSHANDLER_GROUP = 0x1,         /* only send 'up'/'down' events based on whole group */
  AW_PSHANDLER_COUNTONCHANGE = 0x2, /* only send 'count' events when count changes */

} aw_pshandler_flag_t;


#define AW_PSHANDLER_DEFAULT_FLAGS ( AW_PSHANDLER_GROUP | AW_PSHANDLER_COUNTONCHANGE)

typedef struct aw_pshandler_pidlist_s {

  struct aw_pshandler_pidlist_s 
   *next;

  u_int32_t
   pid;

  /* rss / memtotal (as a decimal) */
  float64_t
   percentmem;

  /* utime + stime */
  aw_timestamp_t
   totaltime;

} aw_pshandler_pidlist_t;

typedef struct aw_pshandler_watchlist_s {

  struct aw_pshandler_watchlist_s 
   *next;

  u_int32_t
   pid;

  byte_t
   *cmdline;

} aw_pshandler_watchlist_t;


typedef struct {

  aw_event_sig_t
   up,               /* regex matched and process is noticed up */
   down,             /* regex matched and process is noticed down */
   count;            /* count of regex matched processes */

} aw_pshandler_events_t;

typedef struct {

  /* total main memory in KB , used to calc %mem */
  u_int32_t
   memtotal;

  /* open stream to /proc */
  DIR
   *dir;             

  /* sorted list of pids that were up last poll interval */
  aw_pshandler_pidlist_t
   *up;              

  aw_cache_allocator_t
   pidlist_factory;

  /* last time the handler was run */
  aw_timestamp_t
   last_handler_timestamp;

} aw_pshandler_state_t;



typedef struct {

  aw_pshandler_flag_t
   flags;

  aw_pshandler_events_t
    events;

  /* regex string */
  const byte_t
   *regex;

  /* holds substitution string, may be NULL */
  const byte_t
   *subst;

} aw_pshandler_regex_t;

typedef struct {

  aw_pshandler_flag_t
   flags;

  aw_pshandler_events_t
    events;

  /* holds compiled regular expression  */
  regex_t
   pattern;

  /* holds substitution string, may be NULL */
  byte_t
   *subst;

  aw_pshandler_watchlist_t
   *watch;           /* list of pids that are in 'up' that matched regex */

  u_int32_t
   watchcount;       /* length of watch list */

} aw_pshandler_watcher_t;

typedef struct {

  /* generate event if proceses %mem is in [min,max] */
  float64_t
   min,max;

  aw_event_sig_t
   memevent;

} aw_pshandler_memfilter_t;


typedef struct {

  /* generate event if proceses %cpu is in [min,max] */
  float64_t
   min,max;

  aw_event_sig_t
   cpuevent;

} aw_pshandler_cpufilter_t;


typedef struct {

  aw_handler_t 
    handler_header;

  u_int32_t
   nwatchers;

  aw_pshandler_watcher_t
   *watchers;

  aw_pshandler_memfilter_t
   memfilter;

  aw_pshandler_cpufilter_t
   cpufilter;

  aw_pshandler_state_t
   state;

} aw_pshandler_t ;


aw_pshandler_t *aw_create_pshandler(u_int32_t nregexs,
                                    aw_pshandler_regex_t *regexs,    
                                    aw_pshandler_memfilter_t *memfilter,
                                    aw_pshandler_cpufilter_t *cpufilter, 
                                    int32_t (*regevent)(aw_handler_t *h, aw_address_t *eventid, u_int32_t index),
                                    int32_t (*regmaskevent)(aw_handler_t *h, aw_address_t *eventid, u_int32_t index),
                                    const aw_alarm_sched_t *sched,
                                    aw_logger_t *logger
                                    );

void aw_free_pshandler(aw_pshandler_t *p);

aw_handler_t *aw_wire_pshandler(aw_wire_mkhandler_args_t *args);

#endif

Aware 0.11.1 Copyright (C) 1998-2005 Russell Leighton (russ@elegant-software.com)