Examples with Received org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.network.instance.protocol.bgp.neighbor_state.augmentation.messages.Received used on opensource projects

Example 26 with Received

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.network.instance.protocol.bgp.neighbor_state.augmentation.messages.Received in project netvirt by opendaylight.

the class BgpRouter method reConnect.

private void reConnect(TTransportException tte) {
    Bgp bgpConfig = bgpConfigSupplier.get();
    if (bgpConfig != null) {
        LOG.error("Received TTransportException, while configuring qthriftd, goind for Disconnect/Connect " + " Host: {}, Port: {}", bgpConfig.getConfigServer().getHost().getValue(), bgpConfig.getConfigServer().getPort().intValue());
        disconnect();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            LOG.error("Exception wile reconnecting ", e);
        }
        connect(bgpConfig.getConfigServer().getHost().getValue(), bgpConfig.getConfigServer().getPort().intValue());
    } else {
        LOG.error("Unable to send commands to thrift and fetch bgp configuration", tte);
    }
}

Example 27 with Received

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.network.instance.protocol.bgp.neighbor_state.augmentation.messages.Received in project netvirt by opendaylight.

the class NaptEventHandler method prepareAndSendPacketOut.

private void prepareAndSendPacketOut(NAPTEntryEvent naptEntryEvent, Uint32 routerId, String sourceIPPortKey) {
    // Send Packetout - tcp or udp packets which got punted to controller.
    Uint64 metadata = naptEntryEvent.getPacketReceived().getMatch().getMetadata().getMetadata();
    byte[] inPayload = naptEntryEvent.getPacketReceived().getPayload();
    Ethernet ethPkt = new Ethernet();
    if (inPayload != null) {
        try {
            ethPkt.deserialize(inPayload, 0, inPayload.length * Byte.SIZE);
        } catch (PacketException e) {
            NaptPacketInHandler.removeIncomingPacketMap(sourceIPPortKey);
            LOG.error("prepareAndSendPacketOut : Failed to decode Packet", e);
            return;
        }
    }
    long portTag = MetaDataUtil.getLportFromMetadata(metadata).intValue();
    LOG.debug("prepareAndSendPacketOut : portTag from incoming packet is {}", portTag);
    List<ActionInfo> actionInfos = new ArrayList<>();
    String interfaceName = getInterfaceNameFromTag(portTag);
    Uint64 dpnID = null;
    int portNum = -1;
    if (interfaceName != null) {
        LOG.debug("prepareAndSendPacketOut : interfaceName fetched from portTag is {}", interfaceName);
        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface iface = null;
        int vlanId = 0;
        iface = interfaceManager.getInterfaceInfoFromConfigDataStore(interfaceName);
        if (iface == null) {
            NaptPacketInHandler.removeIncomingPacketMap(sourceIPPortKey);
            LOG.error("prepareAndSendPacketOut : Unable to read interface {} from config DataStore", interfaceName);
            return;
        }
        IfL2vlan ifL2vlan = iface.augmentation(IfL2vlan.class);
        if (ifL2vlan != null && ifL2vlan.getVlanId() != null) {
            vlanId = ifL2vlan.getVlanId().getValue() == null ? 0 : ifL2vlan.getVlanId().getValue().toJava();
        }
        InterfaceInfo infInfo = interfaceManager.getInterfaceInfoFromOperationalDataStore(interfaceName);
        if (infInfo == null) {
            LOG.error("prepareAndSendPacketOut : error in getting interfaceInfo from Operation DS");
            return;
        }
        dpnID = infInfo.getDpId();
        portNum = infInfo.getPortNo();
        if (ethPkt.getEtherType() != (short) NwConstants.ETHTYPE_802_1Q) {
            // VLAN Access port
            LOG.debug("prepareAndSendPacketOut : vlanId is {}", vlanId);
            if (vlanId != 0) {
                // Push vlan
                actionInfos.add(new ActionPushVlan(0));
                actionInfos.add(new ActionSetFieldVlanVid(1, vlanId));
            } else {
                LOG.debug("prepareAndSendPacketOut : No vlanId {}, may be untagged", vlanId);
            }
        } else {
            // VLAN Trunk Port
            LOG.debug("prepareAndSendPacketOut : This is VLAN Trunk port case - need not do VLAN tagging again");
        }
    } else {
        // This case will be hit for packets send from non-napt switch.
        LOG.info("prepareAndSendPacketOut : interfaceName is not available.Retrieve from packet received");
        NodeConnectorId nodeId = naptEntryEvent.getPacketReceived().getMatch().getInPort();
        portNum = Integer.parseInt(nodeId.getValue());
        LOG.debug("prepareAndSendPacketOut : in_port portNum : {}", portNum);
        // List<PathArgument> dpnNodes = naptEntryEvent.getPacketReceived().getIngress().getValue().getPath();
        Iterable<PathArgument> outArgs = naptEntryEvent.getPacketReceived().getIngress().getValue().getPathArguments();
        PathArgument pathArgument = Iterables.get(outArgs, 2);
        LOG.debug("prepareAndSendPacketOut : pathArgument : {}", pathArgument);
        InstanceIdentifier.IdentifiableItem<?, ?> item = Arguments.checkInstanceOf(pathArgument, InstanceIdentifier.IdentifiableItem.class);
        NodeConnectorKey key = Arguments.checkInstanceOf(item.getKey(), NodeConnectorKey.class);
        LOG.info("prepareAndSendPacketOut : NodeConnectorKey key : {}", key.getId().getValue());
        String dpnKey = key.getId().getValue();
        if (dpnKey.contains(NatConstants.COLON_SEPARATOR)) {
            dpnID = Uint64.valueOf(dpnKey.split(NatConstants.COLON_SEPARATOR)[1]).intern();
        }
    }
    byte[] pktOut = buildNaptPacketOut(ethPkt);
    if (pktOut != null) {
        String routerName = NatUtil.getRouterName(dataBroker, routerId);
        Uint64 tunId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, natOverVxlanUtil, elanManager, idManager, routerId, routerName);
        LOG.info("sendNaptPacketOut for ({}:{}) on dpnId {} portNum {} tunId {}", naptEntryEvent.getIpAddress(), naptEntryEvent.getPortNumber(), dpnID, portNum, tunId);
        sendNaptPacketOut(pktOut, dpnID, portNum, actionInfos, tunId);
    } else {
        LOG.warn("prepareAndSendPacketOut : Unable to send Packet Out");
    }
}

Example 28 with Received

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.network.instance.protocol.bgp.neighbor_state.augmentation.messages.Received in project netvirt by opendaylight.

the class DhcpInterfaceAddJob method call.

@Override
public List<ListenableFuture<?>> call() throws ExecutionException, InterruptedException {
    String interfaceName = interfaceAdd.getName();
    LOG.trace("Received add DCN for interface {}, dpid {}", interfaceName, dpnId);
    org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface iface = interfaceManager.getInterfaceInfoFromConfigDataStore(interfaceName);
    if (iface != null) {
        IfTunnel tunnelInterface = iface.augmentation(IfTunnel.class);
        if (tunnelInterface != null && !tunnelInterface.isInternal()) {
            IpAddress tunnelIp = tunnelInterface.getTunnelDestination();
            List<Uint64> dpns = DhcpServiceUtils.getListOfDpns(dataBroker);
            if (dpns.contains(dpnId)) {
                return dhcpExternalTunnelManager.handleTunnelStateUp(tunnelIp, dpnId);
            }
            return Collections.emptyList();
        }
    }
    if (!dpnId.equals(DhcpMConstants.INVALID_DPID)) {
        Port port = dhcpManager.getNeutronPort(interfaceName);
        Subnet subnet = dhcpManager.getNeutronSubnet(port);
        if (null == subnet || !subnet.isEnableDhcp()) {
            LOG.debug("DHCP is not enabled for port {}", port.getName());
            return Collections.emptyList();
        }
        List<ListenableFuture<?>> futures = new ArrayList<>();
        // Support for VM migration use cases.
        futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> DhcpServiceUtils.bindDhcpService(interfaceName, NwConstants.DHCP_TABLE, tx)));
        LOG.info("DhcpInterfaceEventListener add isEnableDhcp:{}", subnet.isEnableDhcp());
        futures.addAll(installDhcpEntries(interfaceAdd.getName(), dpnId));
        LOG.trace("Checking ElanDpnInterface {} for dpn {} ", interfaceName, dpnId);
        String subnetId = subnet.getUuid().getValue();
        java.util.Optional<SubnetToDhcpPort> subnetToDhcp = DhcpServiceUtils.getSubnetDhcpPortData(dataBroker, subnetId);
        if (!subnetToDhcp.isPresent()) {
            return Collections.emptyList();
        }
        LOG.trace("Installing the Arp responder for interface {} with DHCP MAC {} & IP {}.", interfaceName, subnetToDhcp.get().getPortMacaddress(), subnetToDhcp.get().getPortFixedip());
        ArpReponderInputBuilder builder = new ArpReponderInputBuilder();
        builder.setDpId(dpnId.toJava()).setInterfaceName(interfaceName).setSpa(subnetToDhcp.get().getPortFixedip()).setSha(subnetToDhcp.get().getPortMacaddress()).setLportTag(interfaceAdd.getIfIndex());
        builder.setInstructions(ArpResponderUtil.getInterfaceInstructions(interfaceManager, interfaceName, subnetToDhcp.get().getPortFixedip(), subnetToDhcp.get().getPortMacaddress(), itmRpcService));
        elanService.addArpResponderFlow(builder.buildForInstallFlow());
        return futures;
    }
    return Collections.emptyList();
}

Example 29 with Received

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.network.instance.protocol.bgp.neighbor_state.augmentation.messages.Received in project netvirt by opendaylight.

the class NaptFlowRemovedEventHandler method onFlowRemoved.

@Override
public void onFlowRemoved(FlowRemoved flowRemoved) {
    /*
        If the removed flow is from the OUTBOUND NAPT table :
        1) Get the ActionInfo of the flow.
        2) From the ActionInfo of the flow get the internal IP address, port and the protocol.
        3) Get the Metadata matching info of the flow.
        4) From the Metadata matching info of the flow get router ID.
        5) Querry the container intext-ip-port-map using the router ID
           and the internal IP address, port to get the external IP address, port
        6) Instantiate an NaptEntry event and populate the external IP address, port and the router ID.
        7) Place the NaptEntry event to the queue.
*/
    short tableId = flowRemoved.getTableId().toJava();
    RemovedFlowReason removedReasonFlag = flowRemoved.getReason();
    if (tableId == NwConstants.OUTBOUND_NAPT_TABLE && RemovedFlowReason.OFPRRIDLETIMEOUT.equals(removedReasonFlag)) {
        LOG.info("onFlowRemoved : triggered for table-{} entry", tableId);
        // Get the internal internal IP address and the port number from the IPv4 match.
        Ipv4Prefix internalIpv4Address = null;
        Layer3Match layer3Match = flowRemoved.getMatch().getLayer3Match();
        if (layer3Match instanceof Ipv4Match) {
            Ipv4Match internalIpv4Match = (Ipv4Match) layer3Match;
            internalIpv4Address = internalIpv4Match.getIpv4Source();
        }
        if (internalIpv4Address == null) {
            LOG.error("onFlowRemoved : Matching internal IP is null while retrieving the " + "value from the Outbound NAPT flow");
            return;
        }
        // Get the internal IP as a string
        String internalIpv4AddressAsString = internalIpv4Address.getValue();
        String[] internalIpv4AddressParts = internalIpv4AddressAsString.split("/");
        String internalIpv4HostAddress = null;
        if (internalIpv4AddressParts.length >= 1) {
            internalIpv4HostAddress = internalIpv4AddressParts[0];
        }
        // Get the protocol from the layer4 match
        NAPTEntryEvent.Protocol protocol = null;
        Integer internalPortNumber = null;
        Layer4Match layer4Match = flowRemoved.getMatch().getLayer4Match();
        if (layer4Match instanceof TcpMatch) {
            TcpMatchFields tcpMatchFields = (TcpMatchFields) layer4Match;
            internalPortNumber = tcpMatchFields.getTcpSourcePort().getValue().toJava();
            protocol = NAPTEntryEvent.Protocol.TCP;
        } else if (layer4Match instanceof UdpMatch) {
            UdpMatchFields udpMatchFields = (UdpMatchFields) layer4Match;
            internalPortNumber = udpMatchFields.getUdpSourcePort().getValue().toJava();
            protocol = NAPTEntryEvent.Protocol.UDP;
        }
        if (protocol == null) {
            LOG.error("onFlowRemoved : Matching protocol is null while retrieving the value " + "from the Outbound NAPT flow");
            return;
        }
        // Get the router ID from the metadata.
        Uint32 routerId;
        Uint64 metadata = flowRemoved.getMatch().getMetadata().getMetadata();
        if (MetaDataUtil.getNatRouterIdFromMetadata(metadata) != 0) {
            routerId = Uint32.valueOf(MetaDataUtil.getNatRouterIdFromMetadata(metadata));
        } else {
            LOG.error("onFlowRemoved : Null exception while retrieving routerId");
            return;
        }
        String flowDpn = NatUtil.getDpnFromNodeRef(flowRemoved.getNode());
        NAPTEntryEvent naptEntryEvent = new NAPTEntryEvent(internalIpv4HostAddress, internalPortNumber, flowDpn, routerId, NAPTEntryEvent.Operation.DELETE, protocol);
        naptEventdispatcher.addFlowRemovedNaptEvent(naptEntryEvent);
    } else {
        LOG.debug("onFlowRemoved : Received flow removed notification due to flowdelete from switch for flowref");
    }
}

Example 30 with Received

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.network.instance.protocol.bgp.neighbor_state.augmentation.messages.Received in project netvirt by opendaylight.

the class NatArpNotificationHandler method onArpRequestReceived.

@Override
public void onArpRequestReceived(ArpRequestReceived notification) {
    LOG.debug("NatArpNotificationHandler received {}", notification);
    IpAddress srcIp = notification.getSrcIpaddress();
    if (srcIp == null || !Objects.equals(srcIp, notification.getDstIpaddress())) {
        LOG.debug("NatArpNotificationHandler: ignoring ARP packet, not gratuitous {}", notification);
        return;
    }
    // Since the point of all this is to learn VIPs those are by definition
    // not the IP addresses assigned to a port by neutron configuration.
    ElanInterface arpSenderIfc = elanService.getElanInterfaceByElanInterfaceName(notification.getInterface());
    if (ipBelongsToElanInterface(arpSenderIfc, srcIp)) {
        LOG.debug("NatArpNotificationHandler: ignoring GARP packet. No need to NAT a port's static IP. {}", notification);
        return;
    }
    ElanInterface targetIfc = null;
    for (String ifcName : elanService.getElanInterfaces(arpSenderIfc.getElanInstanceName())) {
        ElanInterface elanInterface = elanService.getElanInterfaceByElanInterfaceName(ifcName);
        if (ipBelongsToElanInterface(elanInterface, srcIp)) {
            targetIfc = elanInterface;
            break;
        }
    }
    if (null == targetIfc) {
        LOG.warn("NatArpNotificationHandler: GARP does not correspond to an interface in this elan {}", notification);
        return;
    }
    RouterInterface routerInterface = NatUtil.getConfiguredRouterInterface(dataBroker, targetIfc.getName());
    if (null == routerInterface) {
        LOG.warn("NatArpNotificationHandler: Could not retrieve router ifc for {}", targetIfc);
        return;
    }
    VipState newVipState = this.vipStateTracker.buildVipState(srcIp.getIpv4Address().getValue(), notification.getDpnId(), targetIfc.getName());
    VipState cachedState = null;
    try {
        cachedState = this.vipStateTracker.get(newVipState.getIp()).orElse(null);
    } catch (ReadFailedException e) {
        LOG.warn("NatArpNotificationHandler failed to read vip state {}", notification, e);
    }
    if (null == cachedState) {
        this.southboundEventHandlers.handleAdd(targetIfc.getName(), notification.getDpnId(), routerInterface, newVipState);
    } else if (!cachedState.getDpnId().equals(newVipState.getDpnId())) {
        this.southboundEventHandlers.handleRemove(cachedState.getIfcName(), cachedState.getDpnId(), routerInterface);
        this.southboundEventHandlers.handleAdd(targetIfc.getName(), notification.getDpnId(), routerInterface, newVipState);
    }
}