2 * Copyright (c) 2015 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
8 package org.opendaylight.vpnservice.interfacemgr.servicebindings.flowbased.utilities;
10 import com.google.common.base.Optional;
11 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
12 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
13 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
14 import org.opendaylight.vpnservice.interfacemgr.IfmConstants;
15 import org.opendaylight.vpnservice.interfacemgr.IfmUtil;
16 import org.opendaylight.vpnservice.interfacemgr.commons.InterfaceManagerCommonUtils;
17 import org.opendaylight.vpnservice.mdsalutil.*;
18 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
19 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
20 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
21 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
22 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
23 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
24 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
25 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteMetadataCase;
26 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
27 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
28 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.servicebinding.rev151015.ServiceBindings;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.servicebinding.rev151015.StypeOpenflow;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.servicebinding.rev151015.service.bindings.ServicesInfo;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.servicebinding.rev151015.service.bindings.ServicesInfoKey;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.servicebinding.rev151015.service.bindings.services.info.BoundServices;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfL2vlan;
39 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
40 import org.slf4j.Logger;
41 import org.slf4j.LoggerFactory;
43 import java.math.BigInteger;
44 import java.util.ArrayList;
45 import java.util.List;
47 public class FlowBasedServicesUtils {
48 private static final Logger LOG = LoggerFactory.getLogger(FlowBasedServicesUtils.class);
50 public static ServicesInfo getServicesInfoForInterface(String interfaceName, DataBroker dataBroker) {
51 ServicesInfoKey servicesInfoKey = new ServicesInfoKey(interfaceName);
52 InstanceIdentifier.InstanceIdentifierBuilder<ServicesInfo> servicesInfoIdentifierBuilder =
53 InstanceIdentifier.builder(ServiceBindings.class).child(ServicesInfo.class, servicesInfoKey);
54 Optional<ServicesInfo> servicesInfoOptional = IfmUtil.read(LogicalDatastoreType.CONFIGURATION,
55 servicesInfoIdentifierBuilder.build(), dataBroker);
57 if (servicesInfoOptional.isPresent()) {
58 return servicesInfoOptional.get();
64 public static NodeConnectorId getNodeConnectorIdFromInterface(Interface iface, DataBroker dataBroker) {
65 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState =
66 InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(iface.getName(), dataBroker);
68 List<String> ofportIds = ifState.getLowerLayerIf();
69 return new NodeConnectorId(ofportIds.get(0));
74 public static List<MatchInfo> getMatchInfoForVlanPortAtIngressTable(BigInteger dpId, long portNo, Interface iface) {
75 List<MatchInfo> matches = new ArrayList<>();
76 matches.add(new MatchInfo(MatchFieldType.in_port, new BigInteger[] {dpId, BigInteger.valueOf(portNo)}));
78 IfL2vlan l2vlan = iface.getAugmentation(IfL2vlan.class);
80 vlanId = l2vlan.getVlanId().getValue();
83 LOG.error("VlanId matching support is not fully available in Be.");
84 matches.add(new MatchInfo(MatchFieldType.vlan_vid, new long[]{vlanId}));
89 public static List<MatchInfo> getMatchInfoForTunnelPortAtIngressTable(BigInteger dpId, long portNo, Interface iface) {
90 List<MatchInfo> matches = new ArrayList<MatchInfo>();
91 matches.add(new MatchInfo(MatchFieldType.in_port, new BigInteger[]{dpId, BigInteger.valueOf(portNo)}));
95 public static List<MatchInfo> getMatchInfoForDispatcherTable(BigInteger dpId, Interface iface,
96 int interfaceTag, short servicePriority) {
97 List<MatchInfo> matches = new ArrayList<MatchInfo>();
98 matches.add(new MatchInfo(MatchFieldType.metadata, new BigInteger[] {
99 MetaDataUtil.getMetaDataForLPortDispatcher(interfaceTag, servicePriority),
100 MetaDataUtil.getMetaDataMaskForLPortDispatcher() }));
104 public static Long getLPortTag(Interface iface, DataBroker dataBroker) {
105 /*ParentRefs parentRefs = iface.getAugmentation(ParentRefs.class);
106 String portName = parentRefs.getParentInterface();
107 BigInteger dpIdFromInterface = parentRefs.getDatapathNodeIdentifier();
108 String portKey = FlowBasedServicesUtils.getInterfaceRefInfo(dpIdFromInterface.toString(), portName);
109 if (iface.getType().isAssignableFrom(L2vlan.class)) {
110 InterfacesMetaKey interfacesMetaKey = new InterfacesMetaKey(portKey);
111 InterfacesInfoKey interfacesInfoKey = new InterfacesInfoKey(iface.getName());
112 InterfacesInfo interfacesInfo = VlanInterfaceUtilities.getInterfacesInfoFromConfigDS(interfacesMetaKey,
113 interfacesInfoKey, dataBroker);
114 return interfacesInfo.getLporttag();
115 } else if (iface.getType().isAssignableFrom(Tunnel.class)) {
116 TunnelInterfaceRefInfoKey tunnelInterfaceRefInfoKey = new TunnelInterfaceRefInfoKey(portKey);
117 TunnelInterfaceEntries tunnelInterfaceEntries =
118 TunnelInterfaceUtilities.getTunnelInterfaceRefEntriesFromConfigDs(
119 tunnelInterfaceRefInfoKey, iface.getName(), dataBroker);
120 return tunnelInterfaceEntries.getLportTag();
125 public static void installInterfaceIngressFlow(BigInteger dpId, Interface iface,
126 BoundServices boundServiceNew,
128 List<MatchInfo> matches, int lportTag, short tableId) {
129 List<Instruction> instructions = boundServiceNew.getAugmentation(StypeOpenflow.class).getInstruction();
131 int serviceInstructionsSize = instructions.size();
132 List<Instruction> instructionSet = new ArrayList<Instruction>();
134 IfL2vlan l2vlan = iface.getAugmentation(IfL2vlan.class);
136 vlanId = l2vlan.getVlanId().getValue();
139 // incrementing instructionSize and using it as actionKey. Because it won't clash with any other instructions
140 int actionKey = ++serviceInstructionsSize;
141 instructionSet.add(MDSALUtil.buildAndGetPopVlanActionInstruction(actionKey, ++serviceInstructionsSize));
144 if (lportTag != 0L) {
145 BigInteger[] metadataValues = IfmUtil.mergeOpenflowMetadataWriteInstructions(instructions);
146 short sIndex = boundServiceNew.getServicePriority();
147 BigInteger metadata = MetaDataUtil.getMetaDataForLPortDispatcher(lportTag,
148 ++sIndex, metadataValues[0]);
149 BigInteger metadataMask = MetaDataUtil.getMetaDataMaskForLPortDispatcher(
150 MetaDataUtil.METADATA_MASK_SERVICE_INDEX,
151 MetaDataUtil.METADATA_MASK_LPORT_TAG, metadataValues[1]);
152 instructionSet.add(MDSALUtil.buildAndGetWriteMetadaInstruction(metadata, metadataMask,
153 ++serviceInstructionsSize));
156 if (instructions != null && !instructions.isEmpty()) {
157 for (Instruction info : instructions) {
158 // Skip meta data write as that is handled already
159 if (info.getInstruction() instanceof WriteMetadataCase) {
162 instructionSet.add(info);
166 String serviceRef = boundServiceNew.getServiceName();
167 String flowRef = getFlowRef(dpId, iface.getName(), boundServiceNew);
168 StypeOpenflow stypeOpenflow = boundServiceNew.getAugmentation(StypeOpenflow.class);
169 Flow ingressFlow = MDSALUtil.buildFlowNew(tableId, flowRef,
170 stypeOpenflow.getFlowPriority(), serviceRef, 0, 0,
171 stypeOpenflow.getFlowCookie(), matches, instructionSet);
172 installFlow(dpId, ingressFlow, t);
175 public static void installFlow(BigInteger dpId, Flow flow, WriteTransaction t) {
176 FlowKey flowKey = new FlowKey(new FlowId(flow.getId()));
177 Node nodeDpn = buildInventoryDpnNode(dpId);
178 InstanceIdentifier<Flow> flowInstanceId = InstanceIdentifier.builder(Nodes.class)
179 .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
180 .child(Table.class, new TableKey(flow.getTableId())).child(Flow.class,flowKey).build();
182 t.put(LogicalDatastoreType.CONFIGURATION, flowInstanceId, flow, true);
185 public static void removeFlow(String flowRef, BigInteger dpId, WriteTransaction t) {
186 LOG.debug("Removing Ingress Flows");
187 FlowKey flowKey = new FlowKey(new FlowId(flowRef));
188 Node nodeDpn = buildInventoryDpnNode(dpId);
189 InstanceIdentifier<Flow> flowInstanceId = InstanceIdentifier.builder(Nodes.class)
190 .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
191 .child(Table.class, new TableKey(IfmConstants.VLAN_INTERFACE_INGRESS_TABLE)).child(Flow.class, flowKey).build();
193 t.delete(LogicalDatastoreType.CONFIGURATION, flowInstanceId);
196 private static Node buildInventoryDpnNode(BigInteger dpnId) {
197 NodeId nodeId = new NodeId("openflow:" + dpnId);
198 Node nodeDpn = new NodeBuilder().setId(nodeId).setKey(new NodeKey(nodeId)).build();
203 public static void installLPortDispatcherFlow(BigInteger dpId, BoundServices boundService, Interface iface,
204 WriteTransaction t, int interfaceTag) {
205 LOG.debug("Installing LPort Dispatcher Flows {}, {}", dpId, iface);
206 short serviceIndex = boundService.getServicePriority();
207 String serviceRef = boundService.getServiceName();
208 List<MatchInfo> matches = FlowBasedServicesUtils.getMatchInfoForDispatcherTable(dpId, iface,
209 interfaceTag, serviceIndex);
211 // Get the metadata and mask from the service's write metadata instruction
212 StypeOpenflow stypeOpenFlow = boundService.getAugmentation(StypeOpenflow.class);
213 List<Instruction> serviceInstructions = stypeOpenFlow.getInstruction();
214 int instructionSize = serviceInstructions.size();
215 BigInteger[] metadataValues = IfmUtil.mergeOpenflowMetadataWriteInstructions(serviceInstructions);
216 BigInteger metadata = MetaDataUtil.getMetaDataForLPortDispatcher(interfaceTag, ++serviceIndex, metadataValues[0]);
217 BigInteger metadataMask = MetaDataUtil.getMetaDataMaskForLPortDispatcher(MetaDataUtil.METADATA_MASK_SERVICE_INDEX,
218 MetaDataUtil.METADATA_MASK_LPORT_TAG, metadataValues[1]);
220 // build the final instruction for LPort Dispatcher table flow entry
221 List<Instruction> instructions = new ArrayList<Instruction>();
222 instructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(metadata, metadataMask, ++instructionSize));
223 if (serviceInstructions != null && !serviceInstructions.isEmpty()) {
224 for (Instruction info : serviceInstructions) {
225 // Skip meta data write as that is handled already
226 if (info.getInstruction() instanceof WriteMetadataCase) {
229 instructions.add(info);
233 // build the flow and install it
234 String flowRef = getFlowRef(dpId, iface.getName(), boundService);
235 Flow ingressFlow = MDSALUtil.buildFlowNew(stypeOpenFlow.getDispatcherTableId(), flowRef,
236 boundService.getServicePriority(), serviceRef, 0, 0, stypeOpenFlow.getFlowCookie(), matches, instructions);
237 installFlow(dpId, ingressFlow, t);
240 public static void removeIngressFlow(Interface iface, BoundServices serviceOld, BigInteger dpId, WriteTransaction t) {
241 LOG.debug("Removing Ingress Flows");
242 String flowKeyStr = getFlowRef(dpId, iface.getName(), serviceOld);
243 FlowKey flowKey = new FlowKey(new FlowId(flowKeyStr));
244 Node nodeDpn = buildInventoryDpnNode(dpId);
245 InstanceIdentifier<Flow> flowInstanceId = InstanceIdentifier.builder(Nodes.class)
246 .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
247 .child(Table.class, new TableKey(IfmConstants.VLAN_INTERFACE_INGRESS_TABLE)).child(Flow.class, flowKey).build();
249 t.delete(LogicalDatastoreType.CONFIGURATION, flowInstanceId);
252 public static void removeLPortDispatcherFlow(BigInteger dpId, Interface iface, BoundServices boundServicesOld, WriteTransaction t) {
253 LOG.debug("Removing LPort Dispatcher Flows {}, {}", dpId, iface);
255 StypeOpenflow stypeOpenFlow = boundServicesOld.getAugmentation(StypeOpenflow.class);
256 // build the flow and install it
257 String flowRef = getFlowRef(dpId, iface.getName(), boundServicesOld);
258 FlowKey flowKey = new FlowKey(new FlowId(flowRef));
259 Node nodeDpn = buildInventoryDpnNode(dpId);
260 InstanceIdentifier<Flow> flowInstanceId = InstanceIdentifier.builder(Nodes.class)
261 .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
262 .child(Table.class, new TableKey(stypeOpenFlow.getDispatcherTableId())).child(Flow.class, flowKey).build();
264 t.delete(LogicalDatastoreType.CONFIGURATION, flowInstanceId);
267 private static String getFlowRef(BigInteger dpnId, String iface, BoundServices service) {
268 return new StringBuffer().append(dpnId).append(IfmConstants.VLAN_INTERFACE_INGRESS_TABLE).append(NwConstants.FLOWID_SEPARATOR)
269 .append(iface).append(NwConstants.FLOWID_SEPARATOR).append(service.getServiceName()).append(NwConstants.FLOWID_SEPARATOR)
270 .append(service.getServicePriority()).toString();