2 * Copyright (c) 2016 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.genius.arputil.internal;
11 import com.google.common.base.Optional;
12 import com.google.common.util.concurrent.FutureCallback;
13 import com.google.common.util.concurrent.Futures;
14 import com.google.common.util.concurrent.JdkFutureAdapters;
15 import com.google.common.util.concurrent.SettableFuture;
17 import org.opendaylight.controller.liblldp.HexEncode;
18 import org.opendaylight.controller.liblldp.NetUtils;
19 import org.opendaylight.controller.liblldp.Packet;
20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
21 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
22 import org.opendaylight.controller.md.sal.binding.api.NotificationService;
23 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
24 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
25 import org.opendaylight.genius.mdsalutil.MDSALUtil;
26 import org.opendaylight.genius.mdsalutil.MetaDataUtil;
27 import org.opendaylight.genius.mdsalutil.NWUtil;
28 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
29 import org.opendaylight.genius.mdsalutil.packet.ARP;
30 import org.opendaylight.genius.mdsalutil.packet.Ethernet;
31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.ArpRequestReceivedBuilder;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.ArpResponseReceivedBuilder;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.GetMacInput;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.GetMacOutput;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.GetMacOutputBuilder;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.MacChangedBuilder;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInput;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInputBuilder;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseInput;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.interfaces.InterfaceAddress;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceInputBuilder;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceOutput;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceInputBuilder;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexInput;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexOutput;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexInputBuilder;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceOutput;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Metadata;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketInReason;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingListener;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.SendToController;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
72 import org.opendaylight.yangtools.concepts.ListenerRegistration;
73 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
74 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
75 import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
76 import org.opendaylight.yangtools.yang.common.RpcResult;
77 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
78 import org.slf4j.Logger;
79 import org.slf4j.LoggerFactory;
81 import java.math.BigInteger;
82 import java.net.InetAddress;
83 import java.net.UnknownHostException;
84 import java.util.ArrayList;
85 import java.util.List;
86 import java.util.concurrent.ConcurrentHashMap;
87 import java.util.concurrent.ConcurrentMap;
88 import java.util.concurrent.ExecutionException;
89 import java.util.concurrent.ExecutorService;
90 import java.util.concurrent.Executors;
91 import java.util.concurrent.Future;
93 import static com.google.common.base.Preconditions.checkArgument;
94 import static com.google.common.base.Preconditions.checkNotNull;
96 public class ArpUtilImpl implements OdlArputilService,
97 PacketProcessingListener, AutoCloseable {
99 private static final String FAILED_TO_GET_SRC_IP_FOR_INTERFACE = "Failed to get src ip for %s";
101 private static final String FAILED_TO_GET_SRC_MAC_FOR_INTERFACE = "Failed to get src mac for interface %s iid %s ";
103 private static final String FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE = "failed to send arp req for interface ";
105 private static final String UNKNOWN_IP_ADDRESS_SUPPLIED = "unknown ip address supplied";
107 private static final String NODE_CONNECTOR_NOT_FOUND_ERROR = "Node connector id not found for interface %s";
109 private static final String DPN_NOT_FOUND_ERROR = "dpn not found for interface %s ";
111 private static final short ARP_REQUEST_OP = (short) 1;
113 private static final short ARP_RESPONSE_OP = (short) 2;
115 private static final short ETH_TYPE_ARP = 0x0806;
117 private static final Logger LOGGER = LoggerFactory
118 .getLogger(ArpUtilImpl.class);
120 static OdlInterfaceRpcService intfRpc;
122 ExecutorService threadPool = Executors.newFixedThreadPool(1);
124 DataBroker dataBroker;
125 PacketProcessingService packetProcessingService;
126 NotificationPublishService notificationPublishService;
127 NotificationService notificationService;
128 IMdsalApiManager mdsalMgr;
130 RpcProviderRegistry rpc;
131 ListenerRegistration<ArpUtilImpl> listenerRegistration;
133 ConcurrentMap<String, String> macsDB = new ConcurrentHashMap<>();
134 ConcurrentMap<String, SettableFuture<RpcResult<GetMacOutput>>> getMacFutures = new ConcurrentHashMap<>();
136 public ArpUtilImpl(DataBroker db,
137 PacketProcessingService packetProcessingService,
138 NotificationPublishService notificationPublishService,
139 NotificationService notificationService,
140 IMdsalApiManager mdsalApiManager,
141 RpcProviderRegistry rpc) {
143 this.dataBroker = db;
144 this.packetProcessingService = packetProcessingService;
145 this.notificationPublishService = notificationPublishService;
146 this.mdsalMgr = mdsalApiManager;
147 this.notificationService = notificationService;
149 listenerRegistration = notificationService
150 .registerNotificationListener(this);
151 LOGGER.info("ArpUtil Manager Initialized ");
154 OdlInterfaceRpcService getInterfaceRpcService() {
155 if (intfRpc == null ) {
156 intfRpc = rpc.getRpcService(OdlInterfaceRpcService.class);
162 public void close() throws Exception {
163 listenerRegistration.close();
164 LOGGER.trace("ArpUtil manager Closed");
167 String getIpAddressInString(IpAddress ipAddress)
168 throws UnknownHostException {
169 return InetAddress.getByName(ipAddress.getIpv4Address().getValue()).getHostAddress();
173 public Future<RpcResult<GetMacOutput>> getMac(GetMacInput input) {
176 final String dstIpAddress = getIpAddressInString(input.getIpaddress());
177 if (LOGGER.isTraceEnabled()) {
178 LOGGER.trace("getMac rpc invoked for ip " + dstIpAddress);
180 if (getMacFutures.get(dstIpAddress) != null) {
181 if (LOGGER.isInfoEnabled()) {
182 LOGGER.info("get mac already in progress for the ip "
185 return getMacFutures.get(dstIpAddress);
187 SendArpRequestInputBuilder builder = new SendArpRequestInputBuilder()
188 .setInterfaceAddress(input.getInterfaceAddress())
189 .setIpaddress(input.getIpaddress());
190 Future<RpcResult<Void>> arpReqFt = sendArpRequest(builder.build());
191 final SettableFuture<RpcResult<GetMacOutput>> ft = SettableFuture
195 JdkFutureAdapters.listenInPoolThread(arpReqFt, threadPool),
196 new FutureCallback<RpcResult<Void>>() {
198 public void onFailure(Throwable e) {
199 RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder
200 .<GetMacOutput> failed().withError(
201 ErrorType.APPLICATION,
203 ft.set(resultBuilder.build());
207 public void onSuccess(RpcResult<Void> result) {
208 LOGGER.trace("Successfully sent the arp pkt out for ip "
213 getMacFutures.put(dstIpAddress, ft);
215 } catch (Exception e) {
216 LOGGER.trace("failed to handle getMac request for {} {}",
217 input.getIpaddress(), e);
218 RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder
219 .<GetMacOutput> failed().withError(ErrorType.APPLICATION,
221 return Futures.immediateFuture(resultBuilder.build());
225 byte[] getIpAddressBytes(IpAddress ip) throws UnknownHostException {
226 return InetAddress.getByName(ip.getIpv4Address().getValue())
231 public Future<RpcResult<Void>> sendArpRequest(
232 SendArpRequestInput arpReqInput) {
233 if (LOGGER.isTraceEnabled()) {
234 LOGGER.trace("rpc sendArpRequest invoked for ip "
235 + arpReqInput.getIpaddress());
240 String interfaceName = null;
242 byte[] dstIpBytes = null;
244 RpcResultBuilder<Void> failureBuilder = RpcResultBuilder
246 RpcResultBuilder<Void> successBuilder = RpcResultBuilder
250 dstIpBytes = getIpAddressBytes(arpReqInput.getIpaddress());
251 } catch (Exception e) {
252 failureBuilder.withError(ErrorType.APPLICATION,
253 UNKNOWN_IP_ADDRESS_SUPPLIED);
254 return Futures.immediateFuture(failureBuilder.build());
257 int localErrorCount = 0;
258 for (InterfaceAddress interfaceAddress : arpReqInput
259 .getInterfaceAddress()) {
261 interfaceName = interfaceAddress.getInterface();
262 srcIpBytes = getIpAddressBytes(interfaceAddress.getIpAddress());
264 NodeConnectorId id = getNodeConnectorFromInterfaceName(interfaceName);
266 GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
267 checkNotNull(portResult);
268 dpnId = portResult.getDpid();
269 Long portid = portResult.getPortno();
270 checkArgument(null != dpnId && BigInteger.ZERO != dpnId,
271 DPN_NOT_FOUND_ERROR, interfaceName);
273 NodeConnectorRef ref = MDSALUtil.getNodeConnRef(dpnId,
275 checkNotNull(ref, NODE_CONNECTOR_NOT_FOUND_ERROR, interfaceName);
277 if (LOGGER.isTraceEnabled()) {
279 "sendArpRequest received dpnId {} out interface {}",
280 dpnId, interfaceName);
282 byte srcMac[] = MDSALUtil.getMacAddressForNodeConnector(
284 (InstanceIdentifier<NodeConnector>) ref.getValue());
285 checkNotNull(srcMac, FAILED_TO_GET_SRC_MAC_FOR_INTERFACE,
286 interfaceName, ref.getValue());
287 checkNotNull(srcIpBytes, FAILED_TO_GET_SRC_IP_FOR_INTERFACE,
290 payload = ArpPacketUtil.getPayload(ARP_REQUEST_OP, srcMac,
291 srcIpBytes, ArpPacketUtil.EthernetDestination_Broadcast,
294 List<Action> actions = getEgressAction(interfaceName);
295 sendPacketOutWithActions(dpnId, payload, ref, actions);
297 if (LOGGER.isTraceEnabled()) {
298 LOGGER.trace("sent arp request for "
299 + arpReqInput.getIpaddress());
301 } catch (Throwable e) {
302 LOGGER.trace("failed to send arp req for {} on interface {}",
303 arpReqInput.getIpaddress(), interfaceName);
306 .withError(ErrorType.APPLICATION,
307 FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE
310 .withError(ErrorType.APPLICATION,
311 FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE
316 if (localErrorCount == arpReqInput.getInterfaceAddress().size()) {
317 // All the requests failed
318 return Futures.immediateFuture(failureBuilder.build());
320 return Futures.immediateFuture(successBuilder.build());
323 public Future<RpcResult<Void>> sendPacketOut(BigInteger dpnId,
324 byte[] payload, NodeConnectorRef ref) {
326 NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId,
328 return packetProcessingService
329 .transmitPacket(new TransmitPacketInputBuilder()
332 new NodeRef(InstanceIdentifier
333 .builder(Nodes.class)
335 new NodeKey(new NodeId(
336 "openflow:" + dpnId)))
338 .setIngress(nodeConnectorRef).setEgress(ref).build());
341 public Future<RpcResult<Void>> sendPacketOutWithActions(BigInteger dpnId,
342 byte[] payload, NodeConnectorRef ref, List<Action> actions) {
344 NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId,
346 return packetProcessingService
347 .transmitPacket(new TransmitPacketInputBuilder()
350 new NodeRef(InstanceIdentifier
351 .builder(Nodes.class)
353 new NodeKey(new NodeId(
354 "openflow:" + dpnId)))
356 .setIngress(nodeConnectorRef).setEgress(ref)
357 .setAction(actions).build());
360 private List<Action> getEgressAction(String interfaceName) {
361 List<Action> actions = new ArrayList<Action>();
363 GetEgressActionsForInterfaceInputBuilder egressAction = new GetEgressActionsForInterfaceInputBuilder().setIntfName(interfaceName);
364 OdlInterfaceRpcService intfRpc = getInterfaceRpcService();
365 if (intfRpc == null) {
366 LOGGER.error("Unable to obtain interfaceMgrRpc service, ignoring egress actions for interfaceName {}", interfaceName);
369 Future<RpcResult<GetEgressActionsForInterfaceOutput>> result =
370 intfRpc.getEgressActionsForInterface(egressAction.build());
371 RpcResult<GetEgressActionsForInterfaceOutput> rpcResult = result.get();
372 if (!rpcResult.isSuccessful()) {
373 LOGGER.warn("RPC Call to Get egress actions for interface {} returned with Errors {}", interfaceName, rpcResult.getErrors());
375 actions = rpcResult.getResult().getAction();
377 } catch (InterruptedException | ExecutionException e) {
378 LOGGER.error("Exception when egress actions for interface {}", interfaceName, e);
379 } catch ( Exception e) {
380 LOGGER.error("Exception when egress actions for interface {}", interfaceName, e);
386 public Future<RpcResult<Void>> sendArpResponse(SendArpResponseInput input) {
387 if (LOGGER.isTraceEnabled()) {
388 LOGGER.trace("sendArpResponse rpc invoked");
393 //byte srcMac[] = new byte[] { (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0 };
398 String interfaceName = input.getInterface();
399 GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
400 checkNotNull(portResult);
401 dpnId = portResult.getDpid();
402 Long portid = portResult.getPortno();
403 NodeConnectorRef ref = MDSALUtil.getNodeConnRef(dpnId,
405 checkArgument(null != dpnId && BigInteger.ZERO != dpnId,
406 DPN_NOT_FOUND_ERROR, interfaceName);
407 checkNotNull(ref, NODE_CONNECTOR_NOT_FOUND_ERROR, interfaceName);
409 if (LOGGER.isTraceEnabled()) {
411 "sendArpRequest received dpnId {} out interface {}",
412 dpnId, interfaceName);
415 byte[] srcIpBytes = getIpAddressBytes(input.getSrcIpaddress());
416 byte[] dstIpBytes = getIpAddressBytes(input.getDstIpaddress());
417 if(input.getSrcMacaddress() == null) {
418 srcMac = MDSALUtil.getMacAddressForNodeConnector(dataBroker,
419 (InstanceIdentifier<NodeConnector>) ref.getValue());
421 String macAddr = input.getSrcMacaddress().getValue();
422 srcMac = HexEncode.bytesFromHexString(macAddr);
424 byte[] dstMac = NWUtil.parseMacAddress(input.getDstMacaddress()
426 checkNotNull(srcIpBytes, FAILED_TO_GET_SRC_IP_FOR_INTERFACE,
428 payload = ArpPacketUtil.getPayload(ARP_RESPONSE_OP, srcMac, srcIpBytes,
431 List<Action> actions = getEgressAction(interfaceName);
432 sendPacketOutWithActions(dpnId, payload, ref, actions);
433 if (LOGGER.isTraceEnabled()) {
434 LOGGER.trace("sent the arp response for "
435 + input.getSrcIpaddress());
437 } catch (Throwable e) {
438 LOGGER.error("failed to send arp response for {} {}",
439 input.getSrcIpaddress(), e);
440 return RpcResultBuilder.<Void> failed()
441 .withError(ErrorType.APPLICATION, e.getMessage(), e)
444 RpcResultBuilder<Void> rpcResultBuilder = RpcResultBuilder.success();
445 return Futures.immediateFuture(rpcResultBuilder.build());
449 public void onPacketReceived(PacketReceived packetReceived) {
450 Class<? extends PacketInReason> pktInReason = packetReceived
451 .getPacketInReason();
452 if (LOGGER.isTraceEnabled()) {
453 LOGGER.trace("Packet Received {}", packetReceived);
456 if (pktInReason == SendToController.class) {
459 int tableId = packetReceived.getTableId().getValue();
461 byte[] data = packetReceived.getPayload();
462 Ethernet ethernet = new Ethernet();
464 ethernet.deserialize(data, 0, data.length
465 * NetUtils.NumBitsInAByte);
466 if (ethernet.getEtherType() != ETH_TYPE_ARP) {
470 Packet pkt = ethernet.getPayload();
472 InetAddress srcInetAddr = InetAddress.getByAddress(arp
473 .getSenderProtocolAddress());
474 InetAddress dstInetAddr = InetAddress.getByAddress(arp
475 .getTargetProtocolAddress());
476 InetAddress addr = srcInetAddr;
477 //For GARP learn target IP
478 if (srcInetAddr.getHostAddress().equalsIgnoreCase(dstInetAddr.getHostAddress()))
480 byte[] srcMac = ethernet.getSourceMACAddress();
482 NodeConnectorRef ref = packetReceived.getIngress();
484 Metadata metadata = packetReceived.getMatch().getMetadata();
486 String interfaceName = getInterfaceName(ref,metadata, dataBroker);
487 //Long vpnId = MetaDataUtil.getVpnIdFromMetadata(metadata.getMetadata());
489 checkAndFireMacChangedNotification(interfaceName, srcInetAddr,
491 macsDB.put(interfaceName + "-" + srcInetAddr.getHostAddress(),
492 NWUtil.toStringMacAddress(srcMac));
493 if (arp.getOpCode() == ARP_REQUEST_OP) {
494 fireArpReqRecvdNotification(interfaceName, srcInetAddr,
495 srcMac, dstInetAddr, tableId, metadata.getMetadata());
497 fireArpRespRecvdNotification(interfaceName, srcInetAddr,
498 srcMac, tableId, metadata.getMetadata());
500 if (getMacFutures.get(srcInetAddr.getHostAddress()) != null) {
501 threadPool.submit(new MacResponderTask(arp));
504 } catch (Throwable e) {
505 LOGGER.trace("Failed to decode packet: {}", e);
510 GetPortFromInterfaceOutput getPortFromInterface(String interfaceName) throws Throwable {
511 GetPortFromInterfaceInputBuilder getPortFromInterfaceInputBuilder = new GetPortFromInterfaceInputBuilder();
512 getPortFromInterfaceInputBuilder.setIntfName(interfaceName);
513 OdlInterfaceRpcService intfRpc = getInterfaceRpcService();
514 if (intfRpc == null) {
515 LOGGER.error("Failed to get OF port for interface {}. Unable to obtain OdlInterfaceRpcService",
520 Future<RpcResult<GetPortFromInterfaceOutput>> portFromInterface = intfRpc.getPortFromInterface(getPortFromInterfaceInputBuilder.build());
521 GetPortFromInterfaceOutput result = portFromInterface.get().getResult();
522 LOGGER.trace("getPortFromInterface rpc result is {} ", result);
523 if (result != null) {
524 LOGGER.trace("getPortFromInterface rpc result is {} {} ", result.getDpid(), result.getPortno());
529 private String getInterfaceName(NodeConnectorRef ref, Metadata metadata, DataBroker dataBroker2) throws Throwable {
530 LOGGER.debug("metadata received is {} ", metadata);
532 GetInterfaceFromIfIndexInputBuilder ifIndexInputBuilder = new GetInterfaceFromIfIndexInputBuilder();
533 BigInteger lportTag = MetaDataUtil.getLportFromMetadata(metadata.getMetadata());
535 ifIndexInputBuilder.setIfIndex(lportTag.intValue());
536 GetInterfaceFromIfIndexInput input = ifIndexInputBuilder.build();
537 OdlInterfaceRpcService intfRpc = getInterfaceRpcService();
539 Future<RpcResult<GetInterfaceFromIfIndexOutput>> interfaceFromIfIndex = intfRpc.getInterfaceFromIfIndex(input);
540 GetInterfaceFromIfIndexOutput interfaceFromIfIndexOutput = interfaceFromIfIndex.get().getResult();
541 return interfaceFromIfIndexOutput.getInterfaceName();
544 class MacResponderTask implements Runnable {
547 MacResponderTask(ARP arp) {
554 GetMacOutputBuilder outputBuilder;
556 SettableFuture<RpcResult<GetMacOutput>> future = null;
557 RpcResultBuilder<GetMacOutput> resultBuilder;
559 srcAddr = InetAddress.getByAddress(arp
560 .getSenderProtocolAddress());
561 srcMac = NWUtil.toStringMacAddress(arp
562 .getSenderHardwareAddress());
563 future = getMacFutures.remove(srcAddr.getHostAddress());
564 if (future == null) {
565 LOGGER.trace("There are no pending mac requests.");
568 outputBuilder = new GetMacOutputBuilder()
569 .setMacaddress(new PhysAddress(srcMac));
570 resultBuilder = RpcResultBuilder.success(outputBuilder.build());
571 if (LOGGER.isTraceEnabled()) {
572 LOGGER.trace("sent the mac response for ip {}",
573 srcAddr.getHostAddress());
575 } catch (Exception e) {
576 LOGGER.trace("failed to send mac response {} ", e);
577 resultBuilder = RpcResultBuilder.<GetMacOutput> failed()
578 .withError(ErrorType.APPLICATION, e.getMessage(), e);
580 future.set(resultBuilder.build());
584 private void fireArpRespRecvdNotification(String interfaceName,
585 InetAddress inetAddr, byte[] macAddressBytes, int tableId, BigInteger metadata)
586 throws InterruptedException {
588 IpAddress ip = new IpAddress(inetAddr.getHostAddress().toCharArray());
589 String macAddress = NWUtil.toStringMacAddress(macAddressBytes);
590 PhysAddress mac = new PhysAddress(macAddress);
591 ArpResponseReceivedBuilder builder = new ArpResponseReceivedBuilder();
592 builder.setInterface(interfaceName);
593 builder.setIpaddress(ip);
594 builder.setOfTableId((long) tableId);
595 builder.setMacaddress(mac);
596 builder.setMetadata(metadata);
597 notificationPublishService.putNotification(builder.build());
600 private void fireArpReqRecvdNotification(String interfaceName,
601 InetAddress srcInetAddr, byte[] srcMac, InetAddress dstInetAddr,
602 int tableId, BigInteger metadata) throws InterruptedException {
603 String macAddress = NWUtil.toStringMacAddress(srcMac);
604 ArpRequestReceivedBuilder builder = new ArpRequestReceivedBuilder();
605 builder.setInterface(interfaceName);
606 builder.setOfTableId((long) tableId);
607 builder.setSrcIpaddress(new IpAddress(srcInetAddr.getHostAddress()
609 builder.setDstIpaddress(new IpAddress(dstInetAddr.getHostAddress()
611 builder.setSrcMac(new PhysAddress(macAddress));
612 builder.setMetadata(metadata);
613 notificationPublishService.putNotification(builder.build());
616 private void checkAndFireMacChangedNotification(String interfaceName,
617 InetAddress inetAddr, byte[] macAddressBytes)
618 throws InterruptedException {
620 IpAddress ip = new IpAddress(inetAddr.getHostAddress().toCharArray());
621 String macAddress = NWUtil.toStringMacAddress(macAddressBytes);
622 PhysAddress mac = new PhysAddress(macAddress);
624 if (!macAddress.equals(macsDB.get(interfaceName + "-"
625 + inetAddr.getHostAddress()))) {
626 if (LOGGER.isTraceEnabled()) {
627 LOGGER.trace("mac address changed for " + inetAddr);
629 MacChangedBuilder builder = new MacChangedBuilder();
630 builder.setInterface(interfaceName);
631 builder.setIpaddress(ip);
632 builder.setMacaddress(mac);
633 notificationPublishService.putNotification(builder.build());
637 private InstanceIdentifier<Interface> buildInterfaceId(String interfaceName) {
638 InstanceIdentifierBuilder<Interface> idBuilder = InstanceIdentifier
639 .builder(Interfaces.class).child(Interface.class,
640 new InterfaceKey(interfaceName));
641 InstanceIdentifier<Interface> id = idBuilder.build();
645 private NodeConnectorId getNodeConnectorFromInterfaceName(String interfaceName) {
646 InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> idBuilder =
647 InstanceIdentifier.builder(InterfacesState.class)
648 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class,
649 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey(interfaceName));
650 InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateId = idBuilder.build();
652 Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateOptional = MDSALUtil.read(dataBroker,
653 LogicalDatastoreType.OPERATIONAL,
656 if (ifStateOptional.isPresent()) {
657 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState = ifStateOptional.get();
658 List<String> lowerLayerIf = ifState.getLowerLayerIf();
659 if (!lowerLayerIf.isEmpty()) {
660 return new NodeConnectorId(lowerLayerIf.get(0));