private List<OnmsAlarm> createDownAlarm() {
    List<OnmsAlarm> alarms = new ArrayList<OnmsAlarm>();

    OnmsAlarm alarm1 = new OnmsAlarm();
    alarm1.setNode(m_node1);
    alarm1.setIfIndex(10101);
    alarm1.setUei("uei.opennms.org/internal/topology/linkDown");
    alarms.add(alarm1);

    return alarms;
  }
  private NorthboundAlarm alarm(int alarmId) {
    OnmsAlarm alarm = new OnmsAlarm();
    alarm.setId(alarmId);
    alarm.setUei("uei.opennms.org/test/httpNorthBounder");
    alarm.setEventParms(
        "componentType=Service(string,text);componentName=NAM"
            + alarmId
            + "(string,text);componentForeignSource=FS(string,text);componentForeignId="
            + alarmId
            + "(string,text);cause=17(string,text)");
    alarm.setAlarmType((alarmId + 1) % 2 + 1);

    return new NorthboundAlarm(alarm);
  }
  @Test
  @JUnitTemporaryDatabase
  public void testClearAlarms() {
    OnmsAlarm alarm = m_alarmRepo.getAlarm(1);

    assertNotNull(alarm);
    assertEquals(OnmsSeverity.NORMAL.getId(), alarm.getSeverity().getId());

    int[] alarmIds = {1};
    m_alarmRepo.clearAlarms(alarmIds, "TestUser", new Date());

    alarm = m_alarmRepo.getAlarm(1);
    assertNotNull(alarm);
    assertEquals(OnmsSeverity.CLEARED.getId(), alarm.getSeverity().getId());
  }
  @Test
  @Transactional
  @JUnitTemporaryDatabase
  public void testGetAlarmById() {
    OnmsAlarm alarm = m_alarmRepo.getAlarm(1);
    assertNotNull(alarm);

    assertEquals(1, alarm.getId().intValue());
    assertEquals("uei.opennms.org/test", alarm.getUei());
    assertEquals("localhost", alarm.getDistPoller().getName());
    assertEquals(1, alarm.getCounter().intValue());
    assertEquals(3, alarm.getSeverity().getId());
  }
  @Test
  @Transactional
  public void testAlarmSummary() {
    OnmsEvent event = new OnmsEvent();
    event.setEventLog("Y");
    event.setEventDisplay("Y");
    event.setEventCreateTime(new Date());
    event.setDistPoller(m_distPollerDao.load("localhost"));
    event.setEventTime(new Date());
    event.setEventSeverity(new Integer(7));
    event.setEventUei("uei://org/opennms/test/EventDaoTest");
    event.setEventSource("test");
    m_eventDao.save(event);

    OnmsNode node = m_nodeDao.findAll().iterator().next();

    OnmsAlarm alarm = new OnmsAlarm();

    alarm.setNode(node);
    alarm.setUei(event.getEventUei());
    alarm.setSeverityId(event.getEventSeverity());
    alarm.setFirstEventTime(event.getEventTime());
    alarm.setLastEvent(event);
    alarm.setCounter(1);
    alarm.setDistPoller(m_distPollerDao.load("localhost"));

    m_alarmDao.save(alarm);

    List<AlarmSummary> summary = m_alarmDao.getNodeAlarmSummaries();
    Assert.assertNotNull(summary);
    Assert.assertEquals(1, summary.size());
    AlarmSummary sum = summary.get(0);
    Assert.assertEquals(node.getLabel(), sum.getNodeLabel());
    Assert.assertEquals(alarm.getSeverity().getId(), sum.getMaxSeverity().getId());
    Assert.assertNotSame("N/A", sum.getFuzzyTimeDown());
  }
  @Test
  @Transactional
  public void testAlarmSummary_AlarmWithNoEvent() {
    OnmsNode node = m_nodeDao.findAll().iterator().next();

    OnmsAlarm alarm = new OnmsAlarm();
    alarm.setNode(node);
    alarm.setUei("uei://org/opennms/test/badAlarmTest");
    alarm.setSeverityId(new Integer(7));
    alarm.setCounter(1);
    alarm.setDistPoller(m_distPollerDao.load("localhost"));

    m_alarmDao.save(alarm);

    List<AlarmSummary> summary = m_alarmDao.getNodeAlarmSummaries();
    Assert.assertNotNull(summary);
    Assert.assertEquals(1, summary.size());
    AlarmSummary sum = summary.get(0);
    Assert.assertEquals(node.getLabel(), sum.getNodeLabel());
    Assert.assertEquals(alarm.getSeverity().getId(), sum.getMaxSeverity().getId());
    Assert.assertEquals("N/A", sum.getFuzzyTimeDown());
  }
  @Test
  @Transactional
  @Ignore
  public void testWithoutDistPoller() {
    OnmsEvent event = new OnmsEvent();
    event.setEventLog("Y");
    event.setEventDisplay("Y");
    event.setEventCreateTime(new Date());
    event.setDistPoller(m_distPollerDao.load("localhost"));
    event.setEventTime(new Date());
    event.setEventSeverity(new Integer(7));
    event.setEventUei("uei://org/opennms/test/EventDaoTest");
    event.setEventSource("test");
    m_eventDao.save(event);

    OnmsNode node = m_nodeDao.findAll().iterator().next();

    OnmsAlarm alarm = new OnmsAlarm();

    alarm.setNode(node);
    alarm.setUei(event.getEventUei());
    alarm.setSeverityId(event.getEventSeverity());
    alarm.setFirstEventTime(event.getEventTime());
    alarm.setLastEvent(event);
    alarm.setCounter(1);

    ThrowableAnticipator ta = new ThrowableAnticipator();
    ta.anticipate(
        new DataIntegrityViolationException(
            "not-null property references a null or transient value: org.opennms.netmgt.model.OnmsAlarm.distPoller; nested exception is org.hibernate.PropertyValueException: not-null property references a null or transient value: org.opennms.netmgt.model.OnmsAlarm.distPoller"));

    try {
      m_alarmDao.save(alarm);
    } catch (Throwable t) {
      ta.throwableReceived(t);
    }

    ta.verifyAnticipated();
  }
Example #8
0
 private OnmsAlarm buildAlarm(final OnmsEvent event) {
   final OnmsAlarm alarm = new OnmsAlarm();
   alarm.setDistPoller(getDistPollerDao().load("localhost"));
   alarm.setUei(event.getEventUei());
   alarm.setAlarmType(1);
   alarm.setNode(m_node1);
   alarm.setDescription("This is a test alarm");
   alarm.setLogMsg("this is a test alarm log message");
   alarm.setCounter(1);
   alarm.setIpAddr(InetAddressUtils.getInetAddress("192.168.1.1"));
   alarm.setSeverity(OnmsSeverity.NORMAL);
   alarm.setFirstEventTime(event.getEventTime());
   alarm.setLastEvent(event);
   return alarm;
 }
  /**
   * {@inheritDoc}
   *
   * <p>Purge or purge all action of the selected alarms specified in the POST and then redirect the
   * client to an appropriate URL for display.
   */
  protected ModelAndView handleRequestInternal(
      HttpServletRequest request, HttpServletResponse response) throws Exception {

    logger.info("Enter into the AlarmPurgeController action");

    // Handle the alarm and actionCode parameter
    String[] alarmIdStrings = request.getParameterValues("alarm");
    String action = request.getParameter("actionCode");

    List<Integer> alarmIds = new ArrayList<Integer>();
    if (alarmIdStrings != null && action.equals(PURGE_ACTION)) {
      for (int i = 0; i < alarmIdStrings.length; i++) {
        try {
          alarmIds.add(WebSecurityUtils.safeParseInt(alarmIdStrings[i]));
        } catch (Exception e) {
          logger.error("Could not parse alarm ID '{}' to integer.", alarmIdStrings[i]);
        }
      }
    }

    // Handle the acknowledge type parameter
    String ackTypeString = request.getParameter("acktype");
    AcknowledgeType alarmAckType = m_defaultAlarmAcknowledgeType;

    if (ackTypeString != null) {
      try {
        alarmAckType = AcknowledgeType.getAcknowledgeType(ackTypeString);
      } catch (Exception e) {
        logger.error("Could not retrieve acknowledge type for this '{}'.", ackTypeString);
      }
    }

    // Handle the filter parameter
    List<Filter> filterList = new ArrayList<Filter>();
    String[] filterStrings = request.getParameterValues("filter");

    if (action.equals(PURGEALL_ACTION)) {
      if (filterStrings != null) {
        for (int i = 0; i < filterStrings.length; i++) {
          Filter filter = AlarmUtil.getFilter(filterStrings[i], getServletContext());
          if (filter != null) {
            filterList.add(filter);
          }
        }
      }
    }

    // Get the alarms by alarm criteria
    Filter[] alarmFilters = filterList.toArray(new Filter[0]);

    if (action.equals(PURGEALL_ACTION)) {
      alarmIds.clear();
      AlarmCriteria alarmQueryCriteria = new AlarmCriteria(alarmAckType, alarmFilters);
      OnmsAlarm[] alarms =
          m_webAlarmRepository.getMatchingAlarms(AlarmUtil.getOnmsCriteria(alarmQueryCriteria));
      for (OnmsAlarm alarm : alarms) {
        alarmIds.add(alarm.getId());
      }
    }

    // Handle the purge action
    if (action.equals(PURGE_ACTION) || action.equals(PURGEALL_ACTION)) {
      try {
        m_webAlarmRepository.purgeAlarms(alarmIds);
        request.getSession().setAttribute("actionStatus", alarmIds.size() + "," + SUCCESS_ACTION);
        logger.info(
            "The Purge action is successfully completed for the alarm Id's " + alarmIds + " ");
      } catch (final Exception ex) {
        ex.printStackTrace();
        request.getSession().setAttribute("actionStatus", alarmIds.size() + "," + FAILURE_ACTION);
        logger.error("Unable to do purge action for this alarm Id's.", alarmIds);
      }
    } else {
      logger.error("Unknown alarm action: " + action);
    }

    // Handle the redirect parameters
    String redirectParms = request.getParameter("redirectParms");
    String viewName = m_redirectView;
    if (redirectParms != null) {
      viewName = m_redirectView + "?" + redirectParms;
    }

    RedirectView view = new RedirectView(viewName, true);
    logger.info("Terminated from the AlarmPurgeController action");

    return new ModelAndView(view);
  }
  @Test
  @Transactional
  public void testSave() {
    OnmsEvent event = new OnmsEvent();
    event.setEventLog("Y");
    event.setEventDisplay("Y");
    event.setEventCreateTime(new Date());
    event.setDistPoller(m_distPollerDao.load("localhost"));
    event.setEventTime(new Date());
    event.setEventSeverity(new Integer(7));
    event.setEventUei("uei://org/opennms/test/EventDaoTest");
    event.setEventSource("test");
    m_eventDao.save(event);

    OnmsNode node = m_nodeDao.findAll().iterator().next();

    OnmsAlarm alarm = new OnmsAlarm();

    alarm.setNode(node);
    alarm.setUei(event.getEventUei());
    alarm.setSeverityId(event.getEventSeverity());
    alarm.setFirstEventTime(event.getEventTime());
    alarm.setLastEvent(event);
    alarm.setCounter(1);
    alarm.setDistPoller(m_distPollerDao.load("localhost"));

    m_alarmDao.save(alarm);
    // It works we're so smart! hehe

    OnmsAlarm newAlarm = m_alarmDao.load(alarm.getId());
    assertEquals("uei://org/opennms/test/EventDaoTest", newAlarm.getUei());
    assertEquals(alarm.getLastEvent().getId(), newAlarm.getLastEvent().getId());

    Collection<OnmsAlarm> alarms;
    Criteria criteria = new Criteria(OnmsAlarm.class);
    criteria.addRestriction(new EqRestriction("node.id", node.getId()));
    alarms = m_alarmDao.findMatching(criteria);
    assertEquals(1, alarms.size());
    newAlarm = alarms.iterator().next();
    assertEquals("uei://org/opennms/test/EventDaoTest", newAlarm.getUei());
    assertEquals(alarm.getLastEvent().getId(), newAlarm.getLastEvent().getId());
  }
  @Test
  @Transactional
  public void testActions() {
    OnmsEvent event = new OnmsEvent();
    event.setEventLog("Y");
    event.setEventDisplay("Y");
    event.setEventCreateTime(new Date());
    event.setDistPoller(m_distPollerDao.load("localhost"));
    event.setEventTime(new Date());
    event.setEventSeverity(Integer.valueOf(6));
    event.setEventUei("uei://org/opennms/test/EventDaoTest");
    event.setEventSource("test");
    m_eventDao.save(event);

    OnmsNode node = m_nodeDao.findAll().iterator().next();

    OnmsAlarm alarm = new OnmsAlarm();

    alarm.setNode(node);
    alarm.setUei(event.getEventUei());
    alarm.setSeverity(OnmsSeverity.get(event.getEventSeverity()));
    alarm.setSeverityId(event.getEventSeverity());
    alarm.setFirstEventTime(event.getEventTime());
    alarm.setLastEvent(event);
    alarm.setCounter(1);
    alarm.setDistPoller(m_distPollerDao.load("localhost"));

    m_alarmDao.save(alarm);

    OnmsAlarm newAlarm = m_alarmDao.load(alarm.getId());
    assertEquals("uei://org/opennms/test/EventDaoTest", newAlarm.getUei());
    assertEquals(alarm.getLastEvent().getId(), newAlarm.getLastEvent().getId());

    assertEquals(OnmsSeverity.MAJOR, newAlarm.getSeverity());

    newAlarm.escalate("admin");
    assertEquals(OnmsSeverity.CRITICAL, newAlarm.getSeverity());

    newAlarm.clear("admin");
    assertEquals(OnmsSeverity.CLEARED, newAlarm.getSeverity());

    newAlarm.unacknowledge("admin");
    assertNull(newAlarm.getAckUser());
    assertNull(newAlarm.getAlarmAckTime());
  }
  /**
   * 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()
  /**
   * 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;
  }