Exemple #1
0
  /**
   * {@inheritDoc}
   *
   * <p>The OpenNMS event listener runs this routine when a new event is detected. This can be run
   * on any event but only needs to run on uei.opennms.org/vacuumd/alarmListChanged
   */
  @Override
  public void onEvent(Event event) {
    LOG.debug(
        "Qosd.onEvent: OpenNMS Event Detected by QosD. uei '{}' Dbid(): {}  event.getTime(): {}",
        event.getUei(),
        event.getDbid(),
        event.getTime());

    String s = event.getUei();
    if (s == null) return;

    if (EventConstants.NODE_ADDED_EVENT_UEI.equals(s)
        || EventConstants.NODE_LABEL_CHANGED_EVENT_UEI.equals(s)
        || EventConstants.NODE_DELETED_EVENT_UEI.equals(s)
        || EventConstants.ASSET_INFO_CHANGED_EVENT_UEI.equals(s)) {
      try {
        LOG.debug("QosD.onEvent Event causing update to node list");
        openNMSEventHandlerThread.updateNodeCache();
        return;
      } catch (Exception ex) {
        LOG.error(
            "Qosd.onEvent. Problem calling openNMSEventHandlerThread.updateNodeCache(). Error:",
            ex);
        return;
      }
    }

    if (event.getUei().equals("uei.opennms.org/vacuumd/alarmListChanged")) {
      LOG.debug(
          "QosD.onEvent received 'uei.opennms.org/vacuumd/alarmListChanged' event; Updating alarm list");
    } else {
      // used code from AlarmWriter.java Check value of <logmsg> attribute 'dest', if set to
      // "donotpersist" then simply return, the uei is not to be persisted to the database
      // The uei.opennms.org/vacuumd/alarmListChanged event must be set to be reised
      // as auto-action from vacumd-configuration.xml and is called
      // when vacumd updates the current ( alarm not acknowledgd and cleared ) alarm list
      // note alarmListChanged event may be marked as 'donotpersist' so checked first
      try {
        // this section prints out events received which are not
        // uei.opennms.org/vacuumd/alarmListChanged
        // return if a donotpersist event
        if (event.getLogmsg().getDest().equals("donotpersist")) {
          LOG.debug(
              "QosD.onEvent Ignoring event marked as 'doNotPersist'. Event Uei:{}", event.getUei());
          return;
        }
        // AlarmData should not be null if QoSD-configuration.xml is set up only to receive raise
        // and not clearing alarms
        if (event.getAlarmData().getAlarmType() == 2) {
          LOG.debug(
              "Qosd.onEvent: uei '{}' Dbid(): {} alarm type = 2 (clearing alarm) so ignoring.",
              event.getUei(),
              event.getDbid());
          return;
        }
      } catch (NullPointerException e) {
        LOG.error(
            "Qosd.onEvent: uei '{}' Dbid(): {}' problem dealing with event. Check QoSD-configuration.xml.",
            event.getUei(),
            event.getDbid());
        return;
      }
    }

    // This forces the ossDao to update it's list on this event and call back to sendAlarms() to
    // send the
    // updated alarm list.
    try {
      LOG.debug("QosD.onEvent calling openNMSEventHandlerThread.sendAlarmList() to update list.");
      // ossDao.updateAlarmCacheAndSendAlarms();
      openNMSEventHandlerThread.sendAlarmList();
    } catch (Exception ex) {
      LOG.error(
          "Qosd.onEvent. Problem calling openNMSEventHandlerThread.sendAlarmList(). Error:", ex);
    }
  }
Exemple #2
0
  /** The start() method loads the configuration for the QosD daemon and registers for events */
  @Override
  protected void onStart() {
    String jnp_host;
    // Get a reference to the QosD logger instance assigned by OpenNMS

    LOG.info("Qosd.start(): Preparing to load configuration");

    // set application context for AlarmListConnectionManager
    try {
      LOG.debug(
          "Qosd.start():setting application context for alarmListConnectionManager: m.context.toString:{}",
          m_context.toString());
      alarmListConnectionManager.setApplicationContext(m_context);
    } catch (Exception ex) {
      throw new IllegalArgumentException(
          "Qosd.start(): Error setting spring application context: " + ex);
    }

    // Load the configuration file QosD-Configuration.xml This file contains
    // all the UEIs that will be sent as alarms if useUeiList = true.
    try {
      config = QoSDConfigFactory.getConfig();
      LOG.info("QoSD QoSD-configuration.xml - Configuration Loaded Successfully");

      // loading list of UEI's which trigger this daemon
      triggerUeiList = new Hashtable<String, String>();
      String[] temp = config.getEventlist().getUei();
      for (int i = 0; i < temp.length; i++) triggerUeiList.put(temp[i], "1");

    } catch (MarshalException mrshl_ex) {
      // write an error message to the log file
      LOG.error(
          "Qosd.start(): Marshal Exception thrown whilst getting QoSD configuration\n\t\t\t\tEnsure tags have correct names",
          mrshl_ex);
      throw new UndeclaredThrowableException(mrshl_ex);
    } catch (ValidationException vldtn_ex) {
      LOG.error(
          "Qosd.start(): Validation Exception thrown whilst getting QoSD configuration\n\t\t\t\tMake sure all the tags are formatted correctly within QoSD-configuration.xml",
          vldtn_ex);
      throw new UndeclaredThrowableException(vldtn_ex);
    } catch (IOException io_ex) {
      // Get the OpenNMS home directory
      String configFile = System.getProperty("opennms.home");
      // if there is '/' at the end...
      if (configFile.endsWith(java.io.File.separator)) {
        // ... remove it so that we can compose a valid filename
        configFile = configFile.substring(0, configFile.length() - 1);
      }
      configFile +=
          java.io.File.separator + "etc" + java.io.File.separator + "QoSD-configuration.xml";
      LOG.error(
          "Qosd.start(): Failed to load configuration file: {}\n\t\t\t\tMake sure that it exists",
          configFile,
          io_ex);
      throw new UndeclaredThrowableException(io_ex);
    }

    if (useUeiList)
      LOG.info(
          "Qosd.start(): useUeiList = true = using QoSD QoSD-configuration.xml UEI list selects which alarms are sent");

    try {
      // Load the properties file containing the JNDI connection address etc.
      props = PropertiesLoader.getInstance();
    } catch (FileNotFoundException fnf_ex) {
      // record in log that the properties file could not be found
      String propertiesFilename = System.getProperty("propertiesFile");
      LOG.error("Qosd.start(): Could not find properties file: {}", propertiesFilename, fnf_ex);
      throw new UndeclaredThrowableException(fnf_ex);
    } catch (IOException io_ex) {
      // record in log that the properties file could not be read
      String propertiesFilename = System.getProperty("propertiesFile");
      LOG.error(
          "Qosd.start(): Could not read from properties file: {}\n\t\t\t\tPlease check the file permissions",
          propertiesFilename,
          io_ex);
      throw new UndeclaredThrowableException(io_ex);
    }

    LOG.info("Qosd.start(): QosD Properties File Loaded");

    if (System.getSecurityManager() == null) System.setSecurityManager(new RMISecurityManager());

    /*The following if-statement checks if the naming provider property exists in
     * the properties file. If it does then it stores it in the jnp_host string. If
     * it doesn't then it uses a default naming provider string "jbossjmsserver1:1099" and
     * assigns it to jnp_host, stating this in the log file.
     */
    if (props.getProperty("org.openoss.opennms.spring.qosd.naming.provider") != null) {
      jnp_host = (String) props.getProperty("org.openoss.opennms.spring.qosd.naming.provider");
      LOG.info("Using JNP: {}", jnp_host);
    } else {
      LOG.warn(
          "Qosd.start(): Naming provider property not set, Using default: jnp://jbossjmsserver1:1099");
      jnp_host = "jnp://jbossjmsserver1:1099";
    }

    /* Fill a new properties object with the properties supplied in
     * the properties file.
     */
    env = new Properties();
    env.setProperty("java.naming.provider.url", jnp_host);
    env.setProperty(
        "java.naming.factory.initial",
        props.getProperty("org.openoss.opennms.spring.qosd.naming.contextfactory"));
    env.setProperty(
        "java.naming.factory.url.pkgs",
        props.getProperty("org.openoss.opennms.spring.qosd.naming.pkg"));

    // start a new connection manager thread
    try {
      alarmListConnectionManager.init(props, env);
      alarmListConnectionManager.start();
      // wait until the AlarmListConnectionManager has connected to bean
      LOG.info("Qosd.start(): Waiting Connection Manager Thread to get JMS connection");
      while (alarmListConnectionManager.getStatus() != AlarmListConnectionManager.CONNECTED) ;
      LOG.info("Qosd.start(): Connection Manager Thread JMS connection successfully registered");

      LOG.info("Qosd.start(): openNMS just restarted - sending alarm list rebuilt event");
      // send alarm list rebuilt event to EJB via the connection manager thread.
      alarmListConnectionManager.reset_list(
          "openNMS just restarted - alarm list rebuilt. Time:"
              + new Date()); // send an alarm list rebuilt event
    } catch (Throwable iae) {
      LOG.error("Qosd.start(): Exception caught starting alarmListConnectionManager", iae);
      throw new UndeclaredThrowableException(iae);
    }

    // setting up ossDao to access the OpenNMS database
    try {
      LOG.debug(
          "Qosd.start(): Using ossDao instance: {}",
          (ossDao == null ? "IS NULL" : ossDao.toString()));
      LOG.info("Qosd.start(): Initialising the Node and alarm Caches");
      ossDao.init();
      //	TODO REMOVE
      //			ossDao.updateNodeCaches();
      LOG.info(
          "Qosd.start(): Set up ossDao call back interface to QoSD for forwarding changes to alarm list");
      ossDao.setQoSD(this);
    } catch (Throwable ex) {
      LOG.error("Qosd.start(): Exception caught setting callback interface from ossDao", ex);
      throw new UndeclaredThrowableException(ex);
    }

    // set up thread to handle incoming OpenNMS events
    LOG.info("Qosd.start(): initialising OpenNMSEventHandlerThread");
    try {
      openNMSEventHandlerThread = new OpenNMSEventHandlerThread();
      openNMSEventHandlerThread.setOssDao(ossDao);
      openNMSEventHandlerThread.init();
      openNMSEventHandlerThread.start();
    } catch (Throwable ex) {
      LOG.error("Qosd.start(): Exception caught initialising OpenNMSEventHandlerThread", ex);
      throw new UndeclaredThrowableException(ex);
    }

    // send all the alarmList to EJB via the connection manager thread.
    LOG.info("Qosd.start(): openNMS just restarted - sending all alarms in rebuilt alarm list");
    try {
      // this.sendAlarms(); // interface has just started up. Send all alarms
      openNMSEventHandlerThread.sendAlarmList();
    } catch (Exception e) {
      LOG.error("Qosd.start(): problem sending initial alarm list Error:", e);
    }

    // register listener for OpenNMS events
    LOG.info("Qosd.start(): Starting OpenNMS event listener");
    try {
      registerListener();
    } catch (Exception e) {
      LOG.error("Qosd.start(): problem registering event listener Error:", e);
    }

    // TODO - replace ack handler code with QoSDrx receiver code

    LOG.info("QoSD Started");
  }