awdb.h

Go to the documentation of this file.

/*
** Copyright (C) 2003 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 __AW_DB__
#define __AW_DB__

#include "monitor.h"

#include "regexmatch.h"

/*

Changes:

*/

typedef struct {

  aw_event_sig_t
   connect,                  /* could connect */
   noconnect,                /* could NOT connect */
   complete,                 /* sql completed successfully */
   time;                     /* sql completed successfully and this is how long it took */

} aw_db_cevents_t;


typedef struct {

  float64_t                  /* generate event if count of sql rows is  [min,max] */
   min,
   max;

  aw_event_sig_t
   cevent;                     

} aw_db_counter_t;


typedef struct {

  aw_event_sig_t
   match,                    /* regex matched */
   nomatch;                  /* regex did NOT match */

} aw_db_revents_t;

typedef struct {

  aw_db_revents_t
    revents;

  /* regex string */
  const byte_t
   *regex;

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

} aw_db_regex_t;

typedef struct {

  aw_db_revents_t
    revents;

  /* holds compiled regular expression  */
  regex_t
   pattern;

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

} aw_db_rwatcher_t;


/* #################################### Functions ################################################# */


void aw_db_handler_rmatch(aw_handler_args_t *args, 
                          aw_event_t *event, 
                          byte_t *row_as_string,
                          u_int32_t nwatchers, 
                          aw_db_rwatcher_t *watchers,
                          u_int32_t *match_markers);



/* #################  Macros for generic code common to all supported databases #################### */


#define AW_DB_DISCONNECT_POOL(CONN_TYPE)                                                                                    \
do {                                                                                                                        \
 CONN_TYPE                                                                                                                  \
  *conn;                                                                                                                    \
 while( (conn = aw_llt_getobj(key, dbpool)) != NULL ) free_connection(conn);                                                \
} while(0);

#define MAX_CONNECTION_DELAY 60

#define AW_DB_CONNECT(CONN_TYPE, PREFIX)                                                                                    \
do {                                                                                                                        \
  /* capped exponential backoff in case of failed connections */                                                            \
  if (state->connection_attempts > 0) {                                                                                     \
    struct timespec                                                                                                         \
      sleep_interval ;                                                                                                      \
    u_int32_t                                                                                                               \
      shift = (state->connection_attempts<31)?state->connection_attempts:30; /* don't shift into sign bit! */               \
                                                                                                                            \
    sleep_interval.tv_sec = (1 << shift);                                                                                   \
    if (sleep_interval.tv_sec > MAX_CONNECTION_DELAY ||                                                                     \
        sleep_interval.tv_sec <= 0 /* in case you messed up the shift :) */ ) sleep_interval.tv_sec = MAX_CONNECTION_DELAY; \
                                                                                                                            \
    sleep_interval.tv_nsec = 0;                                                                                             \
                                                                                                                            \
    aw_nanosleep(&sleep_interval);                                                                                          \
                                                                                                                            \
  }/* end if */                                                                                                             \
                                                                                                                            \
  /* get the connection */                                                                                                  \
  {                                                                                                                         \
    CONN_TYPE                                                                                                               \
      *conn;                                                                                                                \
    byte_t                                                                                                                \
      key[128];                                                                                                             \
                                                                                                                            \
    /* in connection pool? */                                                                                               \
    make_connection_key(key, sizeof(key), cinfo);                                                                           \
    conn = aw_llt_getobj(key, dbpool);                                                                                      \
                                                                                                                            \
    if (conn == NULL) { /* must need a new a connection... */                                                               \
                                                                                                                            \
      conn = make_connection(cinfo,logger);                                                                         \
      if (conn == NULL) goto error;                                                                                         \
                                                                                                                            \
    } else { /* found connection in the pool */                                                                             \
                                                                                                                            \
      /* keep sure the connection still works */                                                                            \
      if ( ! isvalid_connection(conn) ) {                                                                                   \
                                                                                                                            \
        /* ... if not, cleanup and then try to make a new one */                                                            \
        free_connection(conn);                                                                                              \
        conn = make_connection(cinfo, logger);                                                                       \
        if (conn == NULL) goto error;                                                                                       \
                                                                                                                            \
      }/* end if */                                                                                                         \
                                                                                                                            \
    }/* end if */                                                                                                           \
                                                                                                                            \
    /* now connected  */                                                                                                    \
    state->connected = 1;                                                                                                   \
                                                                                                                            \
    state->conn = conn;                                                                                                     \
  }                                                                                                                         \
                                                                                                                            \
  /* success */                                                                                                             \
  state->connection_attempts = 0;                                                                                           \
                                                                                                                            \
  return;                                                                                                                   \
                                                                                                                            \
 error:; /* conn == NULL !!! */                                                                                             \
                                                                                                                            \
  aw_log(logger, AW_ERROR_LOG_LEVEL, "Failed to create " #PREFIX " connection");                                            \
                                                                                                                            \
  /* not connected  */                                                                                                      \
  state->connected = -1;                                                                                                    \
                                                                                                                            \
  state->conn = NULL;                                                                                                       \
                                                                                                                            \
  state->connection_attempts++;                                                                                             \
                                                                                                                            \
  /* disconnect all because likely we have connectivity issue */                                                            \
  aw_ ## PREFIX ## _disconnect_all (cinfo, state, logger);                                                                  \
} while (0);


#define AW_DB_DISCONNECT_ALL(PREFIX)                                                                                        \
do {                                                                                                                        \
  byte_t                                                                                                                  \
    key[128];                                                                                                               \
                                                                                                                            \
  /* close this one */                                                                                                      \
  aw_ ## PREFIX ## _disconnect (cinfo, state, logger, 1);                                                                   \
                                                                                                                            \
  /* close the pool */                                                                                                      \
  make_connection_key(key, sizeof(key), cinfo);                                                                             \
                                                                                                                            \
  disconnect_all(key);                                                                                                      \
} while(0); 

#define AW_DB_DISCONNECT(PREFIX)                                                                                            \
do {                                                                                                                        \
  if (state->conn != NULL) {                                                                                                \
    byte_t                                                                                                                \
      key[256];                                                                                                             \
                                                                                                                            \
    if (close) { /* usually means error */                                                                                  \
                                                                                                                            \
      free_connection(state->conn);                                                                                         \
                                                                                                                            \
    } else { /* cache */                                                                                                    \
      int32_t                                                                                                               \
        r = (rand()*100.0F)/RAND_MAX;                                                                                       \
                                                                                                                            \
      make_connection_key(key, sizeof(key), cinfo);                                                                         \
                                                                                                                            \
      /* 5% of the time we free a connection we will just close it,                                                         \
         and ALL others...this prevents accumulation of open                                                                \
         connections that were a result of a spike of contentious requests                                                  \
      */                                                                                                                    \
      if ( r < 5 ) {                                                                                                        \
                                                                                                                            \
        /* me */                                                                                                            \
        free_connection(state->conn);                                                                                       \
                                                                                                                            \
        /* all the rest like me */                                                                                          \
        disconnect_all(key);                                                                                                \
                                                                                                                            \
      } else { /* put live connection back in pool for re-use */                                                            \
                                                                                                                            \
        aw_llt_putobj(key, state->conn, dbpool);                                                                            \
                                                                                                                            \
      }/* end else */                                                                                                       \
                                                                                                                            \
    }/* end else */                                                                                                         \
                                                                                                                            \
    /* reset */                                                                                                             \
    state->conn = NULL;                                                                                                     \
                                                                                                                            \
  }/* end if */                                                                                                             \
                                                                                                                            \
  state->prev_connected = state->connected; /* remember */                                                                  \
                                                                                                                            \
  state->connected = -1; /* mark as down */                                                                                 \
} while(0);


#endif

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