eventwriter.java

opennms得相关源码 请大家看看

     * @exception java.sql.SQLException
     *                Thrown if there is an error adding the event to the
     *                database.
     * @exception java.lang.NullPointerException
     *                Thrown if a required resource cannot be found in the
     *                properties file.
     */
    private void add(Header eventHeader, Event event) throws SQLException {
        int eventID = -1;

        Category log = ThreadCategory.getInstance(EventWriter.class);

        // events next id from sequence
        //

        // Execute the statementto get the next event id
        //
        ResultSet rs = m_getNextEventIdStmt.executeQuery();
        rs.next();
        eventID = rs.getInt(1);
        rs.close();
        rs = null;

        if (log.isDebugEnabled())
            log.debug("EventWriter: DBID: " + eventID);

        synchronized (event) {
            event.setDbid(eventID);
        }

        //
        // Set up the sql information now
        //

        // eventID
        m_eventInsStmt.setInt(1, eventID);

        // eventUEI
        m_eventInsStmt.setString(2, Constants.format(event.getUei(), EVENT_UEI_FIELD_SIZE));

        // nodeID
        int nodeid = (int) event.getNodeid();
        set(m_eventInsStmt, 3, event.hasNodeid() ? nodeid : -1);

        // eventTime
        java.sql.Timestamp eventTime = null;
        try {
            java.util.Date date = EventConstants.parseToDate(event.getTime());
            eventTime = new java.sql.Timestamp(date.getTime());
            m_eventInsStmt.setTimestamp(4, eventTime);
        } catch (java.text.ParseException pe) {
            log.warn("Failed to convert time " + event.getTime() + " to java.sql.Timestamp, Setting current time instead", pe);

            eventTime = new java.sql.Timestamp((new java.util.Date()).getTime());
            m_eventInsStmt.setTimestamp(4, eventTime);
        }

        //
        // Resolve the event host to a hostname using
        // the ipinterface table
        //
        String hostname = event.getHost();
        if (hostname != null) {
            try {
                hostname = getHostName(hostname);
            } catch (SQLException sqlE) {
                // hostname can be null - so do nothing
                // use the IP
                hostname = event.getHost();
            }
        }

        // eventHost
        set(m_eventInsStmt, 5, Constants.format(hostname, EVENT_HOST_FIELD_SIZE));

        // ipAddr
        set(m_eventInsStmt, 6, Constants.format(event.getInterface(), EVENT_INTERFACE_FIELD_SIZE));

        // eventDpName
        m_eventInsStmt.setString(7, (eventHeader != null) ? Constants.format(eventHeader.getDpName(), EVENT_DPNAME_FIELD_SIZE) : "undefined");

        // eventSnmpHost
        set(m_eventInsStmt, 8, Constants.format(event.getSnmphost(), EVENT_SNMPHOST_FIELD_SIZE));

        //
        // convert the service name to a service id
        //
        int svcId = -1;
        if (event.getService() != null) {
            try {
                svcId = getServiceID(event.getService());
            } catch (SQLException sqlE) {
                log.warn("EventWriter.add: Error converting service name \"" + event.getService() + "\" to an integer identifier, storing -1", sqlE);
            }
        }

        // service identifier
        set(m_eventInsStmt, 9, svcId);

        // eventSnmp
        if (event.getSnmp() != null)
            m_eventInsStmt.setString(10, SnmpInfo.format(event.getSnmp(), EVENT_SNMP_FIELD_SIZE).replaceAll("\0",""));
        else
            m_eventInsStmt.setNull(10, Types.VARCHAR);

        // eventParms
        set(m_eventInsStmt, 11, (event.getParms() != null) ? Parameter.format(event.getParms()) : null);

		// grab the ifIndex out of the parms if it is defined	
		if (event.getIfIndex() != null) {
			if (event.getParms() != null) {
				Parameter.format(event.getParms());
			}
		}
	

        // eventCreateTime
        java.sql.Timestamp eventCreateTime = new java.sql.Timestamp((new java.util.Date()).getTime());
        m_eventInsStmt.setTimestamp(12, eventCreateTime);

        // eventDescr
        set(m_eventInsStmt, 13, Constants.format(event.getDescr(), EVENT_DESCR_FIELD_SIZE));

        // eventLoggroup
        set(m_eventInsStmt, 14, (event.getLoggroupCount() > 0) ? Constants.format(event.getLoggroup(), EVENT_LOGGRP_FIELD_SIZE) : null);

        // eventLogMsg
        // eventLog
        // eventDisplay
        if (event.getLogmsg() != null) {
            // set log message
            set(m_eventInsStmt, 15, Constants.format(event.getLogmsg().getContent(), EVENT_LOGMSG_FIELD_SIZE));
            String logdest = event.getLogmsg().getDest();
            // if 'logndisplay' set both log and display
            // column to yes
            if (logdest.equals("logndisplay")) {
                set(m_eventInsStmt, 16, MSG_YES);
                set(m_eventInsStmt, 17, MSG_YES);
            }
            // if 'logonly' set log column to true
            else if (logdest.equals("logonly")) {
                set(m_eventInsStmt, 16, MSG_YES);
                set(m_eventInsStmt, 17, MSG_NO);
            }
            // if 'displayonly' set display column to true
            else if (logdest.equals("displayonly")) {
                set(m_eventInsStmt, 16, MSG_NO);
                set(m_eventInsStmt, 17, MSG_YES);
            }
            // if 'suppress' set both log and display to false
            else if (logdest.equals("suppress")) {
                set(m_eventInsStmt, 16, MSG_NO);
                set(m_eventInsStmt, 17, MSG_NO);
            }
        } else {
            m_eventInsStmt.setNull(15, Types.VARCHAR);

            // If this is an event that had no match in the event conf
            // mark it as to be logged and displayed so that there
            // are no events that slip through the system
            // without the user knowing about them

            set(m_eventInsStmt, 16, MSG_YES);
            set(m_eventInsStmt, 17, MSG_YES);
        }

        // eventSeverity
        set(m_eventInsStmt, 18, Constants.getSeverity(event.getSeverity()));

        // eventPathOutage
        set(m_eventInsStmt, 19, (event.getPathoutage() != null) ? Constants.format(event.getPathoutage(), EVENT_PATHOUTAGE_FIELD_SIZE) : null);

        // eventCorrelation
        set(m_eventInsStmt, 20, (event.getCorrelation() != null) ? org.opennms.netmgt.eventd.db.Correlation.format(event.getCorrelation(), EVENT_CORRELATION_FIELD_SIZE) : null);

        // eventSuppressedCount
        m_eventInsStmt.setNull(21, Types.INTEGER);

        // eventOperInstruct
        set(m_eventInsStmt, 22, Constants.format(event.getOperinstruct(), EVENT_OPERINSTRUCT_FIELD_SIZE));

        // eventAutoAction
        set(m_eventInsStmt, 23, (event.getAutoactionCount() > 0) ? AutoAction.format(event.getAutoaction(), EVENT_AUTOACTION_FIELD_SIZE) : null);

        // eventOperAction / eventOperActionMenuText
        if (event.getOperactionCount() > 0) {
            List a = new ArrayList();
            List b = new ArrayList();

            Enumeration en = event.enumerateOperaction();
            while (en.hasMoreElements()) {
                Operaction eoa = (Operaction) en.nextElement();
                a.add(eoa);
                b.add(eoa.getMenutext());
            }

            set(m_eventInsStmt, 24, OperatorAction.format(a, EVENT_OPERACTION_FIELD_SIZE));
            set(m_eventInsStmt, 25, Constants.format(b, EVENT_OPERACTION_MENU_FIELD_SIZE));
        } else {
            m_eventInsStmt.setNull(24, Types.VARCHAR);
            m_eventInsStmt.setNull(25, Types.VARCHAR);
        }

        // eventNotification, this column no longer needed
        m_eventInsStmt.setNull(26, Types.VARCHAR);

        // eventTroubleTicket / eventTroubleTicket state
        if (event.getTticket() != null) {
            set(m_eventInsStmt, 27, Constants.format(event.getTticket().getContent(), EVENT_TTICKET_FIELD_SIZE));
            int ttstate = 0;
            if (event.getTticket().getState().equals("on"))
                ttstate = 1;

            set(m_eventInsStmt, 28, ttstate);
        } else {
            m_eventInsStmt.setNull(27, Types.VARCHAR);
            m_eventInsStmt.setNull(28, Types.INTEGER);
        }

        // eventForward
        set(m_eventInsStmt, 29, (event.getForwardCount() > 0) ? org.opennms.netmgt.eventd.db.Forward.format(event.getForward(), EVENT_FORWARD_FIELD_SIZE) : null);

        // event mouseOverText
        set(m_eventInsStmt, 30, Constants.format(event.getMouseovertext(), EVENT_MOUSEOVERTEXT_FIELD_SIZE));

        // eventAckUser
        if (event.getAutoacknowledge() != null && event.getAutoacknowledge().getState().equals("on")) {

            set(m_eventInsStmt, 31, Constants.format(event.getAutoacknowledge().getContent(), EVENT_ACKUSER_FIELD_SIZE));

            // eventAckTime - if autoacknowledge is present,
            // set time to event create time
            set(m_eventInsStmt, 32, eventCreateTime);
        } else {
            m_eventInsStmt.setNull(31, Types.INTEGER);
            m_eventInsStmt.setNull(32, Types.TIMESTAMP);
        }

        // eventSource
        set(m_eventInsStmt, 33, Constants.format(event.getSource(), EVENT_SOURCE_FIELD_SIZE));
		
        // execute
        m_eventInsStmt.executeUpdate();

        if (log.isDebugEnabled())
            log.debug("SUCCESSFULLY added " + event.getUei() + " related  data into the EVENTS table");
    }

    /**
     * Constructor
     */
    public EventWriter(String getNextEventIdStr) throws SQLException {
        // Get a database connection
        //
        m_dbConn = null;
        try {
            DatabaseConnectionFactory.init();
            m_dbConn = DatabaseConnectionFactory.getInstance().getConnection();
        } catch (MarshalException me) {
            ThreadCategory.getInstance(EventWriter.class).fatal("Marshall Exception getting database connection", me);
            throw new UndeclaredThrowableException(me);
        } catch (ValidationException ve) {
            ThreadCategory.getInstance(EventWriter.class).fatal("Validation Exception getting database connection", ve);
            throw new UndeclaredThrowableException(ve);
        } catch (ClassNotFoundException cnfE) {
            ThreadCategory.getInstance(EventWriter.class).fatal("Driver Class Not Found Exception getting database connection", cnfE);
            throw new UndeclaredThrowableException(cnfE);
        } catch (IOException ioE) {
            ThreadCategory.getInstance(EventWriter.class).fatal("IO Exception getting database connection", ioE);
            throw new UndeclaredThrowableException(ioE);
        }

        //
        // prepare the SQL statement
        //
        m_getSvcIdStmt = m_dbConn.prepareStatement(EventdConstants.SQL_DB_SVCNAME_TO_SVCID);
        m_getHostNameStmt = m_dbConn.prepareStatement(EventdConstants.SQL_DB_HOSTIP_TO_HOSTNAME);
        m_getNextEventIdStmt = m_dbConn.prepareStatement(getNextEventIdStr);
        m_eventInsStmt = m_dbConn.prepareStatement(EventdConstants.SQL_DB_INS_EVENT);
        // set the database for rollback support
        //
        try {
            m_dbConn.setAutoCommit(false);
        } catch (SQLException se) {
            ThreadCategory.getInstance(EventWriter.class).warn("Unable to set auto commit mode");
        }
    }

    /**
     * Close all the prepared statements
     */
    public void close() {
        try {
            m_getSvcIdStmt.close();
            m_getHostNameStmt.close();
            m_getNextEventIdStmt.close();
            m_eventInsStmt.close();
        } catch (SQLException sqle) {
            ThreadCategory.getInstance(EventWriter.class).warn("SQLException while closing prepared statements", sqle);
        } finally {
            try {
                m_dbConn.close();
            } catch (SQLException e) {
                ThreadCategory.getInstance(EventWriter.class).warn("SQLException while closing database connection", e);
            }
        }
    }

    /**
     * The method that inserts the event into the database
     * 
     * @param eventHeader
     *            the event header
     * @param event
     *            the actual event to be inserted
     */
    public void persistEvent(Header eventHeader, Event event) throws SQLException {
        if (event != null) {
            Category log = ThreadCategory.getInstance(EventWriter.class);

            // Check value of <logmsg> attribute 'dest', if set to
            // "donotpersist" then simply return, the uei is not to be
            // persisted to the database
            String logdest = event.getLogmsg().getDest();
            if (logdest.equals("donotpersist")) {
                log.debug("EventWriter: uei '" + event.getUei() + "' marked as 'doNotPersist'.");
                return;
            } else {
                if (log.isDebugEnabled()) {
                    log.debug("EventWriter dbRun for : " + event.getUei() + " nodeid: " + event.getNodeid() + " ipaddr: " + event.getInterface() + " serviceid: " + event.getService());
                }
            }

            try {
                add(eventHeader, event);

                // commit
                m_dbConn.commit();
            } catch (SQLException e) {
                log.warn("Error inserting event into the datastore", e);
                try {
                    m_dbConn.rollback();
                } catch (Exception e2) {
                    log.warn("Rollback of transaction failed!", e2);
                }

                throw e;
            }

            if (log.isDebugEnabled())
                log.debug("EventWriter finished for : " + event.getUei());
        }
    }
}