/**
   * This method maps OpenNMS alarm to an OSS/J alarms and adds additional information
   *
   * @param _openNMSalarm data to use to populate the OSS/J alarm
   * @param alarmValueSpecification AlarmValue object to be populated - Invariant (Specifcation)
   *     values should be already populated
   * @return the _av OSS/J AlarmValue populated with opennms data
   * @throws java.lang.IllegalArgumentException if any.
   * @throws javax.oss.UnsupportedAttributeException if any.
   */
  public AlarmValue populateOssjAlarmFromOpenNMSAlarm(
      AlarmValue alarmValueSpecification, OnmsAlarm _openNMSalarm)
      throws IllegalArgumentException, UnsupportedAttributeException {
    ThreadCategory log = getLog();
    String logheader =
        "\t\t" + this.getClass().getSimpleName() + "populateOssjAlarmFromOpenNMSAlarm():";

    // Node node = null;
    OnmsNode node = null;

    // Asset asset = null;
    OnmsAssetRecord asset = null;

    boolean isQoSDrxAlarm = false; // true if alarm is received from Qosdrx

    if (log.isDebugEnabled()) log.debug(logheader + ": Populating alarm");

    // test to see if opennms alarm already has type and instance information set. If yes then it
    // has most likely
    // come from Qosdrx.
    if ((_openNMSalarm.getManagedObjectInstance() != null)
        && (_openNMSalarm.getManagedObjectType() != null)
        && (!_openNMSalarm.getManagedObjectInstance().equals(""))
        && (!_openNMSalarm.getManagedObjectType().equals(""))) {
      isQoSDrxAlarm = true;
      if (log.isDebugEnabled())
        log.debug(
            logheader
                + ": isQoSDrxAlarm TRUE - because OpenNMS alarm has ManagedObjectInstance and ManagedObjectType");
    } else {
      isQoSDrxAlarm = false;
      if (log.isDebugEnabled())
        log.debug(
            logheader
                + ": isQoSDrxAlarm FALSE - because OpenNMS alarm NOT POPULATED ManagedObjectInstance and ManagedObjectType");
    }

    try {
      // If the alarm has both an acknowledge time and an acknowledge user
      // then the alarm has been acknowledged. Set the corrsponding parameters
      // in the OSS/J alarm
      if ((null != _openNMSalarm.getAlarmAckTime()) && (null != _openNMSalarm.getAlarmAckUser())) {
        alarmValueSpecification.setAckUserId(_openNMSalarm.getAlarmAckUser());
        // OnmsAlarm can contain java.sql.Timestamp - convert to Date
        alarmValueSpecification.setAckTime(new Date(_openNMSalarm.getAlarmAckTime().getTime()));
        alarmValueSpecification.setAlarmAckState(AlarmAckState.ACKNOWLEDGED);
      } else {
        alarmValueSpecification.setAlarmAckState(AlarmAckState.UNACKNOWLEDGED);
      }

      // if the alarm is cleared, then set the alarm cleared time
      // to that of the lasteventtime as this must be the time
      // the clear occured.
      if (_openNMSalarm.getSeverity() == OnmsSeverity.CLEARED) {
        // OnmsAlarm can contain java.sql.Timestamp - convert to Date
        alarmValueSpecification.setAlarmClearedTime(
            new Date(_openNMSalarm.getLastEventTime().getTime()));
      } else {
        alarmValueSpecification.setAlarmClearedTime(null);
      }

      // Set the alarmRaisedTime to the FirstEventTime of the OpenNMS
      // alarm. Set the alarm changed time to the last event time.
      // OnmsAlarm can contain java.sql.Timestamp - convert to Date
      if (null != _openNMSalarm.getFirstEventTime()) {
        alarmValueSpecification.setAlarmRaisedTime(
            new Date(_openNMSalarm.getFirstEventTime().getTime()));
      }
      if (null != _openNMSalarm.getLastEventTime()) {
        alarmValueSpecification.setAlarmChangedTime(
            new Date(_openNMSalarm.getLastEventTime().getTime()));
      }

    } catch (Throwable e) {
      log.error(logheader + ": Problem getting ACK time information", e);
    }

    Matcher matcher = null;
    String _uei_no_html = "NOT_SET";
    try {
      String uei = _openNMSalarm.getUei();
      if (null != uei) {
        matcher = p.matcher(uei);
        _uei_no_html = matcher.replaceAll(" "); // remove any HTML tags from uei
      }
      alarmValueSpecification.setAlarmType(
          (_openNMSalarm.getX733AlarmType() == null)
              ? javax.oss.fm.monitor.AlarmType.EQUIPMENT_ALARM
              : _openNMSalarm.getX733AlarmType());
    } catch (Throwable e) {
      log.error(logheader + ": Problem getting  X733AlarmType or Uei", e);
    }

    // Get some local node information as to where the alarm came from
    // This includes, what type of managed element the node is
    // and what its node id and label are.*/
    //		String mftr = "NOT_SET"; // FIXME: Not read
    //		String modelNo = "NOT_SET"; // FIXME: Not read
    //		String assetserno = "NOT_SET"; // FIXME: Not read
    //		String nodelabel = "NOT_SET"; // FIXME: Not read
    //		String alarmIP = "NOT_SET"; // FIXME: Not read
    String managedObjectType = "NOT_SET";
    String managedObjectInstance = "NOT_SET";
    String assetManagedObjectType = "NOT_SET";
    String assetManagedObjectInstance = "NOT_SET";

    String assetDescription = "NOT_SET";
    String assetAddress2 = "NOT_SET";

    if (!isQoSDrxAlarm) { // if is locally generated alarm
      try {
        // some opennms alarms don't have node information
        // set default values if no node information present
        if (_openNMSalarm.getNode() != null) {
          node = ossDao.findNodeByID(_openNMSalarm.getNode().getId());

          asset = node.getAssetRecord();

          //					alarmIP = _openNMSalarm.getIpAddr(); // Not read
          //					if (node != null) {
          //					nodelabel = node.getLabel(); // Not read
          //					}
          if (asset != null) {
            //						if (asset.getManufacturer()!= null) mftr = asset.getManufacturer(); // Not read
            //						if (asset.getModelNumber()!= null) modelNo = asset.getModelNumber(); // Not read
            //						if (asset.getSerialNumber()!= null) assetserno = asset.getSerialNumber(); // Not
            // read
            if (asset.getDescription() != null)
              assetDescription =
                  asset.getDescription(); // TODO was used for managed object class as is 128 char
            // long
            if (asset.getAddress2() != null)
              assetAddress2 =
                  asset.getAddress2(); // TODO was used for managed object instance - as is 256 char
            // long string
            if (asset.getManagedObjectInstance() != null)
              assetManagedObjectInstance = asset.getManagedObjectInstance();
            if (asset.getManagedObjectType() != null)
              assetManagedObjectType = asset.getManagedObjectType();
          }

          managedObjectInstance = assetManagedObjectInstance;
          managedObjectType = assetManagedObjectType;

          if (log.isDebugEnabled())
            log.debug(
                logheader
                    + ": isQoSDrxAlarm=FALSE  OpenNMS type and instance not set. Using from Node Asset record: ManagedObjectInstance: "
                    + managedObjectInstance
                    + " ManagedObjectType:"
                    + managedObjectType);
        }
      } catch (Throwable ex) {
        log.error(logheader + ": Problem getting node and asset information", ex);
      }
    } else { // is a received alarm
      try {
        managedObjectInstance = _openNMSalarm.getManagedObjectInstance();
        managedObjectType = _openNMSalarm.getManagedObjectType();

        if (log.isDebugEnabled())
          log.debug(
              logheader
                  + ": isQoSDrxAlarm=TRUE  OpenNMS type and instance set. Using from OnmsAlarm: ManagedObjectInstance: "
                  + managedObjectInstance
                  + " ManagedObjectType:"
                  + managedObjectType);
      } catch (Throwable ex) {
        log.error(logheader + ": Problem managedObjectInstance or managedObjectType", ex);
      }
    }

    alarmValueSpecification.setManagedObjectClass(managedObjectType);
    if (log.isDebugEnabled())
      log.debug(logheader + ": _av.setManagedObjectClass set to: " + managedObjectType);

    alarmValueSpecification.setManagedObjectInstance(managedObjectInstance);
    if (log.isDebugEnabled())
      log.debug(logheader + ": _av.setManagedObjectInstance set to: " + managedObjectInstance);

    // set severity and probable cause
    try {
      alarmValueSpecification.setPerceivedSeverity(
          onmsSeverityToOssjSeverity(_openNMSalarm.getSeverity()));

      //			alarmValueSpecification.setProbableCause((short)-1); // OSS/J set to -1  then text
      // contains description
      alarmValueSpecification.setProbableCause((short) _openNMSalarm.getX733ProbableCause());

    } catch (Throwable e) {
      log.error(logheader + ": Problem getting severity or probable cause: ", e);
    }

    if (!isQoSDrxAlarm) { // if is a locally generated alarm

      try {
        String _opinstr = _openNMSalarm.getOperInstruct();
        if (null != _opinstr) {
          matcher = p.matcher(_opinstr);
          _opinstr = matcher.replaceAll(" "); // remove all HTML tags from operator instructions
        } else _opinstr = "NOT_SET";
        alarmValueSpecification.setProposedRepairActions(_opinstr);

        String _logmsg = _openNMSalarm.getLogMsg();
        if (null != _logmsg) {
          matcher = p.matcher(_logmsg);
          _logmsg = matcher.replaceAll(" "); // remove all HTML tags from operator instructions
        } else _logmsg = "NOT_SET";

        String _description = _openNMSalarm.getDescription();
        if (null != _description) {
          matcher = p.matcher(_description);
          _description = matcher.replaceAll(" "); // remove all HTML tags from description
        } else _description = "NOT_SET";

        // using manufacturers own definition of specific problem here ( OSS/J )
        alarmValueSpecification.setSpecificProblem(_logmsg);
        Integer alarmid = _openNMSalarm.getId();
        Integer counter = _openNMSalarm.getCounter();
        String reductionkey = _openNMSalarm.getReductionKey();

        // note some OnmsAlarms can have null nodes - we use a default value of 0 for ID
        Integer nodeid = 0;
        String onmsnodelabel = "";
        if (_openNMSalarm.getNode() != null) {
          nodeid = _openNMSalarm.getNode().getId();
          onmsnodelabel = _openNMSalarm.getNode().getLabel();
        }
        InetAddress ipaddress = _openNMSalarm.getIpAddr();
        String x733AlarmType = _openNMSalarm.getX733AlarmType();
        String x733ProbableCause;
        try {
          x733ProbableCause =
              OOSSProbableCause.getStringforEnum((short) _openNMSalarm.getX733ProbableCause());
        } catch (Throwable e) {
          x733ProbableCause = "X733 Probable Cause Incorrectly Defined";
        }

        alarmValueSpecification.setAdditionalText(
            "<alarmid>"
                + alarmid
                + "</alarmid>"
                + "\n            "
                + "<logmsg>"
                + _logmsg
                + "</logmsg>"
                + "\n            "
                + "<uei>"
                + _uei_no_html
                + "<uei>"
                + "\n            "
                + "<x733AlarmType>"
                + x733AlarmType
                + "</x733AlarmType>"
                + "\n            "
                + "<x733ProbableCause>"
                + x733ProbableCause
                + "</x733ProbableCause>"
                + "\n            "
                + "<counter>"
                + counter
                + "</counter>"
                + "\n            "
                + "<reductionkey>"
                + reductionkey
                + "</reductionkey>"
                + "\n            "
                + "<nodeid>"
                + nodeid
                + "</nodeid>"
                + "\n            "
                + "<nodelabel>"
                + onmsnodelabel
                + "</nodelabel>"
                + "\n            "
                + "<ipaddress>"
                + InetAddressUtils.toIpAddrString(ipaddress)
                + "</ipaddress>"
                + "\n            "
                + "<description>"
                + _description
                + "</description>"
                + "\n            "
                + "<opinstr>"
                + _opinstr
                + "</opinstr>"
                + "\n            "
                + "<asset.managedobjectinstance>"
                + assetManagedObjectInstance
                + "</asset.managedobjectinstance>"
                + "\n            "
                + // TODO - was used for object instance
                "<asset.managedobjecttype>"
                + assetManagedObjectType
                + "</asset.managedobjecttype>"
                + "\n            "
                + "<asset.address2>"
                + assetAddress2
                + "</asset.address2>"
                + "\n            "
                + // TODO - was used for object instance
                "<asset.description>"
                + assetDescription
                + "</asset.description>"
                + "\n"); // TODO - was used for object instancetype

      } catch (Throwable e) {
        log.error(
            logheader + ": Problem setting description, logmessage or operator instrctions: ", e);
      }

    } else { // is a received alarm
      try {
        String _opinstr = _openNMSalarm.getOperInstruct();
        if (null == _opinstr) _opinstr = "NOT_SET";
        alarmValueSpecification.setProposedRepairActions(_opinstr);

        String _logmsg = _openNMSalarm.getLogMsg();
        if (null == _logmsg) _logmsg = "NOT_SET";
        // using manufacturers own definition of specific problem here ( OSS/J )
        alarmValueSpecification.setSpecificProblem(_logmsg);

        String _description = _openNMSalarm.getDescription();
        if (null == _description) _description = "NOT_SET";
        alarmValueSpecification.setAdditionalText(_description);

      } catch (Throwable e) {
        log.error(
            logheader + ": Problem setting description, logmessage or operator instrctions: ", e);
      }
    }

    // TODO replacement method to populate the alarm key
    try {
      // populate alarm key
      // TODO was AlarmKey ak = new OOSSAlarmKey(Integer.toString(_openNMSalarm.getId()));
      AlarmKey ak = alarmValueSpecification.getAlarmKey();
      ak.setAlarmPrimaryKey(Integer.toString(_openNMSalarm.getId()));
      ak.setPrimaryKey(ak.getAlarmPrimaryKey());
    } catch (Throwable e) {
      log.error(logheader + ": Problem setting AlarmKey: ", e);
    }

    if (log.isDebugEnabled()) log.debug(logheader + ": Alarm Populated");

    return alarmValueSpecification;
  } // end populateAlarm()
Exemple #2
0
  /**
   * A method to request an alarm list from the OpenNMS database using the ossDao, convert them to
   * OSS/J alarms using the onmsAlarmOssjMapper and send the OSS/J alarms using the alarm list
   * connection manager (alcm) to update the the AlarmMonitor bean. This is called from ossDao every
   * time there is an update to the database.
   */
  @Override
  public void sendAlarms() {
    Hashtable<AlarmKey, AlarmValue> ossjAlarmUpdateList = new Hashtable<AlarmKey, AlarmValue>();
    OnmsAlarm[] onmsAlarmUpdateList = null;
    AlarmValue ossjAlarm;

    try {
      LOG.debug("sendAlarms() using ossDao to get current alarm list");
      onmsAlarmUpdateList = ossDao.getAlarmCache();
    } catch (Throwable ex) {
      // problems contacting the PostgreSQL database
      LOG.error("sendAlarms() Cannot retrieve alarms from ossDao.getAlarmCache()", ex);
      throw new UndeclaredThrowableException(
          ex, "sendAlarms() Cannot retrieve alarms from ossDao.getAlarmCache()");
    }

    LOG.debug("sendAlarms() Alarms fetched. Processing each alarm in list.");
    // Convert the OnmsAlarm array alarmBuf to a hashtable using the alarmid as the key.
    try {
      for (int i = 0; i < onmsAlarmUpdateList.length; i++) {
        LOG.debug("sendAlarms() processing an OpenNMS alarm:");

        // if useUeiList is true only the alarms whose UEI's are listed in the
        // QosD-configuration.xml file will be included in the list.
        if (useUeiList) {
          LOG.debug("sendAlarms() useUeiList= true: using UeiList to determine alarms to send");
          if (null == triggerUeiList.get(onmsAlarmUpdateList[i].getUei())) {
            LOG.debug(
                "sendAlarms() alarm UEI not in QosD-configuration.xml. Not sending. alarmID:{} alarmUEI:{}",
                onmsAlarmUpdateList[i].getId(),
                onmsAlarmUpdateList[i].getUei());
            continue; // ignore this event and return
          }
          LOG.debug(
              "sendAlarms() alarm UEI is in QosD-configuration.xml. Trying to send alarmID:{} alarmUEI:{}",
              onmsAlarmUpdateList[i].getId(),
              onmsAlarmUpdateList[i].getUei());
        }

        if (onmsAlarmUpdateList[i].getAlarmType() != 1) {
          LOG.debug(
              "sendAlarms() Alarm AlarmType !=1 ( not raise alarm ) Not sending alarmID:{} :alarmBuf[i].getQosAlarmState()=: {}",
              onmsAlarmUpdateList[i].getId(),
              onmsAlarmUpdateList[i].getQosAlarmState());
          continue;
        } else {
          LOG.debug(
              "sendAlarms() Alarm AlarmType==1 ( raise alarm ) Sending alarmID:{} :alarmBuf[i].getQosAlarmState()=: {}",
              onmsAlarmUpdateList[i].getId(),
              onmsAlarmUpdateList[i].getQosAlarmState());
          try {

            // Code which creates the OSSJ AlarmValue from the Spring OSS?J AlarmValue Specification
            LOG.debug("sendAlarms(): generating the OSS/J alarm specification:");
            ossjAlarm = alarmListConnectionManager.makeAlarmValueFromSpec();
            LOG.debug(
                "sendAlarms(): OSS/J alarm specification:{}",
                OOSSAlarmValue.converttoString(ossjAlarm));

            // Code which creates the OSSJ AlarmValue from the Spring OSS/J AlarmValue Specification
            LOG.debug("sendAlarms(): onmsAlarmOssjMapper.populateOssjAlarmFromOpenNMSAlarm:");
            ossjAlarm =
                onmsAlarmOssjMapper.populateOssjAlarmFromOpenNMSAlarm(
                    ossjAlarm, onmsAlarmUpdateList[i]);
            LOG.debug(
                "buildList(): alarm specifcation: {}", OOSSAlarmValue.converttoString(ossjAlarm));

            // TODO selector on ACKNOWLEDGED and CLEARED - currently always sends all alarms in list
            if (true)
              try {
                // alarms which are ACKNOWLEDGED and CLEARED are included in this current alarm list
                LOG.debug(
                    "sendAlarms() including ACKNOWLEDGED and CLEARED alarms in alarm in list");
                ossjAlarmUpdateList.put(ossjAlarm.getAlarmKey(), ossjAlarm);
              } catch (Throwable e) {
                LOG.error("sendAlarms() error putting alarm in alarmList", e);
              }

            // TODO - THIS CODE NEVER RUN
            /*
            else try {
            	// no alarms which are ACKNOWLEDGED and CLEARED are included in this current alarm list
            	if (ossjAlarm.getAlarmAckState() == javax.oss.fm.monitor.AlarmAckState.UNACKNOWLEDGED ) {
            		ossjAlarmUpdateList.put(ossjAlarm.getAlarmKey(), ossjAlarm); // put all unacknowledged alarms in list
            	}
            	else if (ossjAlarm.getPerceivedSeverity() != javax.oss.fm.monitor.PerceivedSeverity.CLEARED ){
            		ossjAlarmUpdateList.put(ossjAlarm.getAlarmKey(), ossjAlarm);	// put all uncleared acknowledged alarms in list
            	}
            } catch (Throwable e) {
            	log.error("sendAlarms() error in alarmACKState or PercievedSeverity - check alarm definitons", e);
            }*/
          } catch (Throwable ex) {
            LOG.error(
                "sendAlarms() error trying to populate alarm - alarm disguarded - check alarm definitons",
                ex);
          }
        }
      }
    } catch (Throwable ex) {
      LOG.error("Qosd.sendAlarms(): Problem when building alarm list:", ex);
      throw new UndeclaredThrowableException(
          ex, "Qosd.sendAlarms(): Problem when building alarm list");
    }
    try {
      // debug code prints out alarm list to be sent if enabled
      if (LOG.isDebugEnabled()) {
        LOG.debug("QosD sendAlarms() - Alarm list built:");
        LOG.debug("QosD sendAlarms() - ******* Alarm List to be sent : primary keys");
        for (Entry<AlarmKey, AlarmValue> entry : ossjAlarmUpdateList.entrySet()) {
          LOG.debug(
              "QosD sendAlarms() key:{}  AlarmValue.getAlarmChangedTime: {}",
              entry.getKey().getPrimaryKey(),
              entry.getValue().getAlarmChangedTime());
        }
        LOG.debug("QosD sendAlarms() - ******* END OF LIST");
        LOG.debug("QosD sendAlarms() Sending alarm list to bean");
      }
      // send the alarmList to Ossbeans EJB or local runner via the connection manager thread.

      alarmListConnectionManager.send(ossjAlarmUpdateList);
    } catch (Throwable ex) {
      LOG.error("Qosd.sendAlarms(): Problem when sending alarm list:", ex);
      throw new UndeclaredThrowableException(
          ex, "Qosd.sendAlarms(): Problem when sending alarm list");
    }
  }
  /**
   * This method maps an OSS/J AlarmValue to OpenNMS alarm
   *
   * @param onmsAlarm OnmsAlarm object to be populated
   * @param alarmValue OSS/J AlarmValue data to use to populate OnmsAlarm
   * @param almUpdateBehaviour - determines how to treat the node name of the new alarm must be of
   *     value; <code>USE_TYPE_INSTANCE</code> - populate nodeID with node having same asset type
   *     and instance data as alarm or <code>SPECIFY_OUTSTATION</code> - populate nodeID with node
   *     having same nodeLabel as defaultUpdateNodeLabel
   * @param defaultUpdateNodeLabel name of node to be updated if
   *     almUpdateBehaviour==SPECIFY_OUTSTATION
   * @return the OnmsAlarm populated with OSS/J NotifyNewAlarmEvent data
   * @throws java.lang.IllegalArgumentException if any.
   * @throws javax.oss.UnsupportedAttributeException if any.
   */
  public OnmsAlarm populateOnmsAlarmFromOssjAlarm(
      OnmsAlarm onmsAlarm,
      AlarmValue alarmValue,
      Integer almUpdateBehaviour,
      String defaultUpdateNodeLabel)
      throws IllegalArgumentException, UnsupportedAttributeException {
    ThreadCategory log = getLog();
    String logheader =
        "\t\t" + this.getClass().getSimpleName() + "populateOnmsAlarmFromOssjAlarm():";

    try {
      String ossPrimaryKey = alarmValue.getAlarmKey().getAlarmPrimaryKey();
      String applicationDN = alarmValue.getAlarmKey().getApplicationDN();
      if (log.isDebugEnabled())
        log.debug(
            logheader
                + " - AlarmPrimaryKey: "
                + ossPrimaryKey
                + " ApplictionDN: "
                + applicationDN
                + " alarmRaisedTime: "
                + alarmValue.getAlarmRaisedTime());
      if ((applicationDN == null)
          || (applicationDN.equals(""))
          || (ossPrimaryKey == null)
          || (ossPrimaryKey.equals(""))) {
        log.error(logheader + " ApplicatioDN or PrimaryKey not set");
      } else {
        if (log.isDebugEnabled())
          log.debug(
              logheader + ": trying to find existing alarm using getCurrentAlarmForUniqueKey");

        onmsAlarm = ossDao.getCurrentAlarmForUniqueKey(applicationDN, ossPrimaryKey);
        if (onmsAlarm != null) { // already an alarm with this unique id - log error
          log.error(logheader + " Alarm Already exists with this Unique ID");
        } else {
          onmsAlarm = new OnmsAlarm();

          onmsAlarm.setUei(ossjAlarmTypeToUei(alarmValue.getAlarmType()));
          onmsAlarm.setX733AlarmType(
              (alarmValue.getAlarmType() == null) ? "" : alarmValue.getAlarmType());
          onmsAlarm.setX733ProbableCause(alarmValue.getProbableCause());

          onmsAlarm.setTTicketState(null); // needed?
          onmsAlarm.setTTicketId(""); // needed?
          onmsAlarm.setQosAlarmState("");
          onmsAlarm.setSuppressedUser(""); // needed?
          onmsAlarm.setSuppressedUntil(new Date()); // needed?
          onmsAlarm.setSuppressedTime(new Date()); // needed?

          OnmsSeverity onmsseverity;
          try {
            onmsseverity = ossjSeveritytoOnmsSeverity(alarmValue.getPerceivedSeverity());
          } catch (IllegalArgumentException iae) {
            log.error(
                logheader + " problem setting severity used default:'WARNING'. Exception:" + iae);
            onmsseverity = OnmsSeverity.WARNING;
          }
          onmsAlarm.setSeverity(onmsseverity);

          OnmsServiceType service = new OnmsServiceType();
          service.setId(new Integer(-1));
          onmsAlarm.setServiceType(new OnmsServiceType()); // needed?

          onmsAlarm.setReductionKey(
              ":managedObjectInstance:"
                  + alarmValue.getManagedObjectInstance()
                  + ":managedObjectType:"
                  + alarmValue.getManagedObjectClass()
                  + ":ossPrimaryKey:-"
                  + ossPrimaryKey
                  + ":applicationDN:-"
                  + applicationDN); // must be unique because of alarm_reductionkey_idx

          onmsAlarm.setOssPrimaryKey(ossPrimaryKey);
          onmsAlarm.setOperInstruct(alarmValue.getProposedRepairActions());

          // defaultvalue if search fails - will update node with ID 1
          OnmsNode node = new OnmsNode(); // TODO remove ossDao.makeExtendedOnmsNode();
          node.setId(new Integer(1)); // node id cannot be null
          onmsAlarm.setNode(node); //

          if (almUpdateBehaviour == null) {
            log.error(
                logheader
                    + ": This receiver's alarmUpdateBehaviour is not set: defaulting to update nodeID:1");
          } else {
            if (log.isDebugEnabled())
              log.debug(
                  logheader
                      + " alarmUpdateBehaviour:"
                      + almUpdateBehaviour
                      + " "
                      + getAlarmUpdateBehaviourForInt(almUpdateBehaviour));

            if (almUpdateBehaviour.equals(SPECIFY_OUTSTATION)) {
              // this will look for first match of node label to callingAer.getName()
              // and set node id to this value.

              if (log.isDebugEnabled())
                log.debug(
                    logheader
                        + " SPECIFY_OUTSTATION looking for node with nodelabel:"
                        + defaultUpdateNodeLabel);
              try {
                // TODO temp remove ?
                try {
                  node = ossDao.findNodeByLabel(defaultUpdateNodeLabel);
                } catch (Throwable ex) {
                  log.error(
                      logheader
                          + " alarmUpdateBehaviour.equals(USE_TYPE_INSTANCE) Problem looking up Node "
                          + ex);
                }

                if (node != null) {
                  if (log.isDebugEnabled())
                    log.debug(
                        logheader
                            + " alarmUpdateBehaviour.equals(SPECIFY_OUTSTATION):"
                            + "NODE FOUND for this name:"
                            + defaultUpdateNodeLabel
                            + " setting node id to NodeLabel:"
                            + node.getLabel()
                            + " NodeID:"
                            + node.getId());
                  onmsAlarm.setNode(
                      node); // maps into FIRST instance of node with the same managedObjectInstance
                  // and managedObjectType
                } else {
                  log.error(
                      logheader
                          + " alarmUpdateBehaviour.equals(SPECIFY_OUTSTATION):"
                          + "NODE NOT FOUND for this name:"
                          + defaultUpdateNodeLabel
                          + " setting node id to default NodeID: 1");
                  node = new OnmsNode(); // TODO remove ossDao.makeExtendedOnmsNode();
                  node.setId(new Integer(1)); // node id cannot be null
                  onmsAlarm.setNode(node); //
                }
              } catch (Throwable ex) {
                log.error(
                    logheader
                        + " alarmUpdateBehaviour.equals(USE_TYPE_INSTANCE) Problem looking up Node for alarm Set to default nodeID:1"
                        + ex);
              }

            } else if (almUpdateBehaviour.equals(USE_TYPE_INSTANCE)) {
              // this will look for first match of node Managed object Instance and Managed Object
              // type
              // and set node id to this value.
              String managedObjectType = alarmValue.getManagedObjectClass();
              String managedObjectInstance = alarmValue.getManagedObjectInstance();

              if (log.isDebugEnabled())
                log.debug(
                    logheader
                        + " USE_TYPE_INSTANCE looking for node with managedObjectType:"
                        + managedObjectType
                        + " managedObjectInstance:"
                        + managedObjectInstance);
              try {
                node = ossDao.findNodeByInstanceAndType(managedObjectInstance, managedObjectType);

                if (node != null) {
                  if (log.isDebugEnabled())
                    log.debug(
                        logheader
                            + " alarmUpdateBehaviour.equals(USE_TYPE_INSTANCE):"
                            + "NODE FOUND for this RX Name:"
                            + defaultUpdateNodeLabel
                            + " setting node id to NodeLabel:"
                            + node.getLabel()
                            + " NodeID:"
                            + node.getId());
                  onmsAlarm.setNode(
                      node); // maps into FIRST instance of node with the same managedObjectInstance
                  // and managedObjectType
                } else {
                  log.error(
                      logheader
                          + " alarmUpdateBehaviour.equals(USE_TYPE_INSTANCE):"
                          + "NODE NOT FOUND for this managedObjectType:"
                          + managedObjectType
                          + " managedObjectInstance:"
                          + managedObjectInstance
                          + " setting node id to default NodeID: 1");
                  node = new OnmsNode(); // TODO remove ossDao.makeExtendedOnmsNode();
                  node.setId(new Integer(1)); // node id cannot be null
                  onmsAlarm.setNode(node); //
                }
              } catch (Throwable ex) {
                log.error(
                    logheader
                        + " alarmUpdateBehaviour.equals(USE_TYPE_INSTANCE) Problem looking up Node for alarm Set to default nodeID:1"
                        + ex);
              }
            } else {
              log.error(
                  logheader
                      + " Invalid value for alarmUpdateBehaviour:"
                      + almUpdateBehaviour
                      + " "
                      + getAlarmUpdateBehaviourForInt(almUpdateBehaviour)
                      + " defaulting to update nodeID:1");
            }
          }

          onmsAlarm.setMouseOverText(""); // needed?
          onmsAlarm.setManagedObjectType(alarmValue.getManagedObjectClass());
          onmsAlarm.setManagedObjectInstance(alarmValue.getManagedObjectInstance());
          onmsAlarm.setLogMsg(alarmValue.getSpecificProblem());

          // NOTE - this has no effect here as .setLastEvent nulls value
          // alarm.setLastEventTime(nnae.getEventTime());

          //					TODO REMOVED - DO NOT CREATE EVENT WITH HIBERNATE AlarmDAo
          //					OnmsEvent event= new OnmsEvent();
          //					//event.setId(new Integer(1));  // This is NOT set since unique constraint in
          // alarms table on Events table
          //					onmsAlarm.setLastEvent(event);

          onmsAlarm.setIpAddr(InetAddressUtils.getLocalHostAddress()); // needed?
          onmsAlarm.setId(null); // set null as updating alarm
          onmsAlarm.setFirstEventTime(alarmValue.getAlarmRaisedTime());
          onmsAlarm.setLastEventTime(alarmValue.getAlarmChangedTime());

          //					TODO removed - do create distpoller with hibernate dao
          //					onmsAlarm.setDistPoller(new OnmsDistPoller("undefined","localhost")); //simple
          // constructor
          onmsAlarm.setDistPoller(distPollerDao.get("localhost"));

          onmsAlarm.setDescription(
              alarmValue.getAdditionalText()); // TODO need Qosd Not to generate this if remote
          onmsAlarm.setCounter(new Integer(1));
          onmsAlarm.setApplicationDN(applicationDN);
          onmsAlarm.setAlarmType(new Integer(1)); // set to raise alarm
          // alarm.setAlarmAckUser(arg0);
          // alarm.setAlarmAckTime(arg0);

          if (log.isDebugEnabled()) log.debug(logheader + ": Creating Alarm: ");
        }
      }
    } catch (Throwable e) {
      log.error(logheader + " Error : ", e);
    }
    return onmsAlarm;
  }