Re: exec stuff topic

[Martin Pala]

Yet one thing (it was outlined in the mentioned discussion too:

1.) passive mode is easy to care:

---
static void handle_event(Event_T E) {

ASSERT(E);

if(E->id != EVENT_NULL) {
-   handle_exec(E);
+  if(E->source->mode != MODE_PASSIVE) handle_exec(E);
  handle_alert_event(E);
}
...
---

2.) methods are responsible for indication whether it was successfull or 
not (return code TRUE/FALSE). Monit can't know what is the goal of 
particular method - the only supercontrol over method successesfullness 
which monit have is that in the case of problem, the same event will 
occure soon again (thats why 'timeout' statement is here for). In the 
case that (generaly) the method will return FALSE, EVENT_FAILED will be 
generated.

Following constructs won't be possible in the case of proposed scheme - 
it must be replaced by simple return code control.

OBSOLETE:
---
   check_service(E->source->name, "stop");

   if(is_process_running(E->source)) {
     E->id= EVENT_FAILED;
     swap_message(E, "Failed to stop service '%s'", E->source->name);
   }
---

3.) dependency stuff should support private-like method classification, 
which won't be pushed to dependants. Default (public) methods will post 
the event to all dependants so in my illustration instead of simple 
spawn something like following is more appropriate:

---
static void handle_exec(Event_T E) {

struct mycommand command = E->source->methodlist;

while(command) {

 if( IS(E->default_method_name, E->source->methodlist->name) ||
     (E->id&mask == E->source->methodlist->events&mask)) {

     if(command->private)
       spawn(command); /* it is safe to run command here */
     else
       check_service(E->source->name, E->id); /* must be redesigned to 
post the same event id for every dependant */

     return;

 }

command= E->source->methodlist->next;

}

}
---


Martin Pala wrote:

> I went through new code - it very very nice (i'm starting to like C 
> more and more :)
>
> I think your events implementation provides way for method 
> registration which i proposed few weeks ago.
>
> It is universal system for registering methods for particular events - 
> it is on user to define and register methods. In the case of new test 
> addition, we just add new validation function which will post new type 
> of event and the rest is provided automaticaly. It simplifies code i 
> think.
>
> There is ilustration code (however it is pretty piggy - it is meant as 
> illustration only):
>
> ----
>
> /* present handle_event which is proposed for refactoring: */
> static void handle_event(Event_T E) {
>
>  ASSERT(E);
>
>  switch(E->id) {
>  case EVENT_START:   handle_start(E); break;
>  case EVENT_STOP:    handle_stop(E); break;
>  case EVENT_RESTART: handle_restart(E); break;
>  }
>
>  if(E->id != EVENT_NULL) {
>    handle_alert_event(E);
>    /* TODO: handle_exec_event(E); */
>  }
>
>  Event_free(&E);
>
> }
>
>
> --------------
>
> /* mycommand structure addopts name of the method specified in 
> configuration, for example:
> *    method NAME "..."
> * and events registration mask from Exec_T which can be removed.
> * mycommand structure is transformed to the list
> */
> typedef struct mycommand {
>  char *arg[ARGMAX];                             /**< Program with 
> arguments */
>  int length;                         /**< The length of the arguments 
> array */
>  int has_uid;            /**< TRUE if a new uid is defined for this 
> Command */
>  uid_t uid;         /**< The user id to switch to when running this 
> Command */
>  int has_gid;            /**< TRUE if a new gid is defined for this 
> Command */
>  gid_t gid;        /**< The group id to switch to when running this 
> Command */
>  /**********NEW ***********/
>  char name; /** method name */
>  unsigned int events;    /**< Events triggering this program to be 
> executed */
>  struct mycommand *next;
>  /**********NEW ***********/
>
> } *Command_T;
>
>
> /* Service_T from monitor.h replaces start+stop method callbacks by 
> general method list */
> typedef struct myservice {
>  int task;                                         /**< Monitored task 
> type */
>  char *name;                                  /**< Service descriptive 
> name */
>  char *group;                                       /**< Service group 
> name */
>  /* REMOVE: Command_T start;*/                    /**< The start 
> command for the service */
>  /* REMOVE: Command_T stop;*/                      /**< The stop 
> command for the service */
>  Command_T methodlist;
> .....
> }
>
>
> /* Event_Table adds default method binding (third field)  for 
> automatic registration if the method's name corresponds to event, for 
> example for:
> *   EVENT_START ... is by default registered (if exists): 'method 
> START ....'
> *   etc.
> */
> struct Event_Table {
>  int id;
>  char description[STRLEN];
>  char default_method_name[STRLEN];
> } Event_Table[]= {
>    {EVENT_NULL,              "No Event",                        "void"},
>    {EVENT_FAILED,          "Failed",                              
> "fail"},
>    {EVENT_START,           "Started",                            
> "start"},
>    {EVENT_STOP,             "Stopped",                           "stop"},
>    {EVENT_RESTART,      "Restarted",                        "restart"},
>    {EVENT_CHECKSUM,  "Checksum error",             "cheksum"},
>    {EVENT_RESOURCE,  "Resource limit matched", "resource"},
>    {EVENT_TIMEOUT,       "Timeout",                          "timeout"},
>    {EVENT_TIMESTAMP,  "Timestamp error",            "timestamp"}};
>
>
>
> /* we will go through registered methods and alerts list and do 
> appropriate action in the case that registered method/alert was found */
> static void handle_event(Event_T E) {
>
>  ASSERT(E);
>
>  if(E->id != EVENT_NULL) {
>    handle_exec(E);
>    handle_alert_event(E);
>  }
>
>  Event_free(&E);
>
> }
>
>
> /* take care for looking for registered method:
> * EITHER method registered by default event tag is found
> * OR method registered explicitly by event list is found
> * OTHERWISE no method is registered for this event => skip
> */
> static void handle_exec(Event_T E) {
>
>  struct mycommand command = E->source->methodlist;
>
>  while(command) {
>
>   if( IS(E->default_method_name, E->source->methodlist->name) ||
>       (E->id&mask == E->source->methodlist->events&mask)) {
>
>       spawn(command);
>       return;
>
>   }
>
>  command= E->source->methodlist->next;
>
>  }
>
> }
>
> ---
> CONFIGURATION EXAMPLE:
>
> method start "/etc/init.d/foo start" /* automaticaly registered for 
> start method because of 'start' name */
> method stop "/etc/init.d/foo start" /* automaticaly registered for 
> stop method because of 'stop' name */
> method restart "/etc/init.d/foo restart" on { failed resorce } /* 
> automaticaly registered for restart method by name + additionaly 
> explicitly named events */
> method reload "/etc/init.d/foo reload" on { timestamp } /* registered 
> just for timestamp event because there's no default event tag 'reload' */
>
>
> What do you think? Is this way possible?
>
> Cheers,
> Martin