alarm_checks.c

Go to the documentation of this file.

/*
 * $Id$
 *
 * SNMPStats Module 
 * Copyright (C) 2006 SOMA Networks, INC.
 * Written by: Jeffrey Magder (jmagder@somanetworks.com)
 *
 * This file is part of Kamailio, a free SIP server.
 *
 * Kamailio 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
 *
 * Kamailio 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
 *
 * History:
 * --------
 * 2006-11-23 initial version (jmagder)
 * 
 * This file groups together alarm checking and handling
 */

#include <signal.h>

#include "../../lib/kcore/statistics.h"

#include "alarm_checks.h"
#include "sub_agent.h"
#include "utilities.h"
#include "snmpObjects.h"
#include "snmpMIBNotifications.h"

int check_msg_queue_alarm(int threshold_to_compare_to) 
{
        int bytesWaiting = 0;

        if (threshold_to_compare_to < 0)
        {
                return 0;
        }
        
        bytesWaiting = get_total_bytes_waiting(); 

        if (bytesWaiting > threshold_to_compare_to)
        {
                return bytesWaiting;
        }

        return 0;
}


int check_dialog_alarm(int threshold_to_compare_to) 
{
        int num_dialogs;

        if (threshold_to_compare_to < 0) 
        {
                return 0;
        }

        num_dialogs = get_statistic("active_dialogs");

        if (num_dialogs > threshold_to_compare_to) 
        {
                return num_dialogs;
        }

        return 0;
}

void run_alarm_check(unsigned int ticks, void * attr) 
{
        static int msg_queue_minor_threshold;
        static int msg_queue_major_threshold;           

        static int dialog_minor_threshold;
        static int dialog_major_threshold;

        static char firstRun = 1;
        
        int bytesInMsgQueue;
        int numActiveDialogs;

        /* We only need to retrieve our thresholds the first time around */
        if (firstRun) 
        {
                register_with_master_agent(ALARM_AGENT_NAME);

                msg_queue_minor_threshold = get_msg_queue_minor_threshold();
                msg_queue_major_threshold = get_msg_queue_major_threshold();

                dialog_minor_threshold = get_dialog_minor_threshold();
                dialog_major_threshold = get_dialog_major_threshold();

                firstRun = 0;
        }
        
        /* We need to have this here in case the master agent fails and is
         * restarted.  Without it, we won't be able to re-establish or AgentX
         * connection */
        agent_check_and_process(0); 

        /* Check for MsgQueue alarm conditions */

        /* The retrieved number of bytes will be zero unless
         * there is an alarm condition.  In this case the number
         * of bytes will be returned. */
        bytesInMsgQueue = check_msg_queue_alarm(msg_queue_minor_threshold);

        if (bytesInMsgQueue != 0) 
        {
                send_openserMsgQueueDepthMinorEvent_trap(bytesInMsgQueue, 
                                                msg_queue_minor_threshold);
        }

        bytesInMsgQueue = check_msg_queue_alarm(msg_queue_major_threshold);


        if (bytesInMsgQueue != 0) 
        {
                send_openserMsgQueueDepthMajorEvent_trap(bytesInMsgQueue, 
                                                msg_queue_major_threshold);
        }

        /* Check for Dialog alarm conditions: */

        numActiveDialogs =      check_dialog_alarm(dialog_minor_threshold);

        if (numActiveDialogs != 0)
        {
                send_openserDialogLimitMinorEvent_trap(numActiveDialogs,
                                                dialog_minor_threshold);
        }
        
        numActiveDialogs = check_dialog_alarm(dialog_major_threshold);

        if (numActiveDialogs != 0)
        {
                send_openserDialogLimitMajorEvent_trap(numActiveDialogs,
                                                dialog_major_threshold);
        }
}