2 * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
9 package org.opendaylight.vpnservice.arputil.internal;
11 import static com.google.common.base.Preconditions.checkArgument;
12 import static com.google.common.base.Preconditions.checkNotNull;
14 import java.math.BigInteger;
15 import java.net.InetAddress;
16 import java.net.UnknownHostException;
17 import java.util.List;
18 import java.util.concurrent.ConcurrentHashMap;
19 import java.util.concurrent.ConcurrentMap;
20 import java.util.concurrent.ExecutionException;
21 import java.util.concurrent.ExecutorService;
22 import java.util.concurrent.Executors;
23 import java.util.concurrent.Future;
24 import org.opendaylight.controller.liblldp.NetUtils;
25 import org.opendaylight.controller.liblldp.Packet;
26 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
27 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
28 import org.opendaylight.controller.md.sal.binding.api.NotificationService;
29 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
30 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
31 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
32 import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
33 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
34 import org.opendaylight.vpnservice.mdsalutil.MetaDataUtil;
35 import org.opendaylight.vpnservice.mdsalutil.NWUtil;
36 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
37 import org.opendaylight.vpnservice.mdsalutil.packet.ARP;
38 import org.opendaylight.vpnservice.mdsalutil.packet.Ethernet;
39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Metadata;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketInReason;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingListener;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.SendToController;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.ArpRequestReceived;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.ArpRequestReceivedBuilder;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.ArpResponseReceivedBuilder;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.GetMacInput;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.GetMacOutput;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.GetMacOutputBuilder;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.MacChangedBuilder;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.OdlArputilService;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.SendArpRequestInput;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.SendArpRequestInputBuilder;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.SendArpResponseInput;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.interfaces.InterfaceAddress;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.BaseIds;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetInterfaceFromIfIndexInput;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetInterfaceFromIfIndexInputBuilder;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetInterfaceFromIfIndexOutput;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetPortFromInterfaceInput;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetPortFromInterfaceInputBuilder;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetPortFromInterfaceOutput;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.OdlInterfaceRpcService;
82 import org.opendaylight.yangtools.concepts.ListenerRegistration;
83 import org.opendaylight.yangtools.yang.binding.DataObject;
84 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
85 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
86 import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
87 import org.opendaylight.yangtools.yang.common.RpcResult;
88 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
89 import org.slf4j.Logger;
90 import org.slf4j.LoggerFactory;
92 import com.google.common.base.Optional;
93 import com.google.common.util.concurrent.FutureCallback;
94 import com.google.common.util.concurrent.Futures;
95 import com.google.common.util.concurrent.JdkFutureAdapters;
96 import com.google.common.util.concurrent.SettableFuture;
98 public class ArpUtilImpl implements OdlArputilService,
99 PacketProcessingListener, AutoCloseable {
101 private static final String FAILED_TO_GET_SRC_IP_FOR_INTERFACE = "Failed to get src ip for %s";
103 private static final String FAILED_TO_GET_SRC_MAC_FOR_INTERFACE = "Failed to get src mac for interface %s iid %s ";
105 private static final String FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE = "failed to send arp req for interface ";
107 private static final String UNKNOWN_IP_ADDRESS_SUPPLIED = "unknown ip address supplied";
109 private static final String NODE_CONNECTOR_NOT_FOUND_ERROR = "Node connector id not found for interface %s";
111 private static final String DPN_NOT_FOUND_ERROR = "dpn not found for interface %s ";
113 private static final short ARP_REQUEST_OP = (short) 1;
115 private static final short ARP_RESPONSE_OP = (short) 2;
117 private static final short ETH_TYPE_ARP = 0x0806;
119 private static final Logger LOGGER = LoggerFactory
120 .getLogger(ArpUtilImpl.class);
122 static OdlInterfaceRpcService intfRpc;
124 ExecutorService threadPool = Executors.newFixedThreadPool(1);
126 DataBroker dataBroker;
127 PacketProcessingService packetProcessingService;
128 NotificationPublishService notificationPublishService;
129 NotificationService notificationService;
130 IMdsalApiManager mdsalMgr;
132 RpcProviderRegistry rpc;
133 ListenerRegistration<ArpUtilImpl> listenerRegistration;
135 ConcurrentMap<String, String> macsDB = new ConcurrentHashMap<>();
136 ConcurrentMap<String, SettableFuture<RpcResult<GetMacOutput>>> getMacFutures = new ConcurrentHashMap<>();
138 public ArpUtilImpl(DataBroker db,
139 PacketProcessingService packetProcessingService,
140 NotificationPublishService notificationPublishService,
141 NotificationService notificationService,
142 IMdsalApiManager mdsalApiManager,
143 RpcProviderRegistry rpc) {
145 this.dataBroker = db;
146 this.packetProcessingService = packetProcessingService;
147 this.notificationPublishService = notificationPublishService;
148 this.mdsalMgr = mdsalApiManager;
149 this.notificationService = notificationService;
151 listenerRegistration = notificationService
152 .registerNotificationListener(this);
153 LOGGER.info("ArpUtil Manager Initialized ");
156 OdlInterfaceRpcService getInterfaceRpcService() {
157 if (intfRpc == null ) {
158 intfRpc = rpc.getRpcService(OdlInterfaceRpcService.class);
164 public void close() throws Exception {
165 listenerRegistration.close();
166 LOGGER.trace("ArpUtil manager Closed");
169 String getIpAddressInString(IpAddress ipAddress)
170 throws UnknownHostException {
171 return InetAddress.getByName(ipAddress.getIpv4Address().getValue())
175 public Future<RpcResult<GetMacOutput>> getMac(GetMacInput input) {
178 final String dstIpAddress = getIpAddressInString(input
180 if (LOGGER.isTraceEnabled()) {
181 LOGGER.trace("getMac rpc invoked for ip " + dstIpAddress);
183 if (getMacFutures.get(dstIpAddress) != null) {
184 if (LOGGER.isInfoEnabled()) {
185 LOGGER.info("get mac already in progress for the ip "
188 return getMacFutures.get(dstIpAddress);
190 SendArpRequestInputBuilder builder = new SendArpRequestInputBuilder()
191 .setInterfaceAddress(input.getInterfaceAddress())
192 .setIpaddress(input.getIpaddress());
193 Future<RpcResult<Void>> arpReqFt = sendArpRequest(builder.build());
194 final SettableFuture<RpcResult<GetMacOutput>> ft = SettableFuture
198 JdkFutureAdapters.listenInPoolThread(arpReqFt, threadPool),
199 new FutureCallback<RpcResult<Void>>() {
201 public void onFailure(Throwable e) {
202 RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder
203 .<GetMacOutput> failed().withError(
204 ErrorType.APPLICATION,
206 ft.set(resultBuilder.build());
210 public void onSuccess(RpcResult<Void> result) {
211 LOGGER.trace("Successfully sent the arp pkt out for ip "
216 getMacFutures.put(dstIpAddress, ft);
218 } catch (Exception e) {
219 LOGGER.trace("failed to handle getMac request for {} {}",
220 input.getIpaddress(), e);
221 RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder
222 .<GetMacOutput> failed().withError(ErrorType.APPLICATION,
224 return Futures.immediateFuture(resultBuilder.build());
228 byte[] getIpAddressBytes(IpAddress ip) throws UnknownHostException {
229 return InetAddress.getByName(ip.getIpv4Address().getValue())
234 public Future<RpcResult<Void>> sendArpRequest(
235 SendArpRequestInput arpReqInput) {
236 if (LOGGER.isTraceEnabled()) {
237 LOGGER.trace("rpc sendArpRequest invoked for ip "
238 + arpReqInput.getIpaddress());
243 String interfaceName = null;
245 byte[] dstIpBytes = null;
247 RpcResultBuilder<Void> failureBuilder = RpcResultBuilder
249 RpcResultBuilder<Void> successBuilder = RpcResultBuilder
253 dstIpBytes = getIpAddressBytes(arpReqInput.getIpaddress());
254 } catch (Exception e) {
255 failureBuilder.withError(ErrorType.APPLICATION,
256 UNKNOWN_IP_ADDRESS_SUPPLIED);
257 return Futures.immediateFuture(failureBuilder.build());
260 int localErrorCount = 0;
261 for (InterfaceAddress interfaceAddress : arpReqInput
262 .getInterfaceAddress()) {
264 interfaceName = interfaceAddress.getInterface();
265 srcIpBytes = getIpAddressBytes(interfaceAddress.getIpAddress());
267 NodeConnectorId id = getNodeConnectorFromInterfaceName(interfaceName);
269 GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
270 //dpnId = BigInteger.valueOf(MDSALUtil.getDpnIdFromPortName(id));
271 //Long portid = MDSALUtil.getOfPortNumberFromPortName(id);
272 dpnId = portResult.getDpid();
273 Long portid = portResult.getPortno();
274 checkArgument(null != dpnId && BigInteger.ZERO != dpnId,
275 DPN_NOT_FOUND_ERROR, interfaceName);
277 NodeConnectorRef ref = MDSALUtil.getNodeConnRef(dpnId,
279 checkNotNull(ref, NODE_CONNECTOR_NOT_FOUND_ERROR, interfaceName);
281 if (LOGGER.isTraceEnabled()) {
283 "sendArpRequest received dpnId {} out interface {}",
284 dpnId, interfaceName);
286 byte srcMac[] = MDSALUtil.getMacAddressForNodeConnector(
288 (InstanceIdentifier<NodeConnector>) ref.getValue());
289 checkNotNull(srcMac, FAILED_TO_GET_SRC_MAC_FOR_INTERFACE,
290 interfaceName, ref.getValue());
291 checkNotNull(srcIpBytes, FAILED_TO_GET_SRC_IP_FOR_INTERFACE,
294 payload = ArpPacketUtil.getPayload(ARP_REQUEST_OP, srcMac,
295 srcIpBytes, ArpPacketUtil.EthernetDestination_Broadcast,
298 sendPacketOut(dpnId, payload, ref);
300 if (LOGGER.isTraceEnabled()) {
301 LOGGER.trace("sent arp request for "
302 + arpReqInput.getIpaddress());
304 } catch (Throwable e) {
305 LOGGER.trace("failed to send arp req for {} on interface {}",
306 arpReqInput.getIpaddress(), interfaceName);
309 .withError(ErrorType.APPLICATION,
310 FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE
313 .withError(ErrorType.APPLICATION,
314 FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE
319 if (localErrorCount == arpReqInput.getInterfaceAddress().size()) {
320 // All the requests failed
321 return Futures.immediateFuture(failureBuilder.build());
323 return Futures.immediateFuture(successBuilder.build());
326 public Future<RpcResult<Void>> sendPacketOut(BigInteger dpnId,
327 byte[] payload, NodeConnectorRef ref) {
329 NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId,
331 return packetProcessingService
332 .transmitPacket(new TransmitPacketInputBuilder()
335 new NodeRef(InstanceIdentifier
336 .builder(Nodes.class)
338 new NodeKey(new NodeId(
339 "openflow:" + dpnId)))
341 .setIngress(nodeConnectorRef).setEgress(ref).build());
345 public Future<RpcResult<Void>> sendArpResponse(SendArpResponseInput input) {
346 if (LOGGER.isTraceEnabled()) {
347 LOGGER.trace("sendArpResponse rpc invoked");
354 String interfaceName = input.getInterface();
355 //NodeConnectorId id = getNodeConnectorFromInterfaceName(interfaceName);
357 //dpnId = BigInteger.valueOf(MDSALUtil.getDpnIdFromPortName(id));
358 //Long portid = MDSALUtil.getOfPortNumberFromPortName(id);
360 GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
361 //dpnId = BigInteger.valueOf(MDSALUtil.getDpnIdFromPortName(id));
362 //Long portid = MDSALUtil.getOfPortNumberFromPortName(id);
363 dpnId = portResult.getDpid();
364 Long portid = portResult.getPortno();
367 NodeConnectorRef ref = MDSALUtil.getNodeConnRef(dpnId,
369 checkArgument(null != dpnId && BigInteger.ZERO != dpnId,
370 DPN_NOT_FOUND_ERROR, interfaceName);
371 checkNotNull(ref, NODE_CONNECTOR_NOT_FOUND_ERROR, interfaceName);
373 if (LOGGER.isTraceEnabled()) {
375 "sendArpRequest received dpnId {} out interface {}",
376 dpnId, interfaceName);
379 byte[] srcIpBytes = getIpAddressBytes(input.getSrcIpAddress());
380 byte[] dstIpBytes = getIpAddressBytes(input.getIpaddress());
381 byte srcMac[] = MDSALUtil.getMacAddressForNodeConnector(dataBroker,
382 (InstanceIdentifier<NodeConnector>) ref.getValue());
383 byte[] dstMac = NWUtil.parseMacAddress(input.getMacaddress()
385 checkNotNull(srcIpBytes, FAILED_TO_GET_SRC_IP_FOR_INTERFACE,
387 payload = ArpPacketUtil.getPayload(ARP_RESPONSE_OP, srcMac, srcIpBytes,
390 sendPacketOut(dpnId, payload, ref);
391 if (LOGGER.isTraceEnabled()) {
392 LOGGER.trace("sent the arp response for "
393 + input.getSrcIpAddress());
395 } catch (Throwable e) {
396 LOGGER.trace("failed to send arp response for {} {}",
397 input.getSrcIpAddress(), e);
398 return RpcResultBuilder.<Void> failed()
399 .withError(ErrorType.APPLICATION, e.getMessage(), e)
402 RpcResultBuilder<Void> rpcResultBuilder = RpcResultBuilder.success();
403 return Futures.immediateFuture(rpcResultBuilder.build());
407 public void onPacketReceived(PacketReceived packetReceived) {
408 Class<? extends PacketInReason> pktInReason = packetReceived
409 .getPacketInReason();
410 if (LOGGER.isTraceEnabled()) {
411 LOGGER.trace("Packet Received {}", packetReceived);
414 if (pktInReason == SendToController.class) {
417 int tableId = packetReceived.getTableId().getValue();
419 byte[] data = packetReceived.getPayload();
420 Ethernet ethernet = new Ethernet();
422 ethernet.deserialize(data, 0, data.length
423 * NetUtils.NumBitsInAByte);
424 if (ethernet.getEtherType() != ETH_TYPE_ARP) {
428 Packet pkt = ethernet.getPayload();
430 InetAddress srcInetAddr = InetAddress.getByAddress(arp
431 .getSenderProtocolAddress());
432 InetAddress dstInetAddr = InetAddress.getByAddress(arp
433 .getTargetProtocolAddress());
434 byte[] srcMac = ethernet.getSourceMACAddress();
436 NodeConnectorRef ref = packetReceived.getIngress();
438 Metadata i = packetReceived.getMatch().getMetadata();
440 //String interfaceName = MDSALUtil.getInterfaceName(ref, dataBroker);
441 String interfaceName = getInterfaceName(ref,i, dataBroker);
443 checkAndFireMacChangedNotification(interfaceName, srcInetAddr,
446 macsDB.put(interfaceName + "-" + srcInetAddr.getHostAddress(),
447 NWUtil.toStringMacAddress(srcMac));
449 if (arp.getOpCode() == ARP_REQUEST_OP) {
450 fireArpReqRecvdNotification(interfaceName, srcInetAddr,
451 srcMac, dstInetAddr, tableId);
453 fireArpRespRecvdNotification(interfaceName, srcInetAddr,
456 if (getMacFutures.get(srcInetAddr.getHostAddress()) != null) {
457 threadPool.submit(new MacResponderTask(arp));
460 } catch (Throwable e) {
461 LOGGER.trace("Failed to decode packet: {}", e);
466 GetPortFromInterfaceOutput getPortFromInterface(String interfaceName) throws Throwable {
467 GetPortFromInterfaceInputBuilder x = new GetPortFromInterfaceInputBuilder();
468 x.setIntfName(interfaceName);;
469 Future<RpcResult<GetPortFromInterfaceOutput>> ft = intfRpc.getPortFromInterface(x.build());
470 GetPortFromInterfaceOutput result = ft.get().getResult();
471 LOGGER.trace("getPortFromInterface rpc result is {} ", result);
472 if (result != null) {
473 LOGGER.trace("getPortFromInterface rpc result is {} {} ", result.getDpid(), result.getPortno());
478 private String getInterfaceName(NodeConnectorRef ref, Metadata metadata, DataBroker dataBroker2) throws Throwable {
479 LOGGER.debug("metadata received is {} ", metadata);
481 GetInterfaceFromIfIndexInputBuilder ifIndexInputBuilder = new GetInterfaceFromIfIndexInputBuilder();
482 BigInteger lportTag = MetaDataUtil.getLportFromMetadata(metadata.getMetadata());
484 ifIndexInputBuilder.setIfIndex(lportTag.intValue());
485 GetInterfaceFromIfIndexInput input = ifIndexInputBuilder.build();
486 OdlInterfaceRpcService intfRpc = getInterfaceRpcService();
488 Future<RpcResult<GetInterfaceFromIfIndexOutput>> interfaceFromIfIndex = intfRpc.getInterfaceFromIfIndex(input);
489 GetInterfaceFromIfIndexOutput interfaceFromIfIndexOutput = interfaceFromIfIndex.get().getResult();
490 return interfaceFromIfIndexOutput.getInterfaceName();
493 class MacResponderTask implements Runnable {
496 MacResponderTask(ARP arp) {
503 GetMacOutputBuilder outputBuilder;
505 SettableFuture<RpcResult<GetMacOutput>> future = null;
506 RpcResultBuilder<GetMacOutput> resultBuilder;
508 srcAddr = InetAddress.getByAddress(arp
509 .getSenderProtocolAddress());
510 srcMac = NWUtil.toStringMacAddress(arp
511 .getSenderHardwareAddress());
512 future = getMacFutures.remove(srcAddr.getHostAddress());
513 if (future == null) {
514 LOGGER.trace("There are no pending mac requests.");
517 outputBuilder = new GetMacOutputBuilder()
518 .setMacaddress(new PhysAddress(srcMac));
519 resultBuilder = RpcResultBuilder.success(outputBuilder.build());
520 if (LOGGER.isTraceEnabled()) {
521 LOGGER.trace("sent the mac response for ip {}",
522 srcAddr.getHostAddress());
524 } catch (Exception e) {
525 LOGGER.trace("failed to send mac response {} ", e);
526 resultBuilder = RpcResultBuilder.<GetMacOutput> failed()
527 .withError(ErrorType.APPLICATION, e.getMessage(), e);
529 future.set(resultBuilder.build());
533 private void fireArpRespRecvdNotification(String interfaceName,
534 InetAddress inetAddr, byte[] macAddressBytes, int tableId)
535 throws InterruptedException {
537 IpAddress ip = new IpAddress(inetAddr.getHostAddress().toCharArray());
538 String macAddress = NWUtil.toStringMacAddress(macAddressBytes);
539 PhysAddress mac = new PhysAddress(macAddress);
540 ArpResponseReceivedBuilder builder = new ArpResponseReceivedBuilder();
541 builder.setInterface(interfaceName);
542 builder.setIpaddress(ip);
543 builder.setOfTableId((long) tableId);
544 builder.setMacaddress(mac);
545 notificationPublishService.putNotification(builder.build());
548 private void fireArpReqRecvdNotification(String interfaceName,
549 InetAddress srcInetAddr, byte[] srcMac, InetAddress dstInetAddr,
550 int tableId) throws InterruptedException {
551 String macAddress = NWUtil.toStringMacAddress(srcMac);
552 ArpRequestReceivedBuilder builder = new ArpRequestReceivedBuilder();
553 builder.setInterface(interfaceName);
554 builder.setOfTableId((long) tableId);
555 builder.setSrcIpaddress(new IpAddress(srcInetAddr.getHostAddress()
557 builder.setDstIpaddress(new IpAddress(dstInetAddr.getHostAddress()
559 builder.setSrcMac(new PhysAddress(macAddress));
560 notificationPublishService.putNotification(builder.build());
563 private void checkAndFireMacChangedNotification(String interfaceName,
564 InetAddress inetAddr, byte[] macAddressBytes)
565 throws InterruptedException {
567 IpAddress ip = new IpAddress(inetAddr.getHostAddress().toCharArray());
568 String macAddress = NWUtil.toStringMacAddress(macAddressBytes);
569 PhysAddress mac = new PhysAddress(macAddress);
571 if (!macAddress.equals(macsDB.get(interfaceName + "-"
572 + inetAddr.getHostAddress()))) {
573 if (LOGGER.isTraceEnabled()) {
574 LOGGER.trace("mac address changed for " + inetAddr);
576 MacChangedBuilder builder = new MacChangedBuilder();
577 builder.setInterface(interfaceName);
578 builder.setIpaddress(ip);
579 builder.setMacaddress(mac);
580 notificationPublishService.putNotification(builder.build());
584 private InstanceIdentifier<Interface> buildInterfaceId(String interfaceName) {
585 InstanceIdentifierBuilder<Interface> idBuilder = InstanceIdentifier
586 .builder(Interfaces.class).child(Interface.class,
587 new InterfaceKey(interfaceName));
588 InstanceIdentifier<Interface> id = idBuilder.build();
593 private NodeConnectorId getNodeConnectorFromInterfaceName(String interfaceName) {
594 InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> idBuilder =
595 InstanceIdentifier.builder(InterfacesState.class)
596 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class,
597 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey(interfaceName));
598 InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateId = idBuilder.build();
600 Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateOptional = MDSALUtil.read(dataBroker,
601 LogicalDatastoreType.OPERATIONAL,
604 if (ifStateOptional.isPresent()) {
605 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState = ifStateOptional.get();
606 List<String> lowerLayerIf = ifState.getLowerLayerIf();
607 if (!lowerLayerIf.isEmpty()) {
608 return new NodeConnectorId(lowerLayerIf.get(0));