2 * Copyright (c) 2017 Hewlett Packard Enterprise, Co. 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.netvirt.policyservice.util;
11 import com.google.common.base.Optional;
12 import java.math.BigInteger;
13 import java.util.Collection;
14 import java.util.Collections;
15 import java.util.List;
17 import java.util.Objects;
18 import java.util.concurrent.ExecutionException;
19 import java.util.concurrent.Future;
20 import java.util.stream.Collectors;
21 import javax.annotation.Nonnull;
22 import javax.inject.Inject;
23 import javax.inject.Singleton;
24 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
25 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
26 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
27 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
28 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
29 import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
30 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
31 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
32 import org.opendaylight.netvirt.elanmanager.api.IElanBridgeManager;
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.AclBase;
35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.Acl;
36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.AclKey;
37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.AccessListEntries;
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;
39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.AceKey;
40 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;
41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
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.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan.L2vlanMode;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeLogicalGroup;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameInputBuilder;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameOutput;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.DirectionBase;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.DirectionEgress;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.PolicyAcl;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.PolicyProfiles;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.SetPolicyClassifier;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.UnderlayNetworks;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.policy.profiles.PolicyProfile;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.policy.profiles.PolicyProfileKey;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.policy.profiles.policy.profile.PolicyAclRule;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.policy.profiles.policy.profile.PolicyAclRuleKey;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.policy.profiles.policy.profile.PolicyRoute;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.policy.profiles.policy.profile.policy.acl.rule.AceRule;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.policy.profiles.policy.profile.policy.acl.rule.AceRuleBuilder;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.policy.profiles.policy.profile.policy.acl.rule.AceRuleKey;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.policy.profiles.policy.profile.policy.route.route.BasicRoute;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks.UnderlayNetwork;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks.UnderlayNetworkKey;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks.underlay.network.DpnToInterface;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks.underlay.network.DpnToInterfaceBuilder;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks.underlay.network.DpnToInterfaceKey;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks.underlay.network.PolicyProfileBuilder;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks.underlay.network.dpn.to._interface.TunnelInterface;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks.underlay.network.dpn.to._interface.TunnelInterfaceBuilder;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks.underlay.network.dpn.to._interface.TunnelInterfaceKey;
74 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
75 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
76 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
77 import org.opendaylight.yangtools.yang.common.RpcResult;
78 import org.slf4j.Logger;
79 import org.slf4j.LoggerFactory;
82 public class PolicyServiceUtil {
83 private static final Logger LOG = LoggerFactory.getLogger(PolicyServiceUtil.class);
85 public static final String LOCAL_IPS = "local_ips";
87 private final DataBroker dataBroker;
88 private final IElanBridgeManager bridgeManager;
89 private final ItmRpcService itmRpcService;
90 private final IInterfaceManager interfaceManager;
91 private final JobCoordinator coordinator;
94 public PolicyServiceUtil(final DataBroker dataBroker, final IElanBridgeManager bridgeManager,
95 final ItmRpcService itmRpcService, final IInterfaceManager interfaceManager,
96 final JobCoordinator coordinator) {
97 this.dataBroker = dataBroker;
98 this.bridgeManager = bridgeManager;
99 this.itmRpcService = itmRpcService;
100 this.interfaceManager = interfaceManager;
101 this.coordinator = coordinator;
104 public Optional<String> getAcePolicyClassifier(Ace ace) {
105 Actions actions = ace.getActions();
106 SetPolicyClassifier setPolicyClassifier = actions.augmentation(SetPolicyClassifier.class);
107 if (setPolicyClassifier == null) {
108 LOG.warn("No valid policy action found for ACE rule {}", ace.getRuleName());
109 return Optional.absent();
112 Class<? extends DirectionBase> direction;
114 direction = setPolicyClassifier.getDirection();
115 } catch (IllegalArgumentException e) {
116 LOG.warn("Failed to parse policy classifier direction");
117 return Optional.absent();
120 if (direction == null || !direction.isAssignableFrom(DirectionEgress.class)) {
121 LOG.trace("Ignoring non egress policy ACE rule {}", ace.getRuleName());
122 return Optional.absent();
125 return Optional.of(setPolicyClassifier.getPolicyClassifier());
128 public Optional<Ace> getPolicyAce(String aclName, String ruleName) {
129 InstanceIdentifier<Ace> identifier = getAceIdentifier(aclName, ruleName);
131 return SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
133 } catch (ReadFailedException e) {
134 LOG.warn("Failed to get policy ACE rule {} for ACL {}", ruleName, aclName);
135 return Optional.absent();
139 public List<PolicyProfile> getAllPolicyProfiles() {
140 InstanceIdentifier<PolicyProfiles> identifier = InstanceIdentifier.create(PolicyProfiles.class);
142 Optional<PolicyProfiles> optProfiles = SingleTransactionDataBroker.syncReadOptional(dataBroker,
143 LogicalDatastoreType.CONFIGURATION, identifier);
144 return optProfiles.isPresent() ? optProfiles.get().getPolicyProfile() : Collections.emptyList();
145 } catch (ReadFailedException e) {
146 LOG.warn("Failed to get policy profiles");
147 return Collections.emptyList();
151 public List<String> getUnderlayNetworksForClassifier(String policyClassifier) {
152 InstanceIdentifier<PolicyProfile> identifier = getPolicyClassifierIdentifier(policyClassifier);
154 Optional<PolicyProfile> optProfile = SingleTransactionDataBroker.syncReadOptional(dataBroker,
155 LogicalDatastoreType.CONFIGURATION, identifier);
156 return optProfile.isPresent() ? getUnderlayNetworksFromPolicyRoutes(optProfile.get().getPolicyRoute())
157 : Collections.emptyList();
158 } catch (ReadFailedException e) {
159 LOG.warn("Failed to get policy routes for classifier {}", policyClassifier);
160 return Collections.emptyList();
164 public List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks.underlay
165 .network.PolicyProfile> getUnderlayNetworkPolicyProfiles(String underlayNetwork) {
166 InstanceIdentifier<UnderlayNetwork> identifier = getUnderlayNetworkIdentifier(underlayNetwork);
168 Optional<UnderlayNetwork> optUnderlayNet = SingleTransactionDataBroker.syncReadOptional(dataBroker,
169 LogicalDatastoreType.OPERATIONAL, identifier);
170 return optUnderlayNet.isPresent() ? optUnderlayNet.get().getPolicyProfile() : Collections.emptyList();
171 } catch (ReadFailedException e) {
172 LOG.warn("Failed to get policy classifiers for underlay network {}", underlayNetwork);
173 return Collections.emptyList();
177 public List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.policy.profiles.policy.profile
178 .PolicyAclRule> getPolicyClassifierAclRules(String policyClassifier) {
179 InstanceIdentifier<PolicyProfile> identifier = getPolicyClassifierIdentifier(policyClassifier);
181 Optional<PolicyProfile> optProfile = SingleTransactionDataBroker.syncReadOptional(dataBroker,
182 LogicalDatastoreType.OPERATIONAL, identifier);
183 return optProfile.isPresent() ? optProfile.get().getPolicyAclRule() : Collections.emptyList();
184 } catch (ReadFailedException e) {
185 LOG.warn("Failed to get policy rules for policy classifier {}", policyClassifier);
186 return Collections.emptyList();
190 public void updateTunnelInterfaceForUnderlayNetwork(String underlayNetwork, BigInteger srcDpId, BigInteger dstDpId,
191 String tunnelInterfaceName, boolean isAdded) {
192 coordinator.enqueueJob(underlayNetwork, () -> {
193 InstanceIdentifier<TunnelInterface> identifier = getUnderlayNetworkTunnelIdentifier(underlayNetwork,
194 srcDpId, tunnelInterfaceName);
195 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
197 TunnelInterface tunnelInterface = new TunnelInterfaceBuilder().setInterfaceName(tunnelInterfaceName)
198 .setRemoteDpId(dstDpId).build();
199 tx.merge(LogicalDatastoreType.OPERATIONAL, identifier, tunnelInterface, true);
200 LOG.info("Add tunnel {} on DPN {} to underlay network {}", tunnelInterfaceName, srcDpId,
203 tx.delete(LogicalDatastoreType.OPERATIONAL, identifier);
204 LOG.info("Remove tunnel {} from DPN {} on underlay network {}", tunnelInterfaceName, srcDpId,
207 return Collections.singletonList(tx.submit());
211 public void updateTunnelInterfacesForUnderlayNetwork(String underlayNetwork, BigInteger srcDpId,
212 List<TunnelInterface> tunnelInterfaces, boolean isAdded) {
213 coordinator.enqueueJob(underlayNetwork, () -> {
214 InstanceIdentifier<DpnToInterface> identifier = getUnderlayNetworkDpnIdentifier(underlayNetwork, srcDpId);
215 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
217 DpnToInterface dpnToInterface = new DpnToInterfaceBuilder().setDpId(srcDpId)
218 .setTunnelInterface(tunnelInterfaces).build();
219 tx.merge(LogicalDatastoreType.OPERATIONAL, identifier, dpnToInterface, true);
220 LOG.info("Add tunnel interfaces {} on DPN {} to underlay network {}", tunnelInterfaces, srcDpId,
223 tx.delete(LogicalDatastoreType.OPERATIONAL, identifier);
224 LOG.info("Remove tunnel interfaces {} from DPN {} on underlay network {}", tunnelInterfaces, srcDpId,
227 return Collections.singletonList(tx.submit());
231 public void updatePolicyClassifierForUnderlayNetworks(List<String> underlayNetworks, String policyClassifier,
233 if (underlayNetworks == null || underlayNetworks.isEmpty()) {
234 LOG.debug("No underlay networks found for policy classifier {}", policyClassifier);
238 underlayNetworks.forEach(underlayNetwork -> coordinator.enqueueJob(underlayNetwork, () -> {
239 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
241 org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks
242 .underlay.network.PolicyProfile> identifier = getUnderlayNetworkPolicyClassifierIdentifier(
243 policyClassifier, underlayNetwork);
246 tx.merge(LogicalDatastoreType.OPERATIONAL, identifier,
247 new PolicyProfileBuilder().setPolicyClassifier(policyClassifier).build(), true);
248 LOG.info("Add policy classifier {} to underlay network {}", policyClassifier, underlayNetwork);
250 tx.delete(LogicalDatastoreType.OPERATIONAL, identifier);
251 LOG.info("Remove policy classifier {} from underlay network {}", policyClassifier, underlayNetwork);
253 return Collections.singletonList(tx.submit());
257 public void updateAclRuleForPolicyClassifier(String policyClassifier, String aclName, String ruleName,
259 coordinator.enqueueJob(policyClassifier, () -> {
261 AceRule> identifier = getPolicyClassifierAceIdentifier(policyClassifier, aclName, ruleName);
262 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
264 tx.merge(LogicalDatastoreType.OPERATIONAL, identifier,
265 new AceRuleBuilder().setRuleName(ruleName).build(), true);
266 LOG.info("Add ACL {} rule {} to policy classifier {}", aclName, ruleName, policyClassifier);
268 tx.delete(LogicalDatastoreType.OPERATIONAL, identifier);
269 LOG.info("Remove ACL {} rule {} from policy classifier {}", aclName, ruleName, policyClassifier);
271 return Collections.singletonList(tx.submit());
275 public List<BigInteger> getUnderlayNetworksDpns(List<String> underlayNetworks) {
276 if (underlayNetworks == null) {
277 return Collections.emptyList();
280 return underlayNetworks.stream().flatMap(t -> getUnderlayNetworkDpns(t).stream()).distinct()
281 .collect(Collectors.toList());
284 public List<BigInteger> getUnderlayNetworksRemoteDpns(List<String> underlayNetworks) {
285 if (underlayNetworks == null) {
286 return Collections.emptyList();
289 return underlayNetworks.stream().map(this::getUnderlayNetworkRemoteDpns).flatMap(Collection::stream).distinct()
290 .collect(Collectors.toList());
293 public boolean underlayNetworkContainsDpn(String underlayNetwork, BigInteger dpId) {
294 return dpnToInterfacesContainsDpn(getUnderlayNetworkDpnToInterfaces(underlayNetwork), dpId);
297 public boolean underlayNetworkContainsRemoteDpn(String underlayNetwork, BigInteger dpId) {
298 return dpnToInterfacesContainsRemoteDpn(getUnderlayNetworkDpnToInterfaces(underlayNetwork), dpId);
301 public static boolean dpnToInterfacesContainsDpn(List<DpnToInterface> dpnToInterfaces, BigInteger dpId) {
302 return dpnToInterfaces != null && dpnToInterfaces.stream().anyMatch(
303 dpnToInterface -> dpnToInterface.getDpId().equals(dpId));
306 public static boolean dpnToInterfacesContainsRemoteDpn(List<DpnToInterface> dpnToInterfaces, BigInteger dpId) {
307 return dpnToInterfaces != null && dpnToInterfaces.stream().anyMatch(
308 dpnToInterface -> dpnToInterfaceContainsRemoteDpn(dpnToInterface, dpId));
311 public static boolean dpnToInterfaceContainsRemoteDpn(DpnToInterface dpnToInterface, BigInteger dpId) {
312 List<TunnelInterface> tunnelInterfaces = dpnToInterface.getTunnelInterface();
313 return tunnelInterfaces != null && tunnelInterfaces.stream().anyMatch(
314 tunnelInterface -> tunnelInterface.getRemoteDpId().equals(dpId));
317 public String getTunnelUnderlayNetwork(BigInteger dpId, IpAddress tunnelIp) {
318 Node ovsdbNode = bridgeManager.getBridgeNode(dpId);
319 if (ovsdbNode == null) {
320 LOG.error("Failed to get OVSDB node for DPN {}", dpId);
324 Map<String, String> localIpMap = bridgeManager.getOpenvswitchOtherConfigMap(ovsdbNode, LOCAL_IPS);
325 return localIpMap.get(String.valueOf(tunnelIp.getValue()));
328 public static List<BigInteger> getDpnsFromDpnToInterfaces(List<DpnToInterface> dpnToInterfaces) {
329 if (dpnToInterfaces == null) {
330 return Collections.emptyList();
333 return dpnToInterfaces.stream().map(DpnToInterface::getDpId).collect(Collectors.toList());
336 public static List<BigInteger> getRemoteDpnsFromDpnToInterfaces(List<DpnToInterface> dpnToInterfaces) {
337 if (dpnToInterfaces == null) {
338 return Collections.emptyList();
341 return dpnToInterfaces.stream().map(PolicyServiceUtil::getRemoteDpnsFromDpnToInterface)
342 .flatMap(Collection::stream).distinct().collect(Collectors.toList());
345 public static List<BigInteger> getRemoteDpnsFromDpnToInterface(DpnToInterface dpnToInterface) {
346 List<TunnelInterface> tunnelInterfaces = dpnToInterface.getTunnelInterface();
347 if (tunnelInterfaces == null) {
348 return Collections.emptyList();
351 return tunnelInterfaces.stream().map(TunnelInterface::getRemoteDpId)
352 .collect(Collectors.toList());
355 public static List<String> getUnderlayNetworksFromPolicyRoutes(List<PolicyRoute> policyRoutes) {
356 if (policyRoutes == null) {
357 return Collections.emptyList();
360 return policyRoutes.stream().map(PolicyRoute::getRoute)
361 .filter(route -> route instanceof BasicRoute).map(route -> ((BasicRoute) route).getNetworkName())
362 .collect(Collectors.toList());
365 public static boolean isPolicyAcl(Class<? extends AclBase> aclType) {
366 return aclType != null && aclType.isAssignableFrom(PolicyAcl.class);
370 public List<DpnToInterface> getUnderlayNetworkDpnToInterfaces(String underlayNetwork) {
371 InstanceIdentifier<UnderlayNetwork> identifier = InstanceIdentifier.create(UnderlayNetworks.class)
372 .child(UnderlayNetwork.class, new UnderlayNetworkKey(underlayNetwork));
374 return SingleTransactionDataBroker
375 .syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier)
376 .toJavaUtil().map(UnderlayNetwork::getDpnToInterface)
377 .orElse(Collections.emptyList());
378 } catch (ReadFailedException e) {
379 LOG.warn("Failed to get DPNs for underlay network {}", underlayNetwork);
380 return Collections.emptyList();
384 public Optional<DpnToInterface> getUnderlayNetworkDpnToInterfaces(String underlayNetwork, BigInteger dpId) {
385 InstanceIdentifier<DpnToInterface> identifier = getUnderlayNetworkDpnIdentifier(underlayNetwork, dpId);
387 Optional<DpnToInterface> dpnToInterfaceOpt = SingleTransactionDataBroker.syncReadOptional(dataBroker,
388 LogicalDatastoreType.OPERATIONAL, identifier);
389 return dpnToInterfaceOpt;
390 } catch (ReadFailedException e) {
391 LOG.warn("Failed to get DPN {} for underlay network {}", dpId, underlayNetwork);
392 return Optional.absent();
396 private InstanceIdentifier<UnderlayNetwork> getUnderlayNetworkIdentifier(String underlayNetwork) {
397 return InstanceIdentifier.create(UnderlayNetworks.class).child(UnderlayNetwork.class,
398 new UnderlayNetworkKey(underlayNetwork));
401 private InstanceIdentifier<DpnToInterface> getUnderlayNetworkDpnIdentifier(String underlayNetwork,
403 return InstanceIdentifier.create(UnderlayNetworks.class)
404 .child(UnderlayNetwork.class, new UnderlayNetworkKey(underlayNetwork))
405 .child(DpnToInterface.class, new DpnToInterfaceKey(dpId));
408 private InstanceIdentifier<TunnelInterface> getUnderlayNetworkTunnelIdentifier(String underlayNetwork,
409 BigInteger dpId, String tunnelInterface) {
410 return InstanceIdentifier.create(UnderlayNetworks.class)
411 .child(UnderlayNetwork.class, new UnderlayNetworkKey(underlayNetwork))
412 .child(DpnToInterface.class, new DpnToInterfaceKey(dpId))
413 .child(TunnelInterface.class, new TunnelInterfaceKey(tunnelInterface));
416 private InstanceIdentifier<PolicyProfile> getPolicyClassifierIdentifier(String policyClassifier) {
417 return InstanceIdentifier.create(PolicyProfiles.class).child(PolicyProfile.class,
418 new PolicyProfileKey(policyClassifier));
421 private InstanceIdentifier<Ace> getAceIdentifier(String aclName, String ruleName) {
422 return InstanceIdentifier.create(AccessLists.class).child(Acl.class, new AclKey(aclName, PolicyAcl.class))
423 .child(AccessListEntries.class).child(Ace.class, new AceKey(ruleName));
426 private KeyedInstanceIdentifier<AceRule, AceRuleKey> getPolicyClassifierAceIdentifier(String policyClassifier,
427 String aclName, String ruleName) {
428 return InstanceIdentifier.create(PolicyProfiles.class)
429 .child(PolicyProfile.class, new PolicyProfileKey(policyClassifier))
430 .child(PolicyAclRule.class, new PolicyAclRuleKey(aclName))
431 .child(AceRule.class, new AceRuleKey(ruleName));
434 private InstanceIdentifier<
435 org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks.underlay.network
436 .PolicyProfile> getUnderlayNetworkPolicyClassifierIdentifier(String policyClassifier,
437 String underlayNetwork) {
438 return InstanceIdentifier.create(UnderlayNetworks.class)
439 .child(UnderlayNetwork.class, new UnderlayNetworkKey(underlayNetwork))
440 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.policy.rev170207.underlay.networks
441 .underlay.network.PolicyProfile.class, new org.opendaylight.yang.gen.v1.urn.opendaylight
442 .netvirt.policy.rev170207.underlay.networks.underlay.network
443 .PolicyProfileKey(policyClassifier));
446 public List<BigInteger> getUnderlayNetworkDpns(String underlayNetwork) {
447 return getDpnsFromDpnToInterfaces(getUnderlayNetworkDpnToInterfaces(underlayNetwork));
450 public List<BigInteger> getUnderlayNetworkRemoteDpns(String underlayNetwork) {
451 return getRemoteDpnsFromDpnToInterfaces(getUnderlayNetworkDpnToInterfaces(underlayNetwork));
455 public Optional<Integer> getLogicalTunnelLportTag(BigInteger srcDpId, BigInteger dstDpId) {
456 Optional<String> logicalTunnelNameOpt = getLogicalTunnelName(srcDpId, dstDpId);
457 if (!logicalTunnelNameOpt.isPresent()) {
458 LOG.debug("Failed to get logical tunnel for source DPN {} dst DPN {}", srcDpId, dstDpId);
459 return Optional.absent();
462 String logicalTunnelName = logicalTunnelNameOpt.get();
463 InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(logicalTunnelName);
464 if (interfaceInfo == null) {
465 LOG.debug("Failed to get interface info for logical tunnel {}", logicalTunnelName);
466 return Optional.absent();
469 return Optional.of(interfaceInfo.getInterfaceTag());
472 public Optional<String> getLogicalTunnelName(BigInteger srcDpId, BigInteger dstDpId) {
473 Future<RpcResult<GetTunnelInterfaceNameOutput>> tunnelInterfaceOutput = itmRpcService
474 .getTunnelInterfaceName(new GetTunnelInterfaceNameInputBuilder().setSourceDpid(srcDpId)
475 .setDestinationDpid(dstDpId).setTunnelType(TunnelTypeLogicalGroup.class).build());
477 if (tunnelInterfaceOutput.get().isSuccessful()) {
478 return Optional.of(tunnelInterfaceOutput.get().getResult().getInterfaceName());
480 } catch (InterruptedException | ExecutionException e) {
481 LOG.error("Error in RPC call getTunnelInterfaceName for source DPN {} dst DPN {}", srcDpId, dstDpId, e);
484 return Optional.absent();
488 public Optional<String> getVlanMemberInterface(String trunkInterface, VlanId vlanId) {
489 List<Interface> vlanMemberInterfaces = interfaceManager.getChildInterfaces(trunkInterface);
490 if (vlanMemberInterfaces == null || vlanMemberInterfaces.isEmpty()) {
491 LOG.debug("No child interfaces found for trunk {}", trunkInterface);
492 return Optional.absent();
495 return vlanMemberInterfaces.stream()
496 .filter(iface -> isVlanMemberInterface(iface, vlanId))
498 .map(Interface::getName)
500 .orElseGet(Optional::absent);
503 private boolean isVlanMemberInterface(Interface iface, VlanId vlanId) {
504 IfL2vlan l2vlan = iface.augmentation(IfL2vlan.class);
505 if (l2vlan == null || !L2vlanMode.TrunkMember.equals(l2vlan.getL2vlanMode())) {
506 LOG.warn("Interface {} is not VLAN member", iface.getName());
510 return Objects.equals(vlanId, l2vlan.getVlanId());