Examples with SendArpRequestInputBuilder org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInputBuilder used on opensource projects

Example 1 with SendArpRequestInputBuilder

use of org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInputBuilder in project netvirt by opendaylight.

the class VpnFloatingIpHandler method sendGarpOnInterface.

// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
private void sendGarpOnInterface(final BigInteger dpnId, Uuid networkId, final IpAddress floatingIpAddress, String floatingIpPortMacAddress) {
    if (floatingIpAddress.getIpv4Address() == null) {
        LOG.error("sendGarpOnInterface : Failed to send GARP for IP. recieved IPv6.");
        NatServiceCounters.garp_failed_ipv6.inc();
        return;
    }
    String interfaceName = elanService.getExternalElanInterface(networkId.getValue(), dpnId);
    if (interfaceName == null) {
        LOG.warn("sendGarpOnInterface : Failed to send GARP for IP. Failed to retrieve interface name " + "from network {} and dpn id {}.", networkId.getValue(), dpnId);
        NatServiceCounters.garp_failed_missing_interface.inc();
        return;
    }
    try {
        // find the external network interface name for dpn
        List<InterfaceAddress> interfaceAddresses = new ArrayList<>();
        interfaceAddresses.add(new InterfaceAddressBuilder().setInterface(interfaceName).setIpAddress(floatingIpAddress).setMacaddress(new PhysAddress(floatingIpPortMacAddress)).build());
        SendArpRequestInput sendArpRequestInput = new SendArpRequestInputBuilder().setIpaddress(floatingIpAddress).setInterfaceAddress(interfaceAddresses).build();
        JdkFutures.addErrorLogging(arpUtilService.sendArpRequest(sendArpRequestInput), LOG, "sendArpRequest");
        NatServiceCounters.garp_sent.inc();
    } catch (Exception e) {
        LOG.error("sendGarpOnInterface : Failed to send GARP request for floating ip {} from interface {}", floatingIpAddress.getIpv4Address().getValue(), interfaceName, e);
        NatServiceCounters.garp_failed_send.inc();
    }
}

Example 2 with SendArpRequestInputBuilder

use of org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInputBuilder in project netvirt by opendaylight.

the class NeutronSubnetGwMacResolver method sendArpRequest.

// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
private void sendArpRequest(IpAddress srcIpAddress, IpAddress dstIpAddress, MacAddress srcMacAddress, String interfaceName) {
    if (srcIpAddress == null || dstIpAddress == null) {
        LOG.trace("Skip sending ARP to external GW srcIp {} dstIp {}", srcIpAddress, dstIpAddress);
        return;
    }
    PhysAddress srcMacPhysAddress = new PhysAddress(srcMacAddress.getValue());
    try {
        InterfaceAddress interfaceAddress = new InterfaceAddressBuilder().setInterface(interfaceName).setIpAddress(srcIpAddress).setMacaddress(srcMacPhysAddress).build();
        SendArpRequestInput sendArpRequestInput = new SendArpRequestInputBuilder().setIpaddress(dstIpAddress).setInterfaceAddress(Collections.singletonList(interfaceAddress)).build();
        ListenableFutures.addErrorLogging(JdkFutureAdapters.listenInPoolThread(arpUtilService.sendArpRequest(sendArpRequestInput)), LOG, "Send ARP request");
    } catch (Exception e) {
        LOG.error("Failed to send ARP request to external GW {} from interface {}", dstIpAddress.getIpv4Address().getValue(), interfaceName, e);
    }
}

Example 3 with SendArpRequestInputBuilder

use of org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInputBuilder in project genius by opendaylight.

the class ArpUtilImpl method getMac.

@Override
public Future<RpcResult<GetMacOutput>> getMac(GetMacInput input) {
    try {
        final String dstIpAddress = getIpAddressInString(input.getIpaddress());
        LOG.trace("getMac rpc invoked for ip {}", dstIpAddress);
        if (macAddrs.get(dstIpAddress) != null) {
            if (LOG.isInfoEnabled()) {
                LOG.info("get mac already in progress for the ip {}", dstIpAddress);
            }
            return macAddrs.get(dstIpAddress);
        }
        SendArpRequestInputBuilder builder = new SendArpRequestInputBuilder().setInterfaceAddress(input.getInterfaceAddress()).setIpaddress(input.getIpaddress());
        Future<RpcResult<Void>> arpReqFt = sendArpRequest(builder.build());
        final SettableFuture<RpcResult<GetMacOutput>> ft = SettableFuture.create();
        Futures.addCallback(JdkFutureAdapters.listenInPoolThread(arpReqFt, threadPool), new FutureCallback<RpcResult<Void>>() {

            @Override
            public void onFailure(Throwable ex) {
                RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder.<GetMacOutput>failed().withError(ErrorType.APPLICATION, ex.getMessage(), ex);
                ft.set(resultBuilder.build());
            }

            @Override
            public void onSuccess(RpcResult<Void> result) {
                LOG.trace("Successfully sent the arp pkt out for ip {}", dstIpAddress);
            }
        }, MoreExecutors.directExecutor());
        macAddrs.put(dstIpAddress, ft);
        return ft;
    } catch (UnknownHostException e) {
        LOG.error("Failed to handle getMac request for {}", input.getIpaddress(), e);
        RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder.<GetMacOutput>failed().withError(ErrorType.APPLICATION, e.getMessage(), e);
        return Futures.immediateFuture(resultBuilder.build());
    }
}

Example 4 with SendArpRequestInputBuilder

use of org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInputBuilder in project genius by opendaylight.

the class AlivenessProtocolHandlerARP method startMonitoringTask.

@Override
public void startMonitoringTask(MonitoringInfo monitorInfo) {
    if (arpService == null) {
        LOG.debug("ARP Service not available to send the packet");
        return;
    }
    EndpointType source = monitorInfo.getSource().getEndpointType();
    final String sourceInterface = Preconditions.checkNotNull(getInterfaceName(source), "Source interface is required to send ARP Packet for monitoring");
    final String srcIp = Preconditions.checkNotNull(getIpAddress(source), "Source Ip address is required to send ARP Packet for monitoring");
    final Optional<PhysAddress> srcMacAddressOptional = getMacAddress(source);
    if (srcMacAddressOptional.isPresent()) {
        PhysAddress srcMacAddress = srcMacAddressOptional.get();
        EndpointType target = monitorInfo.getDestination().getEndpointType();
        final String targetIp = Preconditions.checkNotNull(getIpAddress(target), "Target Ip address is required to send ARP Packet for monitoring");
        if (LOG.isTraceEnabled()) {
            LOG.trace("sendArpRequest interface {}, senderIPAddress {}, targetAddress {}", sourceInterface, srcIp, targetIp);
        }
        InterfaceAddressBuilder interfaceAddressBuilder = new InterfaceAddressBuilder().setInterface(sourceInterface).setIpAddress(IpAddressBuilder.getDefaultInstance(srcIp));
        if (srcMacAddress != null) {
            interfaceAddressBuilder.setMacaddress(srcMacAddress);
        }
        List<InterfaceAddress> addresses = Collections.singletonList(interfaceAddressBuilder.build());
        SendArpRequestInput input = new SendArpRequestInputBuilder().setInterfaceAddress(addresses).setIpaddress(IpAddressBuilder.getDefaultInstance(targetIp)).build();
        Future<RpcResult<Void>> future = arpService.sendArpRequest(input);
        final String msgFormat = String.format("Send ARP Request on interface %s to destination %s", sourceInterface, targetIp);
        Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future), new FutureCallback<RpcResult<Void>>() {

            @Override
            public void onFailure(Throwable error) {
                LOG.error("Error - {}", msgFormat, error);
            }

            @Override
            public void onSuccess(RpcResult<Void> result) {
                if (result != null && !result.isSuccessful()) {
                    LOG.warn("Rpc call to {} failed {}", msgFormat, getErrorText(result.getErrors()));
                } else {
                    LOG.debug("Successful RPC Result - {}", msgFormat);
                }
            }
        });
    }
}