/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.camel.component.snmp;
import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.apache.camel.impl.ScheduledPollConsumer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.snmp4j.CommunityTarget;
import org.snmp4j.PDU;
import org.snmp4j.Snmp;
import org.snmp4j.TransportMapping;
import org.snmp4j.event.ResponseEvent;
import org.snmp4j.event.ResponseListener;
import org.snmp4j.mp.MPv3;
import org.snmp4j.security.SecurityModels;
import org.snmp4j.security.SecurityProtocols;
import org.snmp4j.security.USM;
import org.snmp4j.smi.Address;
import org.snmp4j.smi.GenericAddress;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.VariableBinding;
import org.snmp4j.transport.DefaultTcpTransportMapping;
import org.snmp4j.transport.DefaultUdpTransportMapping;
public class SnmpOIDPoller extends ScheduledPollConsumer implements ResponseListener {
private static final Logger LOG = LoggerFactory.getLogger(SnmpOIDPoller.class);
private Address targetAddress;
private TransportMapping<? extends Address> transport;
private Snmp snmp;
private USM usm;
private CommunityTarget target;
private PDU pdu;
private SnmpEndpoint endpoint;
public SnmpOIDPoller(SnmpEndpoint endpoint, Processor processor) {
super(endpoint, processor);
this.endpoint = endpoint;
// convert delay from seconds to millis
setDelay(endpoint.getDelay() * 1000L);
}
@Override
protected void doStart() throws Exception {
super.doStart();
this.targetAddress = GenericAddress.parse(this.endpoint.getAddress());
// either tcp or udp
if ("tcp".equals(endpoint.getProtocol())) {
this.transport = new DefaultTcpTransportMapping();
} else if ("udp".equals(endpoint.getProtocol())) {
this.transport = new DefaultUdpTransportMapping();
} else {
throw new IllegalArgumentException("Unknown protocol: " + endpoint.getProtocol());
}
this.snmp = new Snmp(this.transport);
this.usm = new USM(SecurityProtocols.getInstance(), new OctetString(MPv3.createLocalEngineID()), 0);
SecurityModels.getInstance().addSecurityModel(usm);
// setting up target
target = new CommunityTarget();
target.setCommunity(new OctetString(this.endpoint.getSnmpCommunity()));
target.setAddress(targetAddress);
target.setRetries(this.endpoint.getRetries());
target.setTimeout(this.endpoint.getTimeout());
target.setVersion(this.endpoint.getSnmpVersion());
// creating PDU
this.pdu = new PDU();
// listen to the transport
if (LOG.isDebugEnabled()) {
LOG.debug("Starting OID poller on {} using {} protocol", endpoint.getAddress(), endpoint.getProtocol());
}
this.transport.listen();
if (LOG.isInfoEnabled()) {
LOG.info("Started OID poller on {} using {} protocol", endpoint.getAddress(), endpoint.getProtocol());
}
}
@Override
protected void doStop() throws Exception {
// stop listening to the transport
if (this.transport != null && this.transport.isListening()) {
LOG.info("Stopping OID poller on {}", targetAddress);
this.transport.close();
LOG.info("Stopped OID poller on {}", targetAddress);
}
super.doStop();
}
@Override
protected int poll() throws Exception {
this.pdu.clear();
this.pdu.setType(PDU.GET);
// prepare the request items
for (OID oid : this.endpoint.getOids()) {
this.pdu.add(new VariableBinding(oid));
}
// send the request
snmp.send(pdu, target, null, this);
return 1;
}
public void onResponse(ResponseEvent event) {
// Always cancel async request when response has been received
// otherwise a memory leak is created! Not canceling a request
// immediately can be useful when sending a request to a broadcast address.
((Snmp)event.getSource()).cancel(event.getRequest(), this);
// check for valid response
if (event.getRequest() == null || event.getResponse() == null) {
// ignore null requests/responses
LOG.debug("Received invalid SNMP event. Request: " + event.getRequest() + " / Response: " + event.getResponse());
return;
}
PDU pdu = event.getResponse();
processPDU(pdu);
}
/**
* processes the pdu message
*
* @param pdu the pdu
*/
public void processPDU(PDU pdu) {
if (LOG.isDebugEnabled()) {
LOG.debug("Received response event for {} : {}", this.endpoint.getAddress(), pdu);
}
Exchange exchange = endpoint.createExchange(pdu);
try {
getProcessor().process(exchange);
} catch (Exception e) {
getExceptionHandler().handleException(e);
}
}
/** * @return Returns the target.
*/
public CommunityTarget getTarget() {
return this.target;
}
/**
* @param target The target to set.
*/
public void setTarget(CommunityTarget target) {
this.target = target;
}
}