vpnservice/sfc/classifier/impl/src/main/java/org/opendaylight/netvirt/sfc/classifier/service/domain/impl/ConfigurationClassifierImpl.java

   1 /*
   2  * Copyright (c) 2017 Ericsson Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8
   9 package org.opendaylight.netvirt.sfc.classifier.service.domain.impl;
  10
  11 import java.util.ArrayList;
  12 import java.util.Collections;
  13 import java.util.HashMap;
  14 import java.util.HashSet;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Objects;
  18 import java.util.Optional;
  19 import java.util.Set;
  20 import java.util.stream.Collectors;
  21 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  24 import org.opendaylight.netvirt.sfc.classifier.providers.GeniusProvider;
  25 import org.opendaylight.netvirt.sfc.classifier.providers.NetvirtProvider;
  26 import org.opendaylight.netvirt.sfc.classifier.providers.OpenFlow13Provider;
  27 import org.opendaylight.netvirt.sfc.classifier.providers.SfcProvider;
  28 import org.opendaylight.netvirt.sfc.classifier.service.domain.ClassifierEntry;
  29 import org.opendaylight.netvirt.sfc.classifier.service.domain.api.ClassifierRenderableEntry;
  30 import org.opendaylight.netvirt.sfc.classifier.service.domain.api.ClassifierState;
  31 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.rendered.service.paths.RenderedServicePath;
  32 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.sfc.sff.logical.rev160620.DpnIdType;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.AccessLists;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.Acl;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.AccessListEntries;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.Ace;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.Actions;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.Matches;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.sfc.acl.rev150105.NeutronNetwork;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.sfc.acl.rev150105.RedirectToSfc;
  45 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  46 import org.slf4j.Logger;
  47 import org.slf4j.LoggerFactory;
  48
  49 public class ConfigurationClassifierImpl implements ClassifierState {
  50
  51     private final SfcProvider sfcProvider;
  52     private final DataBroker dataBroker;
  53     private final GeniusProvider geniusProvider;
  54     private final NetvirtProvider netvirtProvider;
  55     private static final Logger LOG = LoggerFactory.getLogger(ConfigurationClassifierImpl.class);
  56
  57     public ConfigurationClassifierImpl(GeniusProvider geniusProvider,
  58                                        NetvirtProvider netvirtProvider,
  59                                        SfcProvider sfcProvider,
  60                                        DataBroker dataBroker) {
  61         this.geniusProvider = geniusProvider;
  62         this.netvirtProvider = netvirtProvider;
  63         this.sfcProvider = sfcProvider;
  64         this.dataBroker = dataBroker;
  65     }
  66
  67     @Override
  68     public Set<ClassifierRenderableEntry> getAllEntries() {
  69         return readAcls().stream()
  70                 .map(Acl::getAccessListEntries)
  71                 .filter(Objects::nonNull)
  72                 .map(AccessListEntries::getAce)
  73                 .filter(Objects::nonNull)
  74                 .flatMap(List::stream)
  75                 .map(this::getEntries)
  76                 .flatMap(Set::stream)
  77                 .collect(Collectors.toSet());
  78     }
  79
  80     public List<Acl> readAcls() {
  81         InstanceIdentifier<AccessLists> aclsIID = InstanceIdentifier.builder(AccessLists.class).build();
  82         com.google.common.base.Optional<AccessLists> acls =
  83                 MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, aclsIID);
  84         LOG.trace("Acls read from datastore: {}", acls);
  85         return acls.transform(AccessLists::getAcl).or(Collections.emptyList());
  86     }
  87
  88     public Set<ClassifierRenderableEntry> getEntries(Ace ace) {
  89
  90         LOG.trace("Get entries for Ace {}", ace);
  91
  92         Matches matches = ace.getMatches();
  93
  94         if (matches == null) {
  95             LOG.trace("Ace has no matches");
  96             return Collections.emptySet();
  97         }
  98
  99         Actions actions = ace.getActions();
 100         RenderedServicePath rsp = null;
 101         if (actions != null) {
 102             rsp = sfcProvider.getRenderedServicePath(actions.getAugmentation(RedirectToSfc.class).getRspName())
 103                     .orElse(null);
 104         }
 105
 106         if (rsp == null) {
 107             LOG.trace("Ace has no valid SFC redirect action");
 108             return Collections.emptySet();
 109         }
 110
 111         Long nsp = rsp.getPathId();
 112         Short nsi = rsp.getStartingIndex();
 113
 114         if (nsp == null || nsi == null) {
 115             LOG.trace("RSP has no valid NSI or NSP");
 116             return Collections.emptySet();
 117         }
 118
 119         String firstHopIp = sfcProvider.getFirstHopSfInterfaceFromRsp(rsp)
 120                 .flatMap(geniusProvider::getIpFromInterfaceName)
 121                 .orElse(null);
 122
 123         if (firstHopIp == null) {
 124             LOG.trace("Could not acquire a valid first RSP hop destination ip");
 125             return Collections.emptySet();
 126         }
 127
 128         Map<NodeId, List<InterfaceKey>> nodeToInterfaces = new HashMap<>();
 129         NeutronNetwork neutronNetwork = matches.getAugmentation(NeutronNetwork.class);
 130         if (neutronNetwork != null) {
 131             for (String iface : netvirtProvider.getLogicalInterfacesFromNeutronNetwork(neutronNetwork)) {
 132                 geniusProvider.getNodeIdFromLogicalInterface(iface).ifPresent(
 133                     nodeId -> nodeToInterfaces.computeIfAbsent(nodeId, key -> new ArrayList<>()).add(
 134                             new InterfaceKey(iface)));
 135             }
 136         }
 137
 138         LOG.trace("Got classifier nodes and interfaces: {}", nodeToInterfaces);
 139
 140         Set<ClassifierRenderableEntry> entries = new HashSet<>();
 141         nodeToInterfaces.forEach((nodeId, ifaces) -> {
 142             // Get node info
 143             DpnIdType dpnIdType = new DpnIdType(OpenFlow13Provider.getDpnIdFromNodeId(nodeId));
 144             List<String> nodeIps = geniusProvider.getIpFromDpnId(dpnIdType).stream()
 145                     .map(IpAddress::getIpv4Address)
 146                     .filter(Objects::nonNull)
 147                     .map(Ipv4Address::getValue)
 148                     .collect(Collectors.toList());
 149             String nodeIp = nodeIps.isEmpty() ? null : nodeIps.get(0);
 150
 151             if (nodeIp == null) {
 152                 LOG.trace("Could not get IP address for node {}, skipping", nodeId.getValue());
 153                 return;
 154             }
 155
 156             // Add entries that are not based on ingress or egress interface
 157             entries.add(ClassifierEntry.buildNodeEntry(nodeId));
 158             entries.add(ClassifierEntry.buildPathEntry(
 159                     nodeId,
 160                     nsp,
 161                     nodeIps.contains(firstHopIp) ? null : firstHopIp));
 162
 163             // Add entries based on ingress interface
 164             ifaces.forEach(interfaceKey -> {
 165                 entries.add(ClassifierEntry.buildIngressEntry(interfaceKey));
 166                 entries.add(ClassifierEntry.buildMatchEntry(
 167                         nodeId,
 168                         geniusProvider.getNodeConnectorIdFromInterfaceName(interfaceKey.getName()).get(),
 169                         matches,
 170                         nsp,
 171                         nsi));
 172             });
 173
 174             // Egress services must bind to egress ports. Since we dont know before-hand what
 175             // the egress ports will be, we will bind on all switch ports. If the packet
 176             // doesnt have NSH, it will be returned to the the egress dispatcher table.
 177             List<String> interfaceUuidStrList = geniusProvider.getInterfacesFromNode(nodeId);
 178             interfaceUuidStrList.forEach(interfaceUuidStr -> {
 179                 InterfaceKey interfaceKey = new InterfaceKey(interfaceUuidStr);
 180                 Optional<String> remoteIp = geniusProvider.getRemoteIpAddress(interfaceUuidStr);
 181                 entries.add(ClassifierEntry.buildEgressEntry(interfaceKey, remoteIp.orElse(nodeIp)));
 182             });
 183         });
 184
 185         return entries;
 186     }
 187 }