org.opennms.netmgt.model.events.EventBuilder.setService java code examples

Common ways to obtain EventBuilder

private void myMethod () {
     EventBuilder e =String uei;String str;new EventBuilder(uei, str)
String uei;String source;new EventBuilder(uei, source)
Smart code suggestions by Codota
}

private static EventBuilder createServiceEventBuilder(String uei, String source, long nodeId, String ipAddr, String service, long txNo) {
  EventBuilder bldr = new EventBuilder(uei, source);
  bldr.setNodeid(nodeId);
  bldr.setInterface(addr(ipAddr));
  bldr.setService(service);
  
  bldr.addParam(EventConstants.PARM_TRANSACTION_NO, txNo);
  return bldr;
}

/**
 * <p>createEventBuilder</p>
 *
 * @param source a {@link java.lang.String} object.
 * @param uei a {@link java.lang.String} object.
 * @param nodeId a int.
 * @param ipAddr a {@link java.lang.String} object.
 * @param svcName a {@link java.lang.String} object.
 * @param reason a {@link java.lang.String} object.
 * @return a {@link org.opennms.netmgt.model.events.EventBuilder} object.
 */
public static EventBuilder createEventBuilder(String source, String uei, int nodeId, String ipAddr, String svcName, String reason) {
  
  EventBuilder event = createEventBuilder(source, uei);
  event.setNodeid(nodeId);
  event.setInterface(addr(ipAddr));
  event.setService(svcName);
  
  if (reason != null) {
    event.addParam(EventConstants.PARM_LOSTSERVICE_REASON, reason);
  }
  return event;
}

private void sendEvent(String eventUEI, OnmsMonitoredService dbObj) {
  final EventBuilder bldr = new EventBuilder(eventUEI, "ProvisionService");
  bldr.setNodeid(dbObj.getNodeId());
  bldr.setInterface(dbObj.getIpAddress());
  bldr.setService(dbObj.getServiceName());
  m_eventForwarder.sendNow(bldr.getEvent());
}

private void sendEvent(String eventUEI, OnmsMonitoredService dbObj) {
  final EventBuilder bldr = new EventBuilder(eventUEI, "ProvisionService");
  bldr.setNodeid(dbObj.getNodeId());
  bldr.setInterface(dbObj.getIpAddress());
  bldr.setService(dbObj.getServiceName());
  m_eventForwarder.sendNow(bldr.getEvent());
}

/**
 * Constructs a serviceDeleted Event for the nodeId, ipAddr, serviceName
 * triple
 *
 * @param source
 *            the source of the event
 * @param nodeId
 *            the nodeId that the service resides on
 * @param ipAddr
 *            the interface that the service resides on
 * @param service
 *            the name of the service that was deleted
 * @return an Event that represents the serviceDeleted event for the give
 *         triple
 */
public static Event createServiceDeletedEvent(String source, int nodeId, InetAddress addr, String service) {
  debug("createServiceDeletedEvent for nodeid/ipaddr/service:  %d/%s", nodeId, str(addr), service);
  EventBuilder bldr = new EventBuilder(SERVICE_DELETED_EVENT_UEI, source);
  bldr.setNodeid(nodeId);
  bldr.setInterface(addr);
  bldr.setService(service);
  return bldr.getEvent();
}

public static EventBuilder createEventBuilder(String uei, OnmsAlarm alarm, Map<String, String> attributes) {
  EventBuilder bldr = new EventBuilder(uei, "AlarmUI");
  bldr.setNode(alarm.getNode());
  bldr.setInterface(alarm.getIpAddr());
  bldr.setService(alarm.getServiceType() == null ? null : alarm.getServiceType().getName());
  bldr.addParam(EventConstants.PARM_ALARM_UEI, alarm.getUei());
  if (attributes == null || !attributes.containsKey(EventConstants.PARM_USER))
    bldr.addParam(EventConstants.PARM_USER, alarm.getAlarmAckUser());
  bldr.addParam(EventConstants.PARM_ALARM_ID, alarm.getId());
  if (alarm.getTTicketId() != null) {
    bldr.addParam(EventConstants.PARM_TROUBLE_TICKET, alarm.getTTicketId());
  }
  if (attributes != null) {
    for (Map.Entry<String, String> attribute: attributes.entrySet()) {
      bldr.addParam(attribute.getKey(), attribute.getValue());
    }
  }
  return bldr;
}

/**
 * <p>createForceResanEvent</p>
 *
 * @return a {@link org.opennms.netmgt.xml.event.Event} object.
 */
public Event createForceRescanEvent() {
  // create the event to be sent
  EventBuilder bldr = new EventBuilder(EventConstants.FORCE_RESCAN_EVENT_UEI, "SnmpCollector");
  
  bldr.setNodeid(m_agent.getNodeId());
  bldr.setInterface(m_agent.getAddress());
  
  bldr.setService(AbstractSnmpCollector.SERVICE_NAME);
  
  bldr.setHost(InetAddressUtils.getLocalHostName());
  return bldr.getEvent();
}

public static EventBuilder createEventBuilder(String uei, OnmsAlarm alarm, Map<String, String> attributes) {
  EventBuilder bldr = new EventBuilder(uei, "AlarmUI");
  bldr.setNode(alarm.getNode());
  bldr.setInterface(alarm.getIpAddr());
  bldr.setService(alarm.getServiceType() == null ? null : alarm.getServiceType().getName());
  bldr.addParam(EventConstants.PARM_ALARM_UEI, alarm.getUei());
  if (attributes == null || !attributes.containsKey(EventConstants.PARM_USER))
    bldr.addParam(EventConstants.PARM_USER, alarm.getAlarmAckUser());
  bldr.addParam(EventConstants.PARM_ALARM_ID, alarm.getId());
  if (alarm.getTTicketId() != null) {
    bldr.addParam(EventConstants.PARM_TROUBLE_TICKET, alarm.getTTicketId());
  }
  if (attributes != null) {
    for (Map.Entry<String, String> attribute: attributes.entrySet()) {
      bldr.addParam(attribute.getKey(), attribute.getValue());
    }
  }
  return bldr;
}

bldr.setService(svcName);

/**
 * Generate event and send it to eventd via the event proxy.
 * 
 * uei Universal event identifier of event to generate.
 */
private void sendEvent(String uei, String reason) {
  EventBuilder builder = new EventBuilder(uei, "OpenNMS.Collectd");
  builder.setNodeid(m_nodeId);
  builder.setInterface(m_agent.getAddress());
  builder.setService(m_spec.getServiceName());
  builder.setHost(InetAddressUtils.getLocalHostName());
  
  if (reason != null) {
    builder.addParam("reason", reason);
  }
  // Send the event
  try {
    EventIpcManagerFactory.getIpcManager().sendNow(builder.getEvent());
    LOG.debug("sendEvent: Sent event {} for {}/{}/{}", uei, m_nodeId, getHostAddress(), getServiceName());
  } catch (Throwable e) {
    LOG.error("Failed to send the event {} for interface {}", uei, getHostAddress(), e);
  }
}

EventBuilder bldr = new EventBuilder(EventConstants.CONFIGURE_SNMP_EVENT_UEI, source);
bldr.setInterface(InetAddressUtils.addr(getFirstIPAddress()));
bldr.setService("SNMP");

bldr.setNodeid(nodeId);
bldr.setInterface(ifaddr);
bldr.setService(service);
bldr.setParam(PARM_IP_HOSTNAME, ifaddr.getHostName());
bldr.setParam(PARM_NODE_LABEL, nodeLabel);

/** {@inheritDoc} */
@Override
public Event createEvent(final String uei, final int nodeId, final String addr, final String netMask, final Date date, final OnmsSnmpInterface snmpinterface) {
  
  log().debug("createEvent: uei = " + uei + " nodeid = " + nodeId + " date = " + date);
  
  EventBuilder bldr = new EventBuilder(uei, this.getName(), date);
  bldr.setNodeid(nodeId);
  if (addr != null) {
    bldr.setInterface(InetAddressUtils.addr(addr));
  }
  if (netMask != null) {
    bldr.addParam(EventConstants.PARM_SNMP_INTERFACE_MASK, InetAddressUtils.normalize(netMask));
  }
  bldr.setService(getServiceName());
  bldr.setHost(this.getLocalHostName());
  bldr.setField("ifIndex", snmpinterface.getIfIndex().toString());
  bldr.addParam(EventConstants.PARM_SNMP_INTERFACE_IFINDEX, snmpinterface.getIfIndex().toString());
  if (snmpinterface.getIfName() != null) bldr.addParam(EventConstants.PARM_SNMP_INTERFACE_NAME, snmpinterface.getIfName());
  if (snmpinterface.getIfDescr() != null) bldr.addParam(EventConstants.PARM_SNMP_INTERFACE_DESC, snmpinterface.getIfDescr());
  if (snmpinterface.getIfAlias() != null) bldr.addParam(EventConstants.PARM_SNMP_INTERFACE_ALIAS, snmpinterface.getIfAlias());
  
  return bldr.getEvent();
}

bldr.setNodeid(1);
bldr.setInterface(addr(ipaddr));
bldr.setService(service);

bldr.setNodeid(1);
bldr.setInterface(addr(ipaddr));
bldr.setService(service);

@Test
public void testIt() throws InterruptedException {
  m_collectd.start();
  
  EventBuilder bldr = new EventBuilder(EventConstants.NODE_GAINED_SERVICE_EVENT_UEI, "Test");
  bldr.setNodeid(1);
  bldr.setInterface(addr("192.168.1.1"));
  bldr.setService("SNMP");
  m_collectd.onEvent(bldr.getEvent());
  
  Thread.sleep(2000);
  
  assertNotNull(m_serviceCollector);
  assertEquals(1, m_serviceCollector.getCollectCount());
  
  m_mockUtils.verifyAll();
}

private void processMessage(Tl1AutonomousMessage message) {
  
  LOG.debug("processMessage: Processing message: {}", message);
  EventBuilder bldr = new EventBuilder(Tl1AutonomousMessage.UEI, "Tl1d");
  bldr.setHost(message.getHost());
  bldr.setInterface(addr(message.getHost())); //interface is the IP
  bldr.setService("TL-1"); //Service it TL-1
  bldr.setSeverity(message.getId().getHighestSeverity());
  
  bldr.setTime(message.getTimestamp());
  bldr.addParam("raw-message", message.getRawMessage());
  bldr.addParam("alarm-code", message.getId().getAlarmCode());
  bldr.addParam("atag", message.getId().getAlarmTag());
  bldr.addParam("verb", message.getId().getVerb());
  bldr.addParam("autoblock", message.getAutoBlock().getBlock());
  bldr.addParam("aid",message.getAutoBlock().getAid());
  bldr.addParam("additionalParams",message.getAutoBlock().getAdditionalParams());
  
  m_eventForwarder.sendNow(bldr.getEvent());
  
  LOG.debug("processMessage: Message processed: {}", message);
}

@Test
@JUnitTemporaryDatabase(tempDbClass=MockDatabase.class)
public void testThresholds() throws Exception {
  EventBuilder bldr = new EventBuilder(EventConstants.HIGH_THRESHOLD_EVENT_UEI, "LatencyStoringServiceMonitorAdaptorTest");
  bldr.setNodeid(1);
  bldr.setInterface(addr("127.0.0.1"));
  bldr.setService("ICMP");
  m_eventIpcManager.getEventAnticipator().anticipateEvent(bldr.getEvent());
  bldr = new EventBuilder(EventConstants.HIGH_THRESHOLD_REARM_EVENT_UEI, "LatencyStoringServiceMonitorAdaptorTest");
  bldr.setNodeid(1);
  bldr.setInterface(addr("127.0.0.1"));
  bldr.setService("ICMP");
  m_eventIpcManager.getEventAnticipator().anticipateEvent(bldr.getEvent());
  executeThresholdTest(new Double[] {100.0, 10.0}); // This should emulate a trigger and a rearm
  m_eventIpcManager.getEventAnticipator().verifyAnticipated();
}

  @Test
  public void canHandleServiceDeletedEvents() {
    // Handle a serviceDeleted event targeting svc2
    OnmsNode node = new OnmsNode();
    node.setId(svc2.getNodeId());

    OnmsIpInterface iface = new OnmsIpInterface();
    iface.setId(101);
    iface.setNode(node);
    iface.setIpAddress(svc2.getAddress());

    Event e = new EventBuilder(EventConstants.SERVICE_DELETED_EVENT_UEI, "test")
        .setIpInterface(iface)
        .setService(svc2.getServiceName())
        .getEvent();
    collectd.onEvent(e);

    // The delete flag should be set (and only set) on svc2
    assertFalse("deletion flag was set on svc1!", svc1.getCollectorUpdates().isDeletionFlagSet());
    assertTrue("deletion flag was not set on svc2!", svc2.getCollectorUpdates().isDeletionFlagSet());
  }
}

/**
 * Test on demand.
 * <p>This test assumes that the database is empty. The data collection will be triggered through events.<p>
 *
 * @throws Exception the exception
 */
@Test
public void testOnDemand() throws Exception {
  initialize(false);
  EventBuilder nodeGained = new EventBuilder(EventConstants.NODE_GAINED_SERVICE_EVENT_UEI, "Test");
  nodeGained.setInterface(InetAddressUtils.addr("192.168.1.1"));
  nodeGained.setService("SNMP");
  EventBuilder reinitialize = new EventBuilder(EventConstants.REINITIALIZE_PRIMARY_SNMP_INTERFACE_EVENT_UEI, "Test");
  reinitialize.setInterface(InetAddressUtils.addr("192.168.1.1"));
  // Emulate Provisiond events for node1
  nodeGained.setNodeid(1);
  reinitialize.setNodeid(1);
  m_collectd.onEvent(nodeGained.getEvent());
  m_collectd.onEvent(reinitialize.getEvent());
  // Emulate Provisiond events for node3
  nodeGained.setNodeid(3);
  reinitialize.setNodeid(3);
  m_collectd.onEvent(nodeGained.getEvent());
  m_collectd.onEvent(reinitialize.getEvent());
  verify();
}

Javadoc

setService

Popular methods of EventBuilder

Popular in Java

Reactive rest calls using spring rest template
requestLocationUpdates (LocationManager)
getResourceAsStream (ClassLoader)
Returns a stream for the resource with the specified name. See #getResource(String) for a descriptio
getSystemService (Context)
Runnable (java.lang)
Represents a command that can be executed. Often used to run code in a different Thread.
Path (java.nio.file)
SQLException (java.sql)
An exception that indicates a failed JDBC operation. It provides the following information about pro
Map (java.util)
A Map is a data structure consisting of a set of keys and values in which each key is mapped to a si
SSLHandshakeException (javax.net.ssl)
The exception that is thrown when a handshake could not be completed successfully.
IOUtils (org.apache.commons.io)
General IO stream manipulation utilities. This class provides static utility methods for input/outpu

Best Java code snippets using org.opennms.netmgt.model.events.EventBuilder.setService (Showing top 20 results out of 315)