2 * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.
\r
4 * This program and the accompanying materials are made available under the
\r
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
\r
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
\r
9 package org.opendaylight.nemo.renderer.openflow;
\r
11 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
\r
12 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
\r
13 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
\r
14 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
\r
15 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
\r
16 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
\r
17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
\r
18 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.*;
\r
19 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.mpls.ttl._case.DecMplsTtl;
\r
20 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.mpls.ttl._case.DecMplsTtlBuilder;
\r
21 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.nw.ttl._case.DecNwTtl;
\r
22 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.nw.ttl._case.DecNwTtlBuilder;
\r
23 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.output.action._case.OutputAction;
\r
24 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.output.action._case.OutputActionBuilder;
\r
25 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.mpls.action._case.PopMplsAction;
\r
26 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.mpls.action._case.PopMplsActionBuilder;
\r
27 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.mpls.action._case.PushMplsAction;
\r
28 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.mpls.action._case.PushMplsActionBuilder;
\r
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.field._case.SetField;
\r
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.field._case.SetFieldBuilder;
\r
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
\r
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
\r
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
\r
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
\r
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
\r
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.MeterBuilder;
\r
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.MeterKey;
\r
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
\r
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
\r
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
\r
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
\r
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
\r
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Instructions;
\r
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.InstructionsBuilder;
\r
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match;
\r
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
\r
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.*;
\r
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActions;
\r
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder;
\r
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.go.to.table._case.GoToTable;
\r
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.go.to.table._case.GoToTableBuilder;
\r
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.write.metadata._case.WriteMetadata;
\r
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.write.metadata._case.WriteMetadataBuilder;
\r
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
\r
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
\r
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.*;
\r
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
\r
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
\r
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
\r
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
\r
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.EtherType;
\r
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.BandId;
\r
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterBandType;
\r
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterFlags;
\r
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
\r
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.Drop;
\r
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.DropBuilder;
\r
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.MeterBandHeadersBuilder;
\r
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeader;
\r
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeaderBuilder;
\r
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeaderKey;
\r
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.meter.band.header.MeterBandTypesBuilder;
\r
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetDestinationBuilder;
\r
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetSourceBuilder;
\r
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetTypeBuilder;
\r
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.*;
\r
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4Match;
\r
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4MatchBuilder;
\r
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.PhysicalNetwork;
\r
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.PhysicalLinks;
\r
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.PhysicalPaths;
\r
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.links.PhysicalLink;
\r
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.nodes.PhysicalNode;
\r
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.paths.PhysicalPath;
\r
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.paths.PhysicalPathBuilder;
\r
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.instance.PhysicalPort;
\r
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.VirtualNetwork;
\r
88 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.arps.VirtualArp;
\r
89 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.arps.VirtualArpKey;
\r
90 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.links.VirtualLink;
\r
91 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.nodes.VirtualNode;
\r
92 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.paths.VirtualPath;
\r
93 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.node.instance.VirtualPort;
\r
94 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.intent.mapping.result.rev151010.intent.vn.mapping.results.UserIntentVnMapping;
\r
95 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.intent.mapping.result.rev151010.intent.vn.mapping.results.user.intent.vn.mapping.IntentVnMappingResult;
\r
96 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.intent.mapping.result.rev151010.intent.vn.mapping.results.user.intent.vn.mapping.intent.vn.mapping.result.VirtualResource;
\r
97 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.intent.mapping.result.rev151010.vn.pn.mapping.results.UserVnPnMapping;
\r
98 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.intent.mapping.result.rev151010.vn.pn.mapping.results.user.vn.pn.mapping.VnPnMappingResult;
\r
99 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.IntentId;
\r
100 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.MatchItemName;
\r
101 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId;
\r
102 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.*;
\r
103 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.operations.Operation;
\r
104 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.User;
\r
105 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItem;
\r
106 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
\r
107 import org.slf4j.Logger;
\r
108 import org.slf4j.LoggerFactory;
\r
110 import java.math.BigInteger;
\r
111 import java.util.*;
\r
113 public class FlowUtils implements AutoCloseable {
\r
114 private static final Logger LOG = LoggerFactory.getLogger(FlowUtils.class);
\r
116 private static final short IN_PORT_TABLE_ID = 0;
\r
117 private static final short MPLS_LABEL_TABLE_ID = 1;
\r
118 private static final short MAC_TABLE_ID = 2;
\r
119 private static final short IP_TABLE_ID = 3;
\r
120 private static final short ARP_TABLE_ID = 4;
\r
122 private static final int DEFAULT_FLOW_PRIORITY = 0;
\r
123 private static final String DEFAULT_METADATA_MASK = "ffffffffffffffff";
\r
125 private static final int ETH_TYPE_IP = 0x0800;
\r
126 private static final int ETH_TYPE_MPLS = 0x8847;
\r
127 private static final int ETH_TYPE_ARP = 0x0806;
\r
129 private final DataBroker dataBroker;
\r
131 private Map<PhysicalNodeId, MplsLabelGenerator> mplsGenerators;
\r
132 private Map<PhysicalNodeId, MeterIdGenerator> meterIdGenerators;
\r
133 private Map<PhysicalPathId, List<Integer>> mplsLabelsOfPhysicalPaths;
\r
134 private Map<PhysicalPathId, Long> meterIdsOfPhysicalPaths;
\r
135 private Map<UserId, Long> metadatas;
\r
136 private long currentMetadata = 0;
\r
138 private PhysicalNetworkHelper physicalNetworkHelper;
\r
139 private VirtualNetworkHelper virtualNetworkHelper;
\r
142 private Map<UserId, List<InstanceIdentifier<Flow>>> flowIdsOfUsers;
\r
143 private Map<UserId, List<InstanceIdentifier<Meter>>> meterIdIdsOfUsers;
\r
144 // private List<PhysicalPortId> assignedPortForInPort;
\r
145 private ResourceManager resourceManager;
\r
147 private Map<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeId, MacAddress> gatewayMacAddress;
\r
149 public FlowUtils(DataBroker dataBroker, ResourceManager resourceManager) {
\r
152 this.dataBroker = dataBroker;
\r
153 this.resourceManager = resourceManager;
\r
155 mplsGenerators = new HashMap<PhysicalNodeId, MplsLabelGenerator>();
\r
156 meterIdGenerators = new HashMap<PhysicalNodeId, MeterIdGenerator>();
\r
157 mplsLabelsOfPhysicalPaths = new HashMap<PhysicalPathId, List<Integer>>();
\r
158 meterIdsOfPhysicalPaths = new HashMap<PhysicalPathId, Long>();
\r
159 metadatas = new HashMap<UserId, Long>();
\r
162 flowIdsOfUsers = new HashMap<UserId, List<InstanceIdentifier<Flow>>>();
\r
163 meterIdIdsOfUsers = new HashMap<UserId, List<InstanceIdentifier<Meter>>>();
\r
164 // assignedPortForInPort = new ArrayList<PhysicalPortId>();
\r
166 gatewayMacAddress = new HashMap<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeId, MacAddress>();
\r
167 // Gateway of the DMZ group.
\r
168 gatewayMacAddress.put(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeId("b46cfa7f-93a3-43f4-ac20-09307c75feca"),
\r
169 new MacAddress("00:00:0a:0b:0c:01"));
\r
170 // Gateway of the interior group.
\r
171 gatewayMacAddress.put(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeId("175425f7-c9c9-474a-962c-70cb6c180d4d"),
\r
172 new MacAddress("00:00:0a:0b:0c:02"));
\r
175 public void init(List<PhysicalNode> physicalNodes) {
\r
176 for ( PhysicalNode physicalNode : physicalNodes ) {
\r
177 mplsGenerators.put(physicalNode.getNodeId(), new MplsLabelGenerator());
\r
178 meterIdGenerators.put(physicalNode.getNodeId(), new MeterIdGenerator());
\r
185 * @author Shixing Liu
\r
186 * @param userId TODO
\r
187 * @param nodeId TODO
\r
188 * @param tableId TODO
\r
189 * @param flowId TODO
\r
191 private InstanceIdentifier<Flow> generateFlowInsId(UserId userId,
\r
197 InstanceIdentifier<Flow> flowInsId = createFlowPath(nodeId, tableId, flowId);
\r
199 if(flowIdsOfUsers.containsKey(userId) == false){
\r
200 List<InstanceIdentifier<Flow>> flowInsIds = new ArrayList<InstanceIdentifier<Flow>>();
\r
201 flowInsIds.add(flowInsId);
\r
202 flowIdsOfUsers.put(userId, flowInsIds);
\r
204 List<InstanceIdentifier<Flow>> flowInsIds = flowIdsOfUsers.get(userId);
\r
205 flowInsIds.add(flowInsId);
\r
207 LOG.info("nemo:generateFlowInsId");
\r
214 * @author Shixing Liu
\r
215 * @param userId TODO
\r
216 * @param nodeKey TODO
\r
217 * @param meterKey TODO
\r
219 private InstanceIdentifier<Meter> generateMeterInsId(UserId userId,
\r
221 MeterKey meterKey){
\r
222 InstanceIdentifier<Meter> meterInsId = InstanceIdentifier.create(Nodes.class)
\r
223 .child(Node.class,nodeKey)
\r
224 .augmentation(FlowCapableNode.class).child(Meter.class, meterKey);
\r
226 if(meterIdIdsOfUsers.containsKey(userId) == false){
\r
227 List<InstanceIdentifier<Meter>> meterInsIds = new ArrayList<InstanceIdentifier<Meter>>();
\r
228 meterInsIds.add(meterInsId);
\r
229 meterIdIdsOfUsers.put(userId, meterInsIds);
\r
232 List<InstanceIdentifier<Meter>> meterInsIds = meterIdIdsOfUsers.get(userId);
\r
233 meterInsIds.add(meterInsId);
\r
235 LOG.info("nemo:getMeterInsId");
\r
239 public void updateFlowTable(User user,
\r
240 VirtualNetwork virtualNetwork,
\r
241 UserIntentVnMapping userIntentVnMapping,
\r
242 UserVnPnMapping userVnPnMapping,
\r
243 PhysicalNetwork physicalNetwork) {
\r
244 //If new user, generate metadata;
\r
245 if ( !metadatas.containsKey(user.getUserId()) ) {
\r
246 metadatas.put(user.getUserId(), ++currentMetadata);
\r
249 physicalNetworkHelper = new PhysicalNetworkHelper(physicalNetwork);
\r
250 virtualNetworkHelper = new VirtualNetworkHelper(virtualNetwork);
\r
252 updateInPortTable(user, virtualNetwork, userIntentVnMapping, userVnPnMapping, physicalNetwork);
\r
253 updateMeterTable(user, virtualNetwork, userIntentVnMapping, userVnPnMapping, physicalNetwork);
\r
254 updateMplsTable(user, virtualNetwork, userIntentVnMapping, userVnPnMapping, physicalNetwork);
\r
255 updateIpTable(user, virtualNetwork, userIntentVnMapping, userVnPnMapping, physicalNetwork);
\r
256 updateArpTable(user, virtualNetwork, userIntentVnMapping, userVnPnMapping, physicalNetwork);
\r
262 * @author Zhigang Ji
\r
263 * @param userId TODO
\r
265 public void deleteFlowEntries(UserId userId) {
\r
266 deleteFlowTableEntries(userId);
\r
267 deleteMeterTableEntries(userId);
\r
269 flowIdsOfUsers.put(userId, new LinkedList<InstanceIdentifier<Flow>>());
\r
270 meterIdIdsOfUsers.put(userId, new LinkedList<InstanceIdentifier<Meter>>());
\r
276 public void close() throws Exception {
\r
283 * @author Shixing Liu
\r
284 * @param physicalDestNodeId TODO
\r
285 * @param physicalDestPortId TODO
\r
287 private void configInternalInPortFlowTable(UserId userId,
\r
288 PhysicalNodeId physicalDestNodeId,
\r
289 PhysicalPortId physicalDestPortId) {
\r
290 String nodeID = physicalDestNodeId.getValue();
\r
291 String portID = physicalDestPortId.getValue();
\r
293 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
294 List<Instruction> instructionList = new LinkedList<Instruction>();
\r
295 Match match = new MatchBuilder().setInPort(new NodeConnectorId(portID)).build();
\r
297 GoToTable gotoTable = new GoToTableBuilder().setTableId(MPLS_LABEL_TABLE_ID).build();
\r
298 GoToTableCase gotoTableCase = new GoToTableCaseBuilder().setGoToTable(gotoTable).build();
\r
299 Instruction instructionGoto = new InstructionBuilder().setOrder(0).setInstruction(gotoTableCase).build();
\r
300 instructionList.add(instructionGoto);
\r
302 Instructions instructions = new InstructionsBuilder().setInstruction(instructionList).build();
\r
304 FlowId flowId = new FlowId(UUID.randomUUID().toString());
\r
305 FlowBuilder flowBuilder = baseFlowBuilder().setId(flowId).setTableId(IN_PORT_TABLE_ID).setPriority(DEFAULT_FLOW_PRIORITY);
\r
306 Flow flow = flowBuilder.setMatch(match).setInstructions(instructions).build();
\r
307 NodeId nodeId = new NodeId(nodeID);
\r
309 InstanceIdentifier<Flow> flowInsId = generateFlowInsId(userId, nodeId, flow.getTableId(), flow.getId());
\r
311 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowInsId, flow, true);
\r
312 writeTransaction.submit();
\r
314 LOG.info("nemo:configInternalInPortFlowTable");
\r
321 * @author Shixing Liu
\r
322 * @param physicalDestNodeId TODO
\r
323 * @param physicalDestPortId TODO
\r
324 * @param destNodeType TODO
\r
326 private void configExternalInPortFlowTable(UserId userId,
\r
327 PhysicalNodeId physicalDestNodeId,
\r
328 PhysicalPortId physicalDestPortId,
\r
329 VirtualNode.NodeType destNodeType) {
\r
330 String nodeID = physicalDestNodeId.getValue();
\r
331 String portID = physicalDestPortId.getValue();
\r
333 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
334 List<Instruction> instructionList = new LinkedList<Instruction>();
\r
335 Match match = new MatchBuilder().setInPort(new NodeConnectorId(portID)).build();
\r
337 WriteMetadata writeMetadata = new WriteMetadataBuilder().setMetadata(BigInteger.valueOf(metadatas.get(userId))).setMetadataMask(new BigInteger(DEFAULT_METADATA_MASK, 16)).build();
\r
338 WriteMetadataCase writeMetadataCase = new WriteMetadataCaseBuilder().setWriteMetadata(writeMetadata).build();
\r
339 Instruction instructionMeta = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(writeMetadataCase).build();
\r
340 instructionList.add(instructionMeta);
\r
342 GoToTable gotoTable = new GoToTableBuilder().setTableId((destNodeType==VirtualNode.NodeType.Vswitch)? MAC_TABLE_ID : IP_TABLE_ID).build();
\r
343 GoToTableCase gotoTableCase = new GoToTableCaseBuilder().setGoToTable(gotoTable).build();
\r
344 Instruction instructionGoto = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(gotoTableCase).build();
\r
345 instructionList.add(instructionGoto);
\r
347 Instructions instructions = new InstructionsBuilder().setInstruction(instructionList).build();
\r
349 FlowId flowId = new FlowId(UUID.randomUUID().toString());
\r
351 FlowBuilder flowBuilder = baseFlowBuilder().setId(flowId).setTableId(IN_PORT_TABLE_ID).setPriority(DEFAULT_FLOW_PRIORITY);
\r
352 Flow flow = flowBuilder.setMatch(match).setInstructions(instructions).build();
\r
354 NodeId nodeId = new NodeId(nodeID);
\r
356 InstanceIdentifier<Flow> flowInsId = generateFlowInsId(userId, nodeId, flow.getTableId(), flow.getId());
\r
358 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowInsId, flow, true);
\r
359 writeTransaction.submit();
\r
361 LOG.info("nemo:configExternalInPortFlowTable");
\r
369 * @author Shixing Liu
\r
371 * @param virtualNetwork TODO
\r
372 * @param userIntentVnMapping TODO
\r
373 * @param userVnPnMapping TODO
\r
374 * @param physicalNetwork TODO
\r
376 private void updateInPortTable(User user,
\r
377 VirtualNetwork virtualNetwork,
\r
378 UserIntentVnMapping userIntentVnMapping,
\r
379 UserVnPnMapping userVnPnMapping,
\r
380 PhysicalNetwork physicalNetwork) {
\r
381 List<VnPnMappingResult> vnPnMappingResults = userVnPnMapping.getVnPnMappingResult();
\r
383 for(VnPnMappingResult vnPnMappingResult:vnPnMappingResults){
\r
384 LOG.info("nemo:inport for(VnPnMappingResult vnPnMappingResult:vnPnMappingResults)");
\r
385 if(VirtualResource.VirtualResourceType.Vport == vnPnMappingResult.getVirtualResourceType()) {
\r
386 VirtualPortId virtualPortid = new VirtualPortId(vnPnMappingResult.getVirtualResourceEntityId().getValue());
\r
387 VirtualNodeId virtualNodeId = new VirtualNodeId(vnPnMappingResult.getParentVirtualResourceEntityId().getValue());
\r
389 VirtualPort.PortType virtualPortType = VirtualPort.PortType.Internal;
\r
390 VirtualNode.NodeType virtualNodeType = VirtualNode.NodeType.Vswitch;
\r
392 List<VirtualNode> virtualNodes = virtualNetwork.getVirtualNodes().getVirtualNode();
\r
393 for (VirtualNode virtualNode : virtualNodes) {
\r
394 if (virtualNode.getNodeId().equals(virtualNodeId)){
\r
395 virtualNodeType = virtualNode.getNodeType();
\r
396 for (VirtualPort virtualPort : virtualNode.getVirtualPort()) {
\r
397 if (virtualPort.getPortId().equals(virtualPortid)){
\r
398 virtualPortType = virtualPort.getPortType();
\r
406 PhysicalNodeId physicalDestNodeId =
\r
407 new PhysicalNodeId(vnPnMappingResult.getParentPhysicalResourceEntityId().getValue());
\r
409 PhysicalPortId physicalDestPortId =
\r
410 new PhysicalPortId(vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
412 if (virtualPortType == VirtualPort.PortType.External) {
\r
413 configExternalInPortFlowTable(userVnPnMapping.getUserId(), physicalDestNodeId, physicalDestPortId, virtualNodeType);
\r
415 configInternalInPortFlowTable(userVnPnMapping.getUserId(), physicalDestNodeId, physicalDestPortId);
\r
420 for(PhysicalNode physicalNode: physicalNetwork.getPhysicalNodes().getPhysicalNode()){
\r
421 PhysicalNodeId physicalDestNodeId = physicalNode.getNodeId();
\r
423 for (PhysicalPort physicalPort: physicalNode.getPhysicalPort()){
\r
424 PhysicalPortId physicalDestPortId = physicalPort.getPortId();
\r
425 PhysicalPort.PortType physicalPortType = physicalPort.getPortType();
\r
427 if(physicalPortType == PhysicalPort.PortType.Internal){
\r
428 configInternalInPortFlowTable(userVnPnMapping.getUserId(), physicalDestNodeId, physicalDestPortId);
\r
437 * @author Shixing Liu
\r
439 * @param virtualNetwork TODO
\r
440 * @param userIntentVnMapping TODO
\r
441 * @param userVnPnMapping TODO
\r
442 * @param physicalNetwork TODO
\r
444 private void updateMeterTable(User user,
\r
445 VirtualNetwork virtualNetwork,
\r
446 UserIntentVnMapping userIntentVnMapping,
\r
447 UserVnPnMapping userVnPnMapping,
\r
448 PhysicalNetwork physicalNetwork) {
\r
450 LOG.info("nemo:meter updateMeterTable()");
\r
451 PhysicalPaths physicalPaths = physicalNetwork.getPhysicalPaths();
\r
452 if(null == physicalPaths.getPhysicalPath()){
\r
453 LOG.info("PhysicalPath are null");
\r
457 List<PhysicalPath> physicalPathList = physicalPaths.getPhysicalPath();
\r
459 PhysicalLinks physicalLinks = physicalNetwork.getPhysicalLinks();
\r
460 List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.links.PhysicalLink>
\r
461 physicalLinksList = physicalLinks.getPhysicalLink();
\r
463 for(PhysicalPath physicalPath:physicalPathList) {
\r
464 if(physicalPath.getBandwidth() > 0 ) {
\r
465 LOG.info("nemo: meter physicalPath.getBandwidth() = {}", physicalPath.getBandwidth());
\r
466 if(meterIdsOfPhysicalPaths.containsKey(physicalPath.getPathId())== false){
\r
467 LOG.info("nemo:meter meterIdsOfPhysicalPaths.containsKey(physicalPath.getPathId())== false");
\r
468 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.path.instance.PhysicalLink
\r
469 physicalLinkInPath = physicalPath.getPhysicalLink().get(0);
\r
471 LOG.info("nemo:meter physicalLinkInPath"+physicalLinkInPath.getLinkId().getValue());
\r
472 for (org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.links.PhysicalLink physicalLink : physicalLinksList) {
\r
473 LOG.info("nemo:meter physicalLink "+physicalLink.getLinkId().getValue());
\r
474 if (physicalLinkInPath.getLinkId().getValue().equals(physicalLink.getLinkId().getValue())) {
\r
476 LOG.info("nemo:meter find plink for ppath.");
\r
477 PhysicalNodeId physicalSrcNodeId = physicalLink.getSrcNodeId();
\r
478 PhysicalPortId physicalSrcPortId = physicalLink.getSrcPortId();
\r
480 LOG.info("nemo:meter meterIdGenerators.size() = "+ meterIdGenerators.size());
\r
481 LOG.info("nemo:meter physicalSrcNodeId =" + physicalSrcNodeId.getValue());
\r
483 LOG.info("nemo:meter Assign meter id");
\r
484 Long meterId = (long)0;
\r
485 if(meterIdGenerators.containsKey(physicalSrcNodeId) == false){
\r
486 LOG.info("meterIdGenerators.containsKey(physicalSrcNodeId) == false");
\r
487 MeterIdGenerator meterIdGenerator = new MeterIdGenerator();
\r
488 meterIdGenerators.put(physicalSrcNodeId, meterIdGenerator);
\r
489 meterId = meterIdGenerators.get(physicalSrcNodeId).generateMeterId();
\r
490 meterIdsOfPhysicalPaths.put(physicalPath.getPathId(),meterId);
\r
493 LOG.info("meterIdGenerators.containsKey(physicalSrcNodeId) == true");
\r
494 meterId = meterIdGenerators.get(physicalSrcNodeId).generateMeterId();
\r
495 meterIdsOfPhysicalPaths.put(physicalPath.getPathId(),meterId);
\r
498 //Generate meter flow entries
\r
499 LOG.info("nemo:meter Generate meter flow entries");
\r
500 NodeKey nodeKey = new NodeKey(new NodeId(physicalSrcNodeId.getValue()));
\r
501 MeterKey meterKey = new MeterKey(new MeterId(meterId));
\r
503 InstanceIdentifier<Meter> meterInsId = generateMeterInsId(userVnPnMapping.getUserId(), nodeKey, meterKey);
\r
506 MeterBandHeaderBuilder meterBandHeaderBuilder = new MeterBandHeaderBuilder();
\r
507 MeterBandTypesBuilder meterBandTypesB = new MeterBandTypesBuilder();
\r
508 MeterBandType bandFlag = new MeterBandType(true, false, false);
\r
509 meterBandTypesB.setFlags(bandFlag);// _ofpmbtDrop
\r
510 DropBuilder drop = new DropBuilder();
\r
511 drop.setDropBurstSize(physicalPath.getBandwidth() / 2);
\r
512 drop.setDropRate(physicalPath.getBandwidth());
\r
513 Drop drp = drop.build();
\r
514 meterBandHeaderBuilder.setBandType(drp);
\r
515 meterBandHeaderBuilder.setMeterBandTypes(meterBandTypesB.build());
\r
516 MeterBandHeader meterBH = meterBandHeaderBuilder.build();
\r
517 MeterBuilder meterBuilder = new MeterBuilder();
\r
518 meterBuilder.setMeterBandHeaders(meterBandHeadersBuilder.setMeterBandHeader(meterBandHeaders).build());
\r
521 MeterBuilder meterBuilder = new MeterBuilder();
\r
522 MeterBandHeaderBuilder meterBandHeaderBuilder = new MeterBandHeaderBuilder();
\r
523 MeterBandHeadersBuilder meterBandHeadersBuilder = new MeterBandHeadersBuilder();
\r
524 MeterBandTypesBuilder meterBandTypesB = new MeterBandTypesBuilder();
\r
526 meterBandHeaderBuilder.setKey(new MeterBandHeaderKey(new BandId(physicalPath.getBandwidth())));
\r
527 meterBandHeaderBuilder.setBandBurstSize((long)0);
\r
528 meterBandHeaderBuilder.setBandRate(physicalPath.getBandwidth());
\r
530 MeterBandType bandFlag = new MeterBandType(true, false, false);
\r
531 meterBandTypesB.setFlags(bandFlag);// _ofpmbtDrop
\r
532 DropBuilder drop = new DropBuilder();
\r
533 drop.setDropBurstSize((long)0);
\r
534 drop.setDropRate(physicalPath.getBandwidth());
\r
535 Drop drp = drop.build();
\r
536 meterBandHeaderBuilder.setBandType(drp);
\r
537 meterBandHeaderBuilder.setMeterBandTypes(meterBandTypesB.build());
\r
539 MeterBandHeader meterBH = meterBandHeaderBuilder.build();
\r
540 List<MeterBandHeader> meterBandHeaders = new ArrayList<MeterBandHeader>();
\r
541 meterBandHeaders.add(0, meterBH);
\r
543 meterBuilder.setKey(new MeterKey(new MeterId(meterId)));
\r
544 meterBuilder.setBarrier(false);
\r
546 meterBuilder.setFlags(new MeterFlags(false, true, false, true));
\r
548 meterBuilder.setContainerName("container." + physicalPath.getPathId());
\r
549 meterBuilder.setMeterName("meter." + physicalPath.getPathId());
\r
550 meterBandHeadersBuilder.setMeterBandHeader(meterBandHeaders);
\r
551 meterBuilder.setMeterBandHeaders(meterBandHeadersBuilder.build());
\r
553 Meter meter = meterBuilder.build();
\r
555 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
556 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, meterInsId, meter);
\r
557 writeTransaction.submit();
\r
558 LOG.info("nemo:meter writeTransaction.submit();");
\r
570 * @author Shixing Liu
\r
571 * @param physicalPath TODO
\r
572 * @param physicalLinksList TODO
\r
574 public void assignMPLSLabelForPPath(PhysicalPath physicalPath,
\r
575 List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.links.PhysicalLink> physicalLinksList){
\r
577 LOG.info("nemo: for(1)");
\r
578 List<Integer> mplsLabels = new ArrayList<Integer>();
\r
579 List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.path.instance.PhysicalLink>
\r
580 physicalLinksInPath = physicalPath.getPhysicalLink();
\r
582 for (org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.path.instance.PhysicalLink physicalLinkinPath : physicalLinksInPath) {
\r
583 LOG.info("nemo: for(2)");
\r
584 for (org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.links.PhysicalLink physicalLink : physicalLinksList) {
\r
585 LOG.info("nemo: for(3)");
\r
586 if (physicalLinkinPath.getLinkId().getValue().equals(physicalLink.getLinkId().getValue())) {
\r
587 LOG.info("nemo: physicalLinkinPath.getLinkId() == physicalLink.getLinkId()");
\r
588 PhysicalNodeId physicalDestNodeId = physicalLink.getDestNodeId();
\r
589 if(mplsGenerators.containsKey(physicalDestNodeId) == true){
\r
591 mplsLabels.add(mplsGenerators.get(physicalDestNodeId).generateMplsLabel());
\r
596 MplsLabelGenerator mplsLabelGenerator = new MplsLabelGenerator();
\r
597 mplsGenerators.put(physicalDestNodeId, mplsLabelGenerator);
\r
598 mplsLabels.add(mplsGenerators.get(physicalDestNodeId).generateMplsLabel());
\r
603 mplsLabelsOfPhysicalPaths.put(physicalPath.getPathId(), mplsLabels);
\r
609 * @author Shixing Liu
\r
611 * @param virtualNetwork TODO
\r
612 * @param userIntentVnMapping TODO
\r
613 * @param userVnPnMapping TODO
\r
614 * @param physicalNetwork TODO
\r
616 private void updateMplsTable(User user,
\r
617 VirtualNetwork virtualNetwork,
\r
618 UserIntentVnMapping userIntentVnMapping,
\r
619 UserVnPnMapping userVnPnMapping,
\r
620 PhysicalNetwork physicalNetwork) {
\r
622 LOG.info("nemo:mpls: updateMplsTable()");
\r
623 PhysicalPaths physicalPaths = physicalNetwork.getPhysicalPaths();
\r
625 if(null == physicalPaths.getPhysicalPath()){
\r
626 LOG.info("PhysicalPaths are null");
\r
630 List<PhysicalPath> physicalPathList = physicalPaths.getPhysicalPath();
\r
632 PhysicalLinks physicalLinks = physicalNetwork.getPhysicalLinks();
\r
633 List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.links.PhysicalLink>
\r
634 physicalLinksList = physicalLinks.getPhysicalLink();
\r
636 Iterator<Integer> mplsLabelIter = null;
\r
638 List<VnPnMappingResult> vnPnMappingResults = userVnPnMapping.getVnPnMappingResult();
\r
640 for(VnPnMappingResult vnPnMappingResult:vnPnMappingResults) {
\r
641 if (VirtualResource.VirtualResourceType.Vlink == vnPnMappingResult.getVirtualResourceType()) {
\r
642 PhysicalPathId physicalPathId = new PhysicalPathId(vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
643 PhysicalPath physicalPath = physicalNetworkHelper.getPhysicalPath(physicalPathId);
\r
645 VirtualLinkId virtualLinkId = new VirtualLinkId(vnPnMappingResult.getVirtualResourceEntityId().getValue());
\r
646 VirtualLink virtualLink = virtualNetworkHelper.getVirtualLink(virtualLinkId);
\r
647 VirtualNodeId virtualNodeId = virtualLink.getDestNodeId();
\r
648 VirtualNode.NodeType nodetype = VirtualNode.NodeType.Vswitch;
\r
649 List<VirtualNode> virtualNodes = virtualNetwork.getVirtualNodes().getVirtualNode();
\r
650 for (VirtualNode virtualNode : virtualNodes) {
\r
651 if (virtualNode.getNodeId().equals(virtualNodeId)) {
\r
652 nodetype = virtualNode.getNodeType();
\r
657 //Assign MPLS Label and record MPLS Label
\r
658 assignMPLSLabelForPPath(physicalPath,physicalLinksList);
\r
660 //Create Flow Entries for MPLS Flow Table
\r
662 int inMPLSLabel = Integer.MAX_VALUE;
\r
663 int outMPLSLabel = Integer.MAX_VALUE;
\r
665 List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.path.instance.PhysicalLink>
\r
666 physicalLinksInPath = physicalPath.getPhysicalLink();
\r
667 for (org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.path.instance.PhysicalLink physicalLinkinPath : physicalLinksInPath) {
\r
668 for (org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.links.PhysicalLink physicalLink : physicalLinksList) {
\r
669 if (physicalLinkinPath.getLinkId().getValue().equals(physicalLink.getLinkId().getValue())) {
\r
670 PhysicalNodeId physicalDestNodeId = physicalLink.getDestNodeId();
\r
671 PhysicalNodeId physicalSrcNodeId = physicalLink.getSrcNodeId();
\r
672 PhysicalPortId physicalSrcPortId = physicalLink.getSrcPortId();
\r
674 if (0 == counter++) {
\r
675 LOG.info("nemo:mpls:0 == counter");
\r
676 mplsLabelIter = mplsLabelsOfPhysicalPaths.get(physicalPath.getPathId()).iterator();
\r
677 inMPLSLabel = mplsLabelIter.next();
\r
679 LOG.info("nemo:mpls:counter="+counter);
\r
680 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
681 List<Instruction> instructionList = new LinkedList<Instruction>();
\r
682 List<Action> actionList = new LinkedList<Action>();
\r
683 outMPLSLabel = mplsLabelIter.next();
\r
685 EthernetMatchBuilder ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetType(new EthernetTypeBuilder().setType(new EtherType((long) ETH_TYPE_MPLS)).build());
\r
686 EthernetMatch ethernetMatch = ethernetMatchBuilder.build();
\r
688 ProtocolMatchFieldsBuilder protocolMatchFieldsBuilder = new ProtocolMatchFieldsBuilder().setMplsLabel((long) inMPLSLabel);
\r
689 ProtocolMatchFields protocolMatchFields = protocolMatchFieldsBuilder.build();
\r
691 Match match = new MatchBuilder().setEthernetMatch(ethernetMatch).setProtocolMatchFields(protocolMatchFields).build();
\r
693 SetField setField = new SetFieldBuilder().setProtocolMatchFields(new ProtocolMatchFieldsBuilder().setMplsLabel((long) outMPLSLabel).build()).build();
\r
694 SetFieldCase setFieldCase = new SetFieldCaseBuilder().setSetField(setField).build();
\r
695 Action actionSetField = new ActionBuilder().setOrder(0).setAction(setFieldCase).build();
\r
696 actionList.add(actionSetField);
\r
698 DecMplsTtl decMplsTtl = new DecMplsTtlBuilder().build();
\r
699 DecMplsTtlCase decMplsTtlCase = new DecMplsTtlCaseBuilder().setDecMplsTtl(decMplsTtl).build();
\r
700 Action actionDecMPLS = new ActionBuilder().setOrder(1).setAction(decMplsTtlCase).build();
\r
701 actionList.add(actionDecMPLS);
\r
703 OutputAction outputAction = new OutputActionBuilder().setOutputNodeConnector(new NodeConnectorId(physicalSrcPortId.getValue())).build();
\r
704 OutputActionCase outputActionCase = new OutputActionCaseBuilder().setOutputAction(outputAction).build();
\r
705 Action actionOutput = new ActionBuilder().setOrder(2).setAction(outputActionCase).build();
\r
706 actionList.add(actionOutput);
\r
708 ApplyActions applyActions = new ApplyActionsBuilder().setAction(actionList).build();
\r
709 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
\r
710 Instruction instructionApply = new InstructionBuilder().setOrder(0).setInstruction(applyActionsCase).build();
\r
711 instructionList.add(instructionApply);
\r
713 Instructions instructions = new InstructionsBuilder().setInstruction(instructionList).build();
\r
715 FlowId flowId = new FlowId(UUID.randomUUID().toString());
\r
716 FlowBuilder flowBuilder = baseFlowBuilder().setId(flowId).setTableId(MPLS_LABEL_TABLE_ID).setPriority(DEFAULT_FLOW_PRIORITY);
\r
717 Flow flow = flowBuilder.setMatch(match).setInstructions(instructions).build();
\r
719 LOG.info("nemo:mpls"+physicalSrcNodeId.getValue());
\r
721 NodeId nodeId = new NodeId(physicalSrcNodeId.getValue());
\r
723 InstanceIdentifier<Flow> flowInsId = generateFlowInsId(user.getUserId(), nodeId, flow.getTableId(), flow.getId());
\r
725 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowInsId, flow, true);
\r
726 writeTransaction.submit();
\r
728 inMPLSLabel = outMPLSLabel;
\r
731 if (physicalPath.getPhysicalLink().size() == counter) {
\r
732 LOG.info("nemo:mpls: last hop");
\r
733 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
734 List<Instruction> instructionList = new LinkedList<Instruction>();
\r
735 List<Action> actionList = new LinkedList<Action>();
\r
737 EthernetMatchBuilder ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetType(new EthernetTypeBuilder().setType(new EtherType((long) ETH_TYPE_MPLS)).build());
\r
738 EthernetMatch ethernetMatch = ethernetMatchBuilder.build();
\r
740 ProtocolMatchFieldsBuilder protocolMatchFieldsBuilder = new ProtocolMatchFieldsBuilder().setMplsLabel((long) inMPLSLabel);
\r
741 ProtocolMatchFields protocolMatchFields = protocolMatchFieldsBuilder.build();
\r
743 Match match = new MatchBuilder().setEthernetMatch(ethernetMatch).setProtocolMatchFields(protocolMatchFields).build();
\r
745 PopMplsAction popMplsAction = new PopMplsActionBuilder().setEthernetType(ETH_TYPE_IP).build();
\r
746 PopMplsActionCase popMplsActionCase = new PopMplsActionCaseBuilder().setPopMplsAction(popMplsAction).build();
\r
747 Action actionPopMPLS = new ActionBuilder().setOrder(0).setAction(popMplsActionCase).build();
\r
748 actionList.add(actionPopMPLS);
\r
750 ApplyActions applyActions = new ApplyActionsBuilder().setAction(actionList).build();
\r
751 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
\r
752 Instruction instructionApply = new InstructionBuilder().setOrder(0).setInstruction(applyActionsCase).build();
\r
753 instructionList.add(instructionApply);
\r
755 WriteMetadata writeMetadata = new WriteMetadataBuilder().setMetadata(BigInteger.valueOf(metadatas.get(user.getUserId()))).setMetadataMask(new BigInteger(DEFAULT_METADATA_MASK, 16)).build();
\r
756 WriteMetadataCase writeMetadataCase = new WriteMetadataCaseBuilder().setWriteMetadata(writeMetadata).build();
\r
757 Instruction instructionMeta = new InstructionBuilder().setOrder(1).setInstruction(writeMetadataCase).build();
\r
758 instructionList.add(instructionMeta);
\r
760 GoToTable gotoTable = new GoToTableBuilder().setTableId((nodetype == VirtualNode.NodeType.Vswitch)? MAC_TABLE_ID:IP_TABLE_ID).build();
\r
761 GoToTableCase gotoTableCase = new GoToTableCaseBuilder().setGoToTable(gotoTable).build();
\r
762 Instruction instructionGoto = new InstructionBuilder().setOrder(2).setInstruction(gotoTableCase).build();
\r
763 instructionList.add(instructionGoto);
\r
765 Instructions instructions = new InstructionsBuilder().setInstruction(instructionList).build();
\r
767 FlowId flowId = new FlowId(UUID.randomUUID().toString());
\r
768 FlowBuilder flowBuilder = baseFlowBuilder().setId(flowId).setTableId(MPLS_LABEL_TABLE_ID).setPriority(DEFAULT_FLOW_PRIORITY);
\r
769 Flow flow = flowBuilder.setMatch(match).setInstructions(instructions).build();
\r
771 LOG.info("nemo:mpls:"+physicalDestNodeId.getValue());
\r
772 NodeId nodeId = new NodeId(physicalDestNodeId.getValue());
\r
773 InstanceIdentifier<Flow> flowInsId = generateFlowInsId(user.getUserId(), nodeId, flow.getTableId(), flow.getId());
\r
775 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowInsId, flow, true);
\r
776 writeTransaction.submit();
\r
788 * @author Zhigang Ji
\r
790 * @param virtualNetwork TODO
\r
791 * @param userIntentVnMapping TODO
\r
792 * @param userVnPnMapping TODO
\r
793 * @param physicalNetwork TODO
\r
795 private void updateIpTable(User user,
\r
796 VirtualNetwork virtualNetwork,
\r
797 UserIntentVnMapping userIntentVnMapping,
\r
798 UserVnPnMapping userVnPnMapping,
\r
799 PhysicalNetwork physicalNetwork) {
\r
800 List<VnPnMappingResult> vnPnMappingResults = userVnPnMapping.getVnPnMappingResult();
\r
801 Map<VirtualNodeId, VirtualNode> virtualRouters = virtualNetworkHelper.getVirtualRouters();
\r
802 Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>> connectedVirtualSwitches;
\r
803 Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>> connectedVirtualSwitches1;
\r
804 Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>> connectedVirtualRouters;
\r
805 Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>> connectedVirtualRouters1;
\r
806 VirtualPort layer2ExternalVirtualPort;
\r
807 VirtualPort layer2ExternalVirtualPort1;
\r
808 VirtualPort layer2ExternalVirtualPort2;
\r
809 VirtualPort layer3ExternalVirtualPort;
\r
810 VirtualPort layer3ExternalVirtualPort1;
\r
811 VnPnMappingResult vnPnMappingResult;
\r
812 PhysicalNodeId physicalNodeId;
\r
813 PhysicalNodeId physicalNodeId1;
\r
814 VirtualLink virtualLink;
\r
815 VirtualLink virtualLink1;
\r
816 PhysicalPathId physicalPathId;
\r
817 PhysicalPathId physicalPathId1;
\r
818 PhysicalPath physicalPath;
\r
819 PhysicalPath physicalPath1;
\r
820 PhysicalPortId physicalPortId;
\r
821 PhysicalPort physicalPort;
\r
822 List<IpPrefix> remoteIpPrefixes;
\r
823 List<IpPrefix> ipPrefixes;
\r
824 List<MacAddress> macAddresses;
\r
825 VirtualPort virtualPort;
\r
826 VirtualArp virtualArp;
\r
828 MacAddress gatewayMacAddress;
\r
830 for ( VirtualNodeId virtualNodeId : virtualRouters.keySet() ) {
\r
831 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
832 new VirtualResourceEntityId(virtualNodeId.getValue()));
\r
833 physicalNodeId = new PhysicalNodeId(vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
835 connectedVirtualRouters = virtualNetworkHelper.getConnectedVirtualRouters(virtualNodeId);
\r
837 if ( null != connectedVirtualRouters ) {
\r
838 for ( Map.Entry<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>> entry
\r
839 : connectedVirtualRouters.entrySet() ) {
\r
840 virtualLink = entry.getValue().getValue();
\r
841 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
842 new VirtualResourceEntityId(virtualLink.getLinkId().getValue()));
\r
843 physicalPathId = new PhysicalPathId(
\r
844 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
845 physicalPath = physicalNetworkHelper.getPhysicalPath(physicalPathId);
\r
846 remoteIpPrefixes = new LinkedList<IpPrefix>();
\r
848 connectedVirtualSwitches1 = virtualNetworkHelper
\r
849 .getConnectedVirtualSwitches(entry.getKey());
\r
851 if ( null != connectedVirtualSwitches1 ) {
\r
852 virtualPort = connectedVirtualSwitches1.entrySet().iterator().next().getValue().getKey();
\r
853 ipPrefix = virtualPort.getExternalIpPrefixes().getExternalIpPrefix().get(0);
\r
854 remoteIpPrefixes.add(ipPrefix);
\r
857 layer3ExternalVirtualPort1 = virtualNetworkHelper
\r
858 .getLayer3ExternalVirtualPort(entry.getKey());
\r
860 if ( null != layer3ExternalVirtualPort1 ) {
\r
861 remoteIpPrefixes.addAll(
\r
862 layer3ExternalVirtualPort1.getExternalIpPrefixes().getExternalIpPrefix());
\r
865 layer2ExternalVirtualPort1 = virtualNetworkHelper
\r
866 .getLayer2ExternalVirtualPort(entry.getKey());
\r
868 if ( null != layer2ExternalVirtualPort1 ) {
\r
869 remoteIpPrefixes.addAll(
\r
870 layer2ExternalVirtualPort1.getExternalIpPrefixes().getExternalIpPrefix());
\r
873 if ( !physicalPath.getPhysicalLink().isEmpty() ) {
\r
874 for ( IpPrefix ipPrefix1 : remoteIpPrefixes ) {
\r
875 configIpTableEntry(user.getUserId(), ipPrefix1, physicalPath, false);
\r
881 connectedVirtualSwitches = virtualNetworkHelper.getConnectedVirtualSwitches(virtualNodeId);
\r
883 if ( null != connectedVirtualSwitches ) {
\r
884 virtualPort = connectedVirtualSwitches.values().iterator().next().getKey();
\r
885 ipPrefix = virtualPort.getExternalIpPrefixes().getExternalIpPrefix().get(0);
\r
886 gatewayMacAddress = getGateWayMacAddress(userIntentVnMapping, virtualNodeId);
\r
888 configIpTableEntry(user.getUserId(), ipPrefix, gatewayMacAddress, physicalNodeId);
\r
890 for ( Map.Entry<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>> entry
\r
891 : connectedVirtualSwitches.entrySet() ) {
\r
892 virtualLink = entry.getValue().getValue();
\r
893 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
894 new VirtualResourceEntityId(virtualLink.getLinkId().getValue()));
\r
895 physicalPathId = new PhysicalPathId(
\r
896 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
897 physicalPath = physicalNetworkHelper.getPhysicalPath(physicalPathId);
\r
899 connectedVirtualRouters1 = virtualNetworkHelper
\r
900 .getConnectedVirtualRouters(entry.getKey());
\r
902 if ( null != connectedVirtualRouters1 ) {
\r
903 virtualLink1 = connectedVirtualRouters1.values().iterator().next().getValue();
\r
904 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
905 new VirtualResourceEntityId(virtualLink1.getLinkId().getValue()));
\r
906 physicalPathId1 = new PhysicalPathId(
\r
907 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
908 physicalPath1 = physicalNetworkHelper.getPhysicalPath(physicalPathId1);
\r
910 configMacTableEntry(user.getUserId(), gatewayMacAddress, physicalPath1);
\r
913 connectedVirtualSwitches1 = virtualNetworkHelper
\r
914 .getConnectedVirtualSwitches(entry.getKey());
\r
916 if ( null != connectedVirtualSwitches1 ) {
\r
917 for ( Map.Entry<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>> entry1
\r
918 : connectedVirtualSwitches1.entrySet() ) {
\r
919 virtualLink1 = entry1.getValue().getValue();
\r
920 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
921 new VirtualResourceEntityId(virtualLink1.getLinkId().getValue()));
\r
922 physicalPathId1 = new PhysicalPathId(
\r
923 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
924 physicalPath1 = physicalNetworkHelper.getPhysicalPath(physicalPathId1);
\r
926 if ( !physicalPath1.getPhysicalLink().isEmpty() ) {
\r
927 layer2ExternalVirtualPort2 = virtualNetworkHelper
\r
928 .getLayer2ExternalVirtualPort(entry1.getKey());
\r
930 if ( null != layer2ExternalVirtualPort2 ) {
\r
931 macAddresses = layer2ExternalVirtualPort2
\r
932 .getExternalMacAddresses().getExternalMacAddress();
\r
934 for ( MacAddress macAddress : macAddresses ) {
\r
935 configMacTableEntry(user.getUserId(), macAddress, physicalPath1);
\r
942 layer2ExternalVirtualPort1 = virtualNetworkHelper
\r
943 .getLayer2ExternalVirtualPort(entry.getKey());
\r
945 if ( null != layer2ExternalVirtualPort1 ) {
\r
946 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
947 new VirtualResourceEntityId(layer2ExternalVirtualPort1.getPortId().getValue()));
\r
948 physicalNodeId1 = new PhysicalNodeId(
\r
949 vnPnMappingResult.getParentPhysicalResourceEntityId().getValue());
\r
950 physicalPortId = new PhysicalPortId(
\r
951 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
952 physicalPort = physicalNetworkHelper.getPhysicalPort(physicalNodeId1, physicalPortId);
\r
954 macAddresses = layer2ExternalVirtualPort1
\r
955 .getExternalMacAddresses().getExternalMacAddress();
\r
957 for ( MacAddress macAddress : macAddresses ) {
\r
958 virtualArp = virtualNetworkHelper.getVirtualArp(macAddress);
\r
960 configArpTableEntry(user.getUserId(), virtualArp, physicalPath);
\r
961 configMacTableEntry(user.getUserId(), macAddress, physicalNodeId1, physicalPort);
\r
967 layer3ExternalVirtualPort = virtualNetworkHelper.getLayer3ExternalVirtualPort(virtualNodeId);
\r
969 if ( null != layer3ExternalVirtualPort ) {
\r
970 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
971 new VirtualResourceEntityId(layer3ExternalVirtualPort.getPortId().getValue()));
\r
972 physicalPortId = new PhysicalPortId(vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
973 physicalPort = physicalNetworkHelper.getPhysicalPort(physicalNodeId, physicalPortId);
\r
975 ipPrefixes = layer3ExternalVirtualPort.getExternalIpPrefixes().getExternalIpPrefix();
\r
977 for ( IpPrefix ipPrefix1 : ipPrefixes ) {
\r
978 configIpTableEntry(user.getUserId(), ipPrefix1, physicalNodeId, physicalPort, false);
\r
982 layer2ExternalVirtualPort = virtualNetworkHelper.getLayer2ExternalVirtualPort(virtualNodeId);
\r
984 if ( null != layer2ExternalVirtualPort ) {
\r
985 // TODO: config ip and arp tables.
\r
989 updateIpTableForOperations(user, virtualNetwork, userIntentVnMapping, userVnPnMapping, physicalNetwork);
\r
991 // for testing - jizhigang
\r
992 // log format: vnode(nodetype) --> vnode(nodetype): vlink; ppath; plinks; mplslabels; meterid;
\r
993 Set<VirtualLinkId> printedVirtualLinks = new HashSet<VirtualLinkId>();
\r
994 VirtualNode srcVirtualNode;
\r
995 VirtualNode dstVirtualNode;
\r
996 PhysicalPath physicalPath2;
\r
998 for ( VirtualLink virtualLink2 : virtualNetwork.getVirtualLinks().getVirtualLink() ) {
\r
999 if ( !printedVirtualLinks.contains(virtualLink2.getLinkId()) ) {
\r
1000 srcVirtualNode = virtualNetworkHelper.virtualNodeMap.get(virtualLink2.getSrcNodeId());
\r
1001 dstVirtualNode = virtualNetworkHelper.virtualNodeMap.get(virtualLink2.getDestNodeId());
\r
1002 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults, new VirtualResourceEntityId(virtualLink2.getLinkId().getValue()));
\r
1003 physicalPath2 = physicalNetworkHelper.getPhysicalPath(new PhysicalPathId(vnPnMappingResult.getPhysicalResourceEntityId().getValue()));
\r
1005 System.out.println(srcVirtualNode.getNodeId().getValue() + "(" + srcVirtualNode.getNodeType() + ") --> " +
\r
1006 dstVirtualNode.getNodeId().getValue() + "(" + dstVirtualNode.getNodeType() + "): " + virtualLink2.getLinkId().getValue() + "; " +
\r
1007 physicalPath2.getPathId().getValue() + "; " + physicalPath2.getPhysicalLink() + "; " +
\r
1008 mplsLabelsOfPhysicalPaths.get(physicalPath2.getPathId()) + "; " +
\r
1009 meterIdsOfPhysicalPaths.get(physicalPath2.getPathId()) + ";");
\r
1011 for ( VirtualLink virtualLink3 : virtualNetwork.getVirtualLinks().getVirtualLink() ) {
\r
1012 if ( virtualLink3.getSrcNodeId().equals(dstVirtualNode.getNodeId())
\r
1013 && virtualLink3.getDestNodeId().equals(srcVirtualNode.getNodeId()) ) {
\r
1014 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults, new VirtualResourceEntityId(virtualLink3.getLinkId().getValue()));
\r
1015 physicalPath2 = physicalNetworkHelper.getPhysicalPath(new PhysicalPathId(vnPnMappingResult.getPhysicalResourceEntityId().getValue()));
\r
1017 System.out.println(dstVirtualNode.getNodeId().getValue() + "(" + dstVirtualNode.getNodeType() + ") --> " +
\r
1018 srcVirtualNode.getNodeId().getValue() + "(" + srcVirtualNode.getNodeType() + "): " + virtualLink3.getLinkId().getValue() + "; " +
\r
1019 physicalPath2.getPathId().getValue() + "; " + physicalPath2.getPhysicalLink() + "; " +
\r
1020 mplsLabelsOfPhysicalPaths.get(physicalPath2.getPathId()) + "; " +
\r
1021 meterIdsOfPhysicalPaths.get(physicalPath2.getPathId()) + ";");
\r
1023 printedVirtualLinks.add(virtualLink3.getLinkId());
\r
1027 printedVirtualLinks.add(virtualLink2.getLinkId());
\r
1030 // for testing - jizhigang
\r
1038 * @author Zhigang Ji
\r
1039 * @param user TODO
\r
1040 * @param virtualNetwork TODO
\r
1041 * @param userIntentVnMapping TODO
\r
1042 * @param userVnPnMapping TODO
\r
1043 * @param physicalNetwork TODO
\r
1045 private void updateArpTable(User user,
\r
1046 VirtualNetwork virtualNetwork,
\r
1047 UserIntentVnMapping userIntentVnMapping,
\r
1048 UserVnPnMapping userVnPnMapping,
\r
1049 PhysicalNetwork physicalNetwork) {
\r
1056 * @author Zhigang Ji
\r
1057 * @param userId TODO
\r
1059 private void deleteFlowTableEntries(UserId userId) {
\r
1060 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
1062 for ( InstanceIdentifier<Flow> flowIid : flowIdsOfUsers.get(userId) ) {
\r
1063 writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, flowIid);
\r
1066 writeTransaction.submit();
\r
1074 * @author Zhigang Ji
\r
1075 * @param userId TODO
\r
1077 private void deleteMeterTableEntries(UserId userId) {
\r
1078 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
1080 for ( InstanceIdentifier<Meter> meterIid : meterIdIdsOfUsers.get(userId) ) {
\r
1081 writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, meterIid);
\r
1084 writeTransaction.submit();
\r
1092 * @author Zhigang Ji
\r
1093 * @param user TODO
\r
1094 * @param virtualNetwork TODO
\r
1095 * @param userIntentVnMapping TODO
\r
1096 * @param userVnPnMapping TODO
\r
1097 * @param physicalNetwork TODO
\r
1099 private void updateIpTableForOperations(User user,
\r
1100 VirtualNetwork virtualNetwork,
\r
1101 UserIntentVnMapping userIntentVnMapping,
\r
1102 UserVnPnMapping userVnPnMapping,
\r
1103 PhysicalNetwork physicalNetwork) {
\r
1104 if ( null == user.getOperations() ) {
\r
1108 List<Operation> operations = user.getOperations().getOperation();
\r
1110 if ( null == operations || operations.isEmpty() ) {
\r
1114 Operation operation = operations.get(0);
\r
1116 List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Flow> nemoFlows =
\r
1117 user.getObjects().getFlow();
\r
1118 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.FlowId nemoFlowId =
\r
1119 new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.FlowId(operation.getTargetObject().getValue());
\r
1120 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Flow nemoFlow =
\r
1121 getFlow(nemoFlows, nemoFlowId);
\r
1123 long priority = 1 + operation.getPriority();
\r
1125 List<IntentVnMappingResult> intentVnMappingResults = userIntentVnMapping.getIntentVnMappingResult();
\r
1126 List<VnPnMappingResult> vnPnMappingResults = userVnPnMapping.getVnPnMappingResult();
\r
1127 IntentId intentId = new IntentId(operation.getOperationId().getValue());
\r
1128 IntentVnMappingResult intentVnMappingResult = getIntentVnMappingResult(intentVnMappingResults, intentId);
\r
1129 List<VirtualResource> virtualResources = sortVirtualResources(intentVnMappingResult.getVirtualResource());
\r
1130 Iterator<VirtualResource> iterator = virtualResources.iterator();
\r
1131 VirtualResource virtualResource;
\r
1132 VirtualResource virtualResource1 = null;
\r
1133 VirtualPathId virtualPathId;
\r
1134 VirtualPath virtualPath;
\r
1135 VirtualLinkId virtualLinkId;
\r
1136 VirtualLink virtualLink;
\r
1137 VirtualNodeId virtualNodeId;
\r
1138 VnPnMappingResult vnPnMappingResult;
\r
1140 Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>> connectedVirtualSwitches;
\r
1141 VirtualPort layer2ExternalVirtualPort;
\r
1142 VirtualPort layer3ExternalVirtualPort;
\r
1144 PhysicalPathId physicalPathId;
\r
1145 PhysicalPathId physicalPathId1;
\r
1146 PhysicalPath physicalPath;
\r
1147 PhysicalPath physicalPath1;
\r
1148 PhysicalNodeId physicalNodeId;
\r
1149 PhysicalNodeId physicalNodeId1;
\r
1150 PhysicalPortId physicalPortId;
\r
1151 PhysicalPortId physicalPortId1;
\r
1152 PhysicalLink physicalLink;
\r
1153 PhysicalPort physicalPort;
\r
1154 PhysicalPort physicalPort1;
\r
1156 while ( iterator.hasNext() ) {
\r
1157 virtualResource = iterator.next();
\r
1159 if ( null == virtualResource1 ) {
\r
1160 if ( VirtualResource.VirtualResourceType.Vpath
\r
1161 == virtualResource.getVirtualResourceType() ) {
\r
1162 virtualPathId = new VirtualPathId(virtualResource.getVirtualResourceEntityId().getValue());
\r
1163 virtualPath = virtualNetworkHelper.getVirtualPath(virtualPathId);
\r
1164 virtualLinkId = virtualPath.getVirtualLink().get(0).getLinkId();
\r
1165 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1166 new VirtualResourceEntityId(virtualLinkId.getValue()));
\r
1167 physicalPathId = new PhysicalPathId(vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1168 physicalPath = physicalNetworkHelper.getPhysicalPath(physicalPathId);
\r
1170 if ( physicalPath.getPhysicalLink().isEmpty() ) {
\r
1173 virtualLink = virtualNetworkHelper.getVirtualLink(virtualLinkId);
\r
1174 connectedVirtualSwitches = virtualNetworkHelper
\r
1175 .getConnectedVirtualSwitches(virtualLink.getSrcNodeId());
\r
1177 if ( null != connectedVirtualSwitches ) {
\r
1178 for ( Map.Entry<VirtualPort, VirtualLink> entry : connectedVirtualSwitches.values() ) {
\r
1179 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1180 new VirtualResourceEntityId(entry.getValue().getLinkId().getValue()));
\r
1181 physicalPathId1 = new PhysicalPathId(
\r
1182 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1183 physicalPath1 = physicalNetworkHelper.getPhysicalPath(physicalPathId1);
\r
1184 physicalLink = physicalNetworkHelper
\r
1185 .getFirstPhysicalLinkOfPhysicalPath(physicalPath1);
\r
1186 physicalPort = physicalNetworkHelper
\r
1187 .getPhysicalPort(physicalLink.getSrcNodeId(), physicalLink.getSrcPortId());
\r
1189 configIpTableEntryForOperation(user.getUserId(), nemoFlow,
\r
1190 physicalPort, physicalPath, (short)priority, true);
\r
1194 layer3ExternalVirtualPort = virtualNetworkHelper
\r
1195 .getLayer3ExternalVirtualPort(virtualLink.getSrcNodeId());
\r
1197 if ( null != layer3ExternalVirtualPort ) {
\r
1198 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1199 new VirtualResourceEntityId(layer3ExternalVirtualPort.getPortId().getValue()));
\r
1200 physicalNodeId = new PhysicalNodeId(
\r
1201 vnPnMappingResult.getParentPhysicalResourceEntityId().getValue());
\r
1202 physicalPortId = new PhysicalPortId(
\r
1203 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1204 physicalPort = physicalNetworkHelper.getPhysicalPort(physicalNodeId, physicalPortId);
\r
1206 configIpTableEntryForOperation(user.getUserId(), nemoFlow,
\r
1207 physicalPort, physicalPath, (short)priority, true);
\r
1210 layer2ExternalVirtualPort = virtualNetworkHelper
\r
1211 .getLayer2ExternalVirtualPort(virtualLink.getSrcNodeId());
\r
1213 if ( null != layer2ExternalVirtualPort ) {
\r
1214 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1215 new VirtualResourceEntityId(layer2ExternalVirtualPort.getPortId().getValue()));
\r
1216 physicalNodeId = new PhysicalNodeId(
\r
1217 vnPnMappingResult.getParentPhysicalResourceEntityId().getValue());
\r
1218 physicalPortId = new PhysicalPortId(
\r
1219 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1220 physicalPort = physicalNetworkHelper.getPhysicalPort(physicalNodeId, physicalPortId);
\r
1222 configIpTableEntryForOperation(user.getUserId(), nemoFlow,
\r
1223 physicalPort, physicalPath, (short)priority, true);
\r
1226 } else if ( VirtualResource.VirtualResourceType.Vport
\r
1227 == virtualResource.getVirtualResourceType() ) {
\r
1228 virtualNodeId = new VirtualNodeId(virtualResource.getParentVirtualResourceEntityId().getValue());
\r
1229 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1230 new VirtualResourceEntityId(virtualResource.getVirtualResourceEntityId().getValue()));
\r
1231 physicalNodeId = new PhysicalNodeId(
\r
1232 vnPnMappingResult.getParentPhysicalResourceEntityId().getValue());
\r
1233 physicalPortId = new PhysicalPortId(vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1234 physicalPort = physicalNetworkHelper.getPhysicalPort(physicalNodeId, physicalPortId);
\r
1236 connectedVirtualSwitches = virtualNetworkHelper.getConnectedVirtualSwitches(virtualNodeId);
\r
1238 if ( null != connectedVirtualSwitches ) {
\r
1239 for ( Map.Entry<VirtualPort, VirtualLink> entry : connectedVirtualSwitches.values() ) {
\r
1240 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1241 new VirtualResourceEntityId(entry.getValue().getLinkId().getValue()));
\r
1242 physicalPathId = new PhysicalPathId(
\r
1243 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1244 physicalPath = physicalNetworkHelper.getPhysicalPath(physicalPathId);
\r
1245 physicalLink = physicalNetworkHelper
\r
1246 .getFirstPhysicalLinkOfPhysicalPath(physicalPath);
\r
1247 physicalPort1 = physicalNetworkHelper
\r
1248 .getPhysicalPort(physicalLink.getSrcNodeId(), physicalLink.getSrcPortId());
\r
1250 configIpTableEntryForOperation(user.getUserId(), nemoFlow,
\r
1251 physicalNodeId, physicalPort1, physicalPort, (short)priority, true);
\r
1255 layer3ExternalVirtualPort = virtualNetworkHelper.getLayer3ExternalVirtualPort(virtualNodeId);
\r
1257 if ( null != layer3ExternalVirtualPort ) {
\r
1258 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1259 new VirtualResourceEntityId(layer3ExternalVirtualPort.getPortId().getValue()));
\r
1260 physicalNodeId1 = new PhysicalNodeId(
\r
1261 vnPnMappingResult.getParentPhysicalResourceEntityId().getValue());
\r
1262 physicalPortId1 = new PhysicalPortId(
\r
1263 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1264 physicalPort1 = physicalNetworkHelper.getPhysicalPort(physicalNodeId1, physicalPortId1);
\r
1266 configIpTableEntryForOperation(user.getUserId(), nemoFlow,
\r
1267 physicalNodeId1, physicalPort1, physicalPort, (short)priority, true);
\r
1270 layer2ExternalVirtualPort = virtualNetworkHelper.getLayer2ExternalVirtualPort(virtualNodeId);
\r
1272 if ( null != layer2ExternalVirtualPort ) {
\r
1273 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1274 new VirtualResourceEntityId(layer2ExternalVirtualPort.getPortId().getValue()));
\r
1275 physicalNodeId1 = new PhysicalNodeId(
\r
1276 vnPnMappingResult.getParentPhysicalResourceEntityId().getValue());
\r
1277 physicalPortId1 = new PhysicalPortId(
\r
1278 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1279 physicalPort1 = physicalNetworkHelper.getPhysicalPort(physicalNodeId1, physicalPortId1);
\r
1281 configIpTableEntryForOperation(user.getUserId(), nemoFlow,
\r
1282 physicalNodeId1, physicalPort1, physicalPort, (short)priority, true);
\r
1286 if ( VirtualResource.VirtualResourceType.Vport == virtualResource1.getVirtualResourceType()
\r
1287 && VirtualResource.VirtualResourceType.Vpath == virtualResource.getVirtualResourceType() ) {
\r
1288 virtualPathId = new VirtualPathId(virtualResource.getVirtualResourceEntityId().getValue());
\r
1289 virtualPath = virtualNetworkHelper.getVirtualPath(virtualPathId);
\r
1290 virtualLinkId = virtualPath.getVirtualLink().get(0).getLinkId();
\r
1291 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1292 new VirtualResourceEntityId(virtualLinkId.getValue()));
\r
1293 physicalPathId = new PhysicalPathId(vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1294 physicalPath = physicalNetworkHelper.getPhysicalPath(physicalPathId);
\r
1296 if ( physicalPath.getPhysicalLink().isEmpty() ) {
\r
1299 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1300 new VirtualResourceEntityId(virtualResource1.getVirtualResourceEntityId().getValue()));
\r
1301 physicalNodeId = new PhysicalNodeId(
\r
1302 vnPnMappingResult.getParentPhysicalResourceEntityId().getValue());
\r
1303 physicalPortId = new PhysicalPortId(
\r
1304 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1305 physicalPort = physicalNetworkHelper.getPhysicalPort(physicalNodeId, physicalPortId);
\r
1307 configIpTableEntryForOperation(user.getUserId(), nemoFlow,
\r
1308 physicalPort, physicalPath, (short)priority, true);
\r
1310 } else if ( VirtualResource.VirtualResourceType.Vpath == virtualResource1.getVirtualResourceType()
\r
1311 && VirtualResource.VirtualResourceType.Vport == virtualResource.getVirtualResourceType() ) {
\r
1312 virtualPathId = new VirtualPathId(virtualResource1.getVirtualResourceEntityId().getValue());
\r
1313 virtualPath = virtualNetworkHelper.getVirtualPath(virtualPathId);
\r
1314 virtualLinkId = virtualPath.getVirtualLink().get(0).getLinkId();
\r
1315 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1316 new VirtualResourceEntityId(virtualLinkId.getValue()));
\r
1317 physicalPathId = new PhysicalPathId(vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1318 physicalPath = physicalNetworkHelper.getPhysicalPath(physicalPathId);
\r
1319 physicalLink = physicalNetworkHelper.getLastPhysicalLinkOfPhysicalPath(physicalPath);
\r
1320 physicalPort1 = physicalNetworkHelper
\r
1321 .getPhysicalPort(physicalLink.getDestNodeId(), physicalLink.getDestPortId());
\r
1323 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1324 new VirtualResourceEntityId(virtualResource.getVirtualResourceEntityId().getValue()));
\r
1325 physicalNodeId = new PhysicalNodeId(
\r
1326 vnPnMappingResult.getParentPhysicalResourceEntityId().getValue());
\r
1327 physicalPortId = new PhysicalPortId(
\r
1328 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1329 physicalPort = physicalNetworkHelper.getPhysicalPort(physicalNodeId, physicalPortId);
\r
1331 configIpTableEntryForOperation(user.getUserId(), nemoFlow,
\r
1332 physicalNodeId, physicalPort1, physicalPort, (short)priority, true);
\r
1333 } else if ( VirtualResource.VirtualResourceType.Vport == virtualResource1.getVirtualResourceType()
\r
1334 && VirtualResource.VirtualResourceType.Vport == virtualResource.getVirtualResourceType() ) {
\r
1335 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1336 new VirtualResourceEntityId(virtualResource1.getVirtualResourceEntityId().getValue()));
\r
1337 physicalNodeId1 = new PhysicalNodeId(
\r
1338 vnPnMappingResult.getParentPhysicalResourceEntityId().getValue());
\r
1339 physicalPortId1 = new PhysicalPortId(
\r
1340 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1341 physicalPort1 = physicalNetworkHelper.getPhysicalPort(physicalNodeId1, physicalPortId1);
\r
1343 vnPnMappingResult = getVnPnMappingResult(vnPnMappingResults,
\r
1344 new VirtualResourceEntityId(virtualResource.getVirtualResourceEntityId().getValue()));
\r
1345 physicalNodeId = new PhysicalNodeId(
\r
1346 vnPnMappingResult.getParentPhysicalResourceEntityId().getValue());
\r
1347 physicalPortId = new PhysicalPortId(
\r
1348 vnPnMappingResult.getPhysicalResourceEntityId().getValue());
\r
1349 physicalPort = physicalNetworkHelper.getPhysicalPort(physicalNodeId, physicalPortId);
\r
1351 configIpTableEntryForOperation(user.getUserId(), nemoFlow,
\r
1352 physicalNodeId1, physicalPort1, physicalPort, (short)priority, true);
\r
1356 virtualResource1 = virtualResource;
\r
1365 * @author Zhigang Ji, Shixing Liu
\r
1366 * @param physicalNodeId TODO
\r
1367 * @param physicalPortId TODO
\r
1370 private MacAddress getMacAddressOfConnectedExternalDevice(PhysicalNodeId physicalNodeId,
\r
1371 PhysicalPortId physicalPortId) {
\r
1372 com.google.common.collect.Table<PhysicalNodeId, PhysicalPortId, MacAddress> externalNetworkMacTable =
\r
1373 this.resourceManager.getExternalNetworkMacTable();
\r
1375 MacAddress macAddress = externalNetworkMacTable.get(physicalNodeId, physicalPortId);
\r
1376 if(macAddress == null){
\r
1377 LOG.info("nemo: cannot find external network device mac address");
\r
1379 LOG.info("nemo: external network device mac address");
\r
1381 return macAddress;
\r
1387 * @author Zhigang Ji
\r
1388 * @param userIntentVnMapping TODO
\r
1389 * @param virtualNodeId TODO
\r
1392 private MacAddress getGateWayMacAddress(UserIntentVnMapping userIntentVnMapping,
\r
1393 VirtualNodeId virtualNodeId) {
\r
1394 List<IntentVnMappingResult> intentVnMappingResults = userIntentVnMapping.getIntentVnMappingResult();
\r
1395 VirtualResource virtualResource;
\r
1397 for ( IntentVnMappingResult intentVnMappingResult : intentVnMappingResults ) {
\r
1398 virtualResource = intentVnMappingResult.getVirtualResource().get(0);
\r
1400 if ( virtualResource.getVirtualResourceEntityId().getValue().equals(virtualNodeId.getValue()) ) {
\r
1401 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeId nodeId =
\r
1402 new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeId(intentVnMappingResult.getIntentId().getValue());
\r
1404 return gatewayMacAddress.get(nodeId);
\r
1414 * @author Zhigang Ji
\r
1415 * @param flows TODO
\r
1416 * @param flowId TODO
\r
1419 private org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Flow getFlow(
\r
1420 List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Flow> flows,
\r
1421 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.FlowId flowId) {
\r
1422 for ( org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Flow
\r
1424 if ( flow.getFlowId().equals(flowId) ) {
\r
1435 * @author Zhigang Ji
\r
1436 * @param matchItems TODO
\r
1437 * @param matchItemName TODO
\r
1440 private MatchItem getMatchItem(List<MatchItem> matchItems, MatchItemName matchItemName) {
\r
1441 for ( MatchItem matchItem : matchItems ) {
\r
1442 if ( matchItem.getMatchItemName().equals(matchItemName) ) {
\r
1453 * @author Zhigang Ji
\r
1454 * @param intentVnMappingResults TODO
\r
1455 * @param intentId TODO
\r
1458 private IntentVnMappingResult getIntentVnMappingResult(
\r
1459 List<IntentVnMappingResult> intentVnMappingResults, IntentId intentId) {
\r
1460 for ( IntentVnMappingResult intentVnMappingResult : intentVnMappingResults ) {
\r
1461 if ( intentVnMappingResult.getIntentId().equals(intentId) ) {
\r
1462 return intentVnMappingResult;
\r
1472 * @author Zhigang Ji
\r
1473 * @param vnPnMappingResults TODO
\r
1474 * @param virtualResourceEntityId TODO
\r
1477 private VnPnMappingResult getVnPnMappingResult(List<VnPnMappingResult> vnPnMappingResults,
\r
1478 VirtualResourceEntityId virtualResourceEntityId) {
\r
1479 for ( VnPnMappingResult vnPnMappingResult : vnPnMappingResults ) {
\r
1480 if ( vnPnMappingResult.getVirtualResourceEntityId().equals(virtualResourceEntityId) ) {
\r
1481 return vnPnMappingResult;
\r
1491 * @author Zhigang Ji
\r
1492 * @param virtualResources TODO
\r
1495 private List<VirtualResource> sortVirtualResources(List<VirtualResource> virtualResources) {
\r
1496 if ( null == virtualResources || 2 > virtualResources.size() ) {
\r
1497 return virtualResources;
\r
1500 List<VirtualResource> sortedVirtualResources =
\r
1501 new ArrayList<VirtualResource>(virtualResources.size());
\r
1502 sortedVirtualResources.addAll(virtualResources);
\r
1504 for ( VirtualResource virtualResource : virtualResources ) {
\r
1505 sortedVirtualResources.set(virtualResource.getOrder().intValue(), virtualResource);
\r
1508 return sortedVirtualResources;
\r
1514 * @author Zhigang Ji
\r
1515 * @param userId TODO
\r
1516 * @param macAddress TODO
\r
1517 * @param physicalNodeId TODO
\r
1518 * @param physicalPort TODO
\r
1520 private void configMacTableEntry(UserId userId, MacAddress macAddress,
\r
1521 PhysicalNodeId physicalNodeId, PhysicalPort physicalPort) {
\r
1522 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
1523 List<Instruction> instructionList = new LinkedList<Instruction>();
\r
1524 List<Action> actionList = new LinkedList<Action>();
\r
1526 EthernetMatchBuilder ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetDestination(new EthernetDestinationBuilder().setAddress(macAddress).build());
\r
1527 EthernetMatch ethernetMatch = ethernetMatchBuilder.build();
\r
1529 MetadataBuilder metadataBuilder = new MetadataBuilder().setMetadata(BigInteger.valueOf(metadatas.get(userId)));
\r
1530 Metadata metadata = metadataBuilder.build();
\r
1532 Match match = new MatchBuilder().setEthernetMatch(ethernetMatch).setMetadata(metadata).build();
\r
1534 OutputAction outputAction = new OutputActionBuilder().setOutputNodeConnector(createNodeConnectorId(physicalPort.getPortId())).build();
\r
1535 OutputActionCase outputActionCase = new OutputActionCaseBuilder().setOutputAction(outputAction).build();
\r
1536 Action actionOutput = new ActionBuilder().setOrder(actionList.size()).setAction(outputActionCase).build();
\r
1537 actionList.add(actionOutput);
\r
1539 ApplyActions applyActions = new ApplyActionsBuilder().setAction(actionList).build();
\r
1540 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
\r
1541 Instruction instructionApply = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(applyActionsCase).build();
\r
1542 instructionList.add(instructionApply);
\r
1544 Instructions instructions = new InstructionsBuilder().setInstruction(instructionList).build();
\r
1546 FlowId flowId = new FlowId(UUID.randomUUID().toString());
\r
1547 FlowBuilder flowBuilder = baseFlowBuilder().setId(flowId).setTableId(MAC_TABLE_ID).setPriority(DEFAULT_FLOW_PRIORITY);
\r
1548 Flow flow = flowBuilder.setMatch(match).setInstructions(instructions).build();
\r
1550 NodeId nodeId = createNodeId(physicalNodeId);
\r
1551 InstanceIdentifier<Flow> flowInsId = generateFlowInsId(userId, nodeId, flow.getTableId(), flow.getId());
\r
1553 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowInsId, flow, true);
\r
1554 writeTransaction.submit();
\r
1562 * @author Zhigang Ji
\r
1563 * @param userId TODO
\r
1564 * @param macAddress TODO
\r
1565 * @param physicalPath TODO
\r
1567 private void configMacTableEntry(UserId userId, MacAddress macAddress,
\r
1568 PhysicalPath physicalPath) {
\r
1569 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
1570 List<Instruction> instructionList = new LinkedList<Instruction>();
\r
1571 List<Action> actionList = new LinkedList<Action>();
\r
1573 PhysicalLink physicalLink = physicalNetworkHelper.getFirstPhysicalLinkOfPhysicalPath(physicalPath);
\r
1575 EthernetMatchBuilder ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetDestination(new EthernetDestinationBuilder().setAddress(macAddress).build());
\r
1576 EthernetMatch ethernetMatch = ethernetMatchBuilder.build();
\r
1578 MetadataBuilder metadataBuilder = new MetadataBuilder().setMetadata(BigInteger.valueOf(metadatas.get(userId)));
\r
1579 Metadata metadata = metadataBuilder.build();
\r
1581 Match match = new MatchBuilder().setEthernetMatch(ethernetMatch).setMetadata(metadata).build();
\r
1583 PushMplsAction pushMplsAction = new PushMplsActionBuilder().setEthernetType(ETH_TYPE_MPLS).build();
\r
1584 PushMplsActionCase pushMplsActionCase = new PushMplsActionCaseBuilder().setPushMplsAction(pushMplsAction).build();
\r
1585 Action actionPushMPLS = new ActionBuilder().setOrder(actionList.size()).setAction(pushMplsActionCase).build();
\r
1586 actionList.add(actionPushMPLS);
\r
1588 SetField setField = new SetFieldBuilder().setProtocolMatchFields(new ProtocolMatchFieldsBuilder().setMplsLabel((long)mplsLabelsOfPhysicalPaths.get(physicalPath.getPathId()).get(0)).build()).build();
\r
1589 SetFieldCase setFieldCase = new SetFieldCaseBuilder().setSetField(setField).build();
\r
1590 Action actionSetField = new ActionBuilder().setOrder(actionList.size()).setAction(setFieldCase).build();
\r
1591 actionList.add(actionSetField);
\r
1593 OutputAction outputAction = new OutputActionBuilder().setOutputNodeConnector(createNodeConnectorId(physicalLink.getSrcPortId())).build();
\r
1594 OutputActionCase outputActionCase = new OutputActionCaseBuilder().setOutputAction(outputAction).build();
\r
1595 Action actionOutput = new ActionBuilder().setOrder(actionList.size()).setAction(outputActionCase).build();
\r
1596 actionList.add(actionOutput);
\r
1598 ApplyActions applyActions = new ApplyActionsBuilder().setAction(actionList).build();
\r
1599 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
\r
1600 Instruction instructionApply = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(applyActionsCase).build();
\r
1601 instructionList.add(instructionApply);
\r
1603 Instructions instructions = new InstructionsBuilder().setInstruction(instructionList).build();
\r
1605 FlowId flowId = new FlowId(UUID.randomUUID().toString());
\r
1606 FlowBuilder flowBuilder = baseFlowBuilder().setId(flowId).setTableId(MAC_TABLE_ID).setPriority(DEFAULT_FLOW_PRIORITY);
\r
1607 Flow flow = flowBuilder.setMatch(match).setInstructions(instructions).build();
\r
1609 NodeId nodeId = createNodeId(physicalLink.getSrcNodeId());
\r
1610 InstanceIdentifier<Flow> flowInsId = generateFlowInsId(userId, nodeId, flow.getTableId(), flow.getId());
\r
1612 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowInsId, flow, true);
\r
1613 writeTransaction.submit();
\r
1621 * @author Zhigang Ji
\r
1622 * @param userId TODO
\r
1623 * @param ipPrefix TODO
\r
1624 * @param physicalNodeId TODO
\r
1625 * @param physicalPort TODO
\r
1626 * @param goToArpTable TODO
\r
1628 private void configIpTableEntry(UserId userId, IpPrefix ipPrefix, PhysicalNodeId physicalNodeId,
\r
1629 PhysicalPort physicalPort, boolean goToArpTable) {
\r
1630 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
1631 List<Instruction> instructionList = new LinkedList<Instruction>();
\r
1632 List<Action> actionList = new LinkedList<Action>();
\r
1634 EthernetMatchBuilder ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetType(new EthernetTypeBuilder().setType(new EtherType((long)ETH_TYPE_IP)).build());
\r
1635 EthernetMatch ethernetMatch = ethernetMatchBuilder.build();
\r
1637 MetadataBuilder metadataBuilder = new MetadataBuilder().setMetadata(BigInteger.valueOf(metadatas.get(userId)));
\r
1638 Metadata metadata = metadataBuilder.build();
\r
1640 Ipv4MatchBuilder ipv4MatchBuilder = new Ipv4MatchBuilder().setIpv4Destination(ipPrefix.getIpv4Prefix());
\r
1641 Ipv4Match ipv4Match = ipv4MatchBuilder.build();
\r
1643 Match match = new MatchBuilder().setEthernetMatch(ethernetMatch).setMetadata(metadata).setLayer3Match(ipv4Match).build();
\r
1645 DecNwTtl decNwTtl = new DecNwTtlBuilder().build();
\r
1646 DecNwTtlCase decNwTtlCase = new DecNwTtlCaseBuilder().setDecNwTtl(decNwTtl).build();
\r
1647 Action actionDecNW = new ActionBuilder().setOrder(actionList.size()).setAction(decNwTtlCase).build();
\r
1648 actionList.add(actionDecNW);
\r
1650 ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetSource(new EthernetSourceBuilder().setAddress(physicalPort.getMacAddress()).build());
\r
1651 ethernetMatch = ethernetMatchBuilder.build();
\r
1653 SetField setField = new SetFieldBuilder().setEthernetMatch(ethernetMatch).build();
\r
1654 SetFieldCase setFieldCase = new SetFieldCaseBuilder().setSetField(setField).build();
\r
1655 Action actionSetField = new ActionBuilder().setOrder(actionList.size()).setAction(setFieldCase).build();
\r
1656 actionList.add(actionSetField);
\r
1658 if ( goToArpTable )
\r
1660 ApplyActions applyActions = new ApplyActionsBuilder().setAction(actionList).build();
\r
1661 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
\r
1662 Instruction instructionApply = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(applyActionsCase).build();
\r
1663 instructionList.add(instructionApply);
\r
1665 WriteMetadata writeMetadata = new WriteMetadataBuilder().setMetadata(BigInteger.valueOf(metadatas.get(userId))).setMetadataMask(new BigInteger(DEFAULT_METADATA_MASK, 16)).build();
\r
1666 WriteMetadataCase writeMetadataCase = new WriteMetadataCaseBuilder().setWriteMetadata(writeMetadata).build();
\r
1667 Instruction instructionMeta = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(writeMetadataCase).build();
\r
1668 instructionList.add(instructionMeta);
\r
1670 GoToTable gotoTable = new GoToTableBuilder().setTableId(ARP_TABLE_ID).build();
\r
1671 GoToTableCase gotoTableCase = new GoToTableCaseBuilder().setGoToTable(gotoTable).build();
\r
1672 Instruction instructionGoto = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(gotoTableCase).build();
\r
1673 instructionList.add(instructionGoto);
\r
1677 ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetDestination(new EthernetDestinationBuilder().setAddress(getMacAddressOfConnectedExternalDevice(physicalNodeId, physicalPort.getPortId())).build());
\r
1678 ethernetMatch = ethernetMatchBuilder.build();
\r
1680 setField = new SetFieldBuilder().setEthernetMatch(ethernetMatch).build();
\r
1681 setFieldCase = new SetFieldCaseBuilder().setSetField(setField).build();
\r
1682 actionSetField = new ActionBuilder().setOrder(actionList.size()).setAction(setFieldCase).build();
\r
1683 actionList.add(actionSetField);
\r
1685 OutputAction outputAction = new OutputActionBuilder().setOutputNodeConnector(createNodeConnectorId(physicalPort.getPortId())).build();
\r
1686 OutputActionCase outputActionCase = new OutputActionCaseBuilder().setOutputAction(outputAction).build();
\r
1687 Action actionOutput = new ActionBuilder().setOrder(actionList.size()).setAction(outputActionCase).build();
\r
1688 actionList.add(actionOutput);
\r
1690 ApplyActions applyActions = new ApplyActionsBuilder().setAction(actionList).build();
\r
1691 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
\r
1692 Instruction instructionApply = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(applyActionsCase).build();
\r
1693 instructionList.add(instructionApply);
\r
1696 Instructions instructions = new InstructionsBuilder().setInstruction(instructionList).build();
\r
1698 FlowId flowId = new FlowId(UUID.randomUUID().toString());
\r
1699 FlowBuilder flowBuilder = baseFlowBuilder().setId(flowId).setTableId(IP_TABLE_ID).setPriority(DEFAULT_FLOW_PRIORITY);
\r
1700 Flow flow = flowBuilder.setMatch(match).setInstructions(instructions).build();
\r
1702 NodeId nodeId = createNodeId(physicalNodeId);
\r
1703 InstanceIdentifier<Flow> flowInsId = generateFlowInsId(userId, nodeId, flow.getTableId(), flow.getId());
\r
1705 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowInsId, flow, true);
\r
1706 writeTransaction.submit();
\r
1714 * @author Zhigang Ji
\r
1715 * @param userId TODO
\r
1716 * @param ipPrefix TODO
\r
1717 * @param physicalPath TODO
\r
1718 * @param goToArpTable TODO
\r
1720 private void configIpTableEntry(UserId userId, IpPrefix ipPrefix,
\r
1721 PhysicalPath physicalPath, boolean goToArpTable) {
\r
1722 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
1723 List<Instruction> instructionList = new LinkedList<Instruction>();
\r
1724 List<Action> actionList = new LinkedList<Action>();
\r
1726 PhysicalLink physicalLink = physicalNetworkHelper.getFirstPhysicalLinkOfPhysicalPath(physicalPath);
\r
1728 EthernetMatchBuilder ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetType(new EthernetTypeBuilder().setType(new EtherType((long)ETH_TYPE_IP)).build());
\r
1729 EthernetMatch ethernetMatch = ethernetMatchBuilder.build();
\r
1731 MetadataBuilder metadataBuilder = new MetadataBuilder().setMetadata(BigInteger.valueOf(metadatas.get(userId)));
\r
1732 Metadata metadata = metadataBuilder.build();
\r
1734 Ipv4MatchBuilder ipv4MatchBuilder = new Ipv4MatchBuilder().setIpv4Destination(ipPrefix.getIpv4Prefix());
\r
1735 Ipv4Match ipv4Match = ipv4MatchBuilder.build();
\r
1737 Match match = new MatchBuilder().setEthernetMatch(ethernetMatch).setMetadata(metadata).setLayer3Match(ipv4Match).build();
\r
1739 if ( 0 < physicalPath.getBandwidth() ) {
\r
1740 org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.meter._case.Meter
\r
1741 meter = new org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.meter._case.MeterBuilder()
\r
1742 .setMeterId(new MeterId(meterIdsOfPhysicalPaths.get(physicalPath.getPathId()))).build();
\r
1743 MeterCase meterCase = new MeterCaseBuilder().setMeter(meter).build();
\r
1744 Instruction instructionMeter = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(meterCase).build();
\r
1745 instructionList.add(instructionMeter);
\r
1748 DecNwTtl decNwTtl = new DecNwTtlBuilder().build();
\r
1749 DecNwTtlCase decNwTtlCase = new DecNwTtlCaseBuilder().setDecNwTtl(decNwTtl).build();
\r
1750 Action actionDecNW = new ActionBuilder().setOrder(actionList.size()).setAction(decNwTtlCase).build();
\r
1751 actionList.add(actionDecNW);
\r
1753 if ( goToArpTable )
\r
1755 PhysicalPort physicalPort = physicalNetworkHelper.getPhysicalPort(physicalLink.getSrcNodeId(), physicalLink.getSrcPortId());
\r
1757 ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetSource(new EthernetSourceBuilder().setAddress(physicalPort.getMacAddress()).build());
\r
1758 ethernetMatch = ethernetMatchBuilder.build();
\r
1760 SetField setField = new SetFieldBuilder().setEthernetMatch(ethernetMatch).build();
\r
1761 SetFieldCase setFieldCase = new SetFieldCaseBuilder().setSetField(setField).build();
\r
1762 Action actionSetField = new ActionBuilder().setOrder(actionList.size()).setAction(setFieldCase).build();
\r
1763 actionList.add(actionSetField);
\r
1765 ApplyActions applyActions = new ApplyActionsBuilder().setAction(actionList).build();
\r
1766 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
\r
1767 Instruction instructionApply = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(applyActionsCase).build();
\r
1768 instructionList.add(instructionApply);
\r
1770 WriteMetadata writeMetadata = new WriteMetadataBuilder().setMetadata(BigInteger.valueOf(metadatas.get(userId))).setMetadataMask(new BigInteger(DEFAULT_METADATA_MASK, 16)).build();
\r
1771 WriteMetadataCase writeMetadataCase = new WriteMetadataCaseBuilder().setWriteMetadata(writeMetadata).build();
\r
1772 Instruction instructionMeta = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(writeMetadataCase).build();
\r
1773 instructionList.add(instructionMeta);
\r
1775 GoToTable gotoTable = new GoToTableBuilder().setTableId(ARP_TABLE_ID).build();
\r
1776 GoToTableCase gotoTableCase = new GoToTableCaseBuilder().setGoToTable(gotoTable).build();
\r
1777 Instruction instructionGoto = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(gotoTableCase).build();
\r
1778 instructionList.add(instructionGoto);
\r
1782 PushMplsAction pushMplsAction = new PushMplsActionBuilder().setEthernetType(ETH_TYPE_MPLS).build();
\r
1783 PushMplsActionCase pushMplsActionCase = new PushMplsActionCaseBuilder().setPushMplsAction(pushMplsAction).build();
\r
1784 Action actionPushMPLS = new ActionBuilder().setOrder(actionList.size()).setAction(pushMplsActionCase).build();
\r
1785 actionList.add(actionPushMPLS);
\r
1787 SetField setField = new SetFieldBuilder().setProtocolMatchFields(new ProtocolMatchFieldsBuilder().setMplsLabel((long)mplsLabelsOfPhysicalPaths.get(physicalPath.getPathId()).get(0)).build()).build();
\r
1788 SetFieldCase setFieldCase = new SetFieldCaseBuilder().setSetField(setField).build();
\r
1789 Action actionSetField = new ActionBuilder().setOrder(actionList.size()).setAction(setFieldCase).build();
\r
1790 actionList.add(actionSetField);
\r
1792 OutputAction outputAction = new OutputActionBuilder().setOutputNodeConnector(createNodeConnectorId(physicalLink.getSrcPortId())).build();
\r
1793 OutputActionCase outputActionCase = new OutputActionCaseBuilder().setOutputAction(outputAction).build();
\r
1794 Action actionOutput = new ActionBuilder().setOrder(actionList.size()).setAction(outputActionCase).build();
\r
1795 actionList.add(actionOutput);
\r
1797 ApplyActions applyActions = new ApplyActionsBuilder().setAction(actionList).build();
\r
1798 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
\r
1799 Instruction instructionApply = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(applyActionsCase).build();
\r
1800 instructionList.add(instructionApply);
\r
1803 Instructions instructions = new InstructionsBuilder().setInstruction(instructionList).build();
\r
1805 FlowId flowId = new FlowId(UUID.randomUUID().toString());
\r
1806 FlowBuilder flowBuilder = baseFlowBuilder().setId(flowId).setTableId(IP_TABLE_ID).setPriority(DEFAULT_FLOW_PRIORITY);
\r
1807 Flow flow = flowBuilder.setMatch(match).setInstructions(instructions).build();
\r
1809 NodeId nodeId = createNodeId(physicalLink.getSrcNodeId());
\r
1810 InstanceIdentifier<Flow> flowInsId = generateFlowInsId(userId, nodeId, flow.getTableId(), flow.getId());
\r
1812 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowInsId, flow, true);
\r
1813 writeTransaction.submit();
\r
1821 * @author Zhigang Ji
\r
1822 * @param userId TODO
\r
1823 * @param ipPrefix TODO
\r
1824 * @param macAddress TODO
\r
1825 * @param physicalNodeId TODO
\r
1827 private void configIpTableEntry(UserId userId, IpPrefix ipPrefix,
\r
1828 MacAddress macAddress, PhysicalNodeId physicalNodeId) {
\r
1829 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
1830 List<Instruction> instructionList = new LinkedList<Instruction>();
\r
1831 List<Action> actionList = new LinkedList<Action>();
\r
1833 EthernetMatchBuilder ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetType(new EthernetTypeBuilder().setType(new EtherType((long)ETH_TYPE_IP)).build());
\r
1834 EthernetMatch ethernetMatch = ethernetMatchBuilder.build();
\r
1836 MetadataBuilder metadataBuilder = new MetadataBuilder().setMetadata(BigInteger.valueOf(metadatas.get(userId)));
\r
1837 Metadata metadata = metadataBuilder.build();
\r
1839 Ipv4MatchBuilder ipv4MatchBuilder = new Ipv4MatchBuilder().setIpv4Destination(ipPrefix.getIpv4Prefix());
\r
1840 Ipv4Match ipv4Match = ipv4MatchBuilder.build();
\r
1842 Match match = new MatchBuilder().setEthernetMatch(ethernetMatch).setMetadata(metadata).setLayer3Match(ipv4Match).build();
\r
1844 DecNwTtl decNwTtl = new DecNwTtlBuilder().build();
\r
1845 DecNwTtlCase decNwTtlCase = new DecNwTtlCaseBuilder().setDecNwTtl(decNwTtl).build();
\r
1846 Action actionDecNW = new ActionBuilder().setOrder(actionList.size()).setAction(decNwTtlCase).build();
\r
1847 actionList.add(actionDecNW);
\r
1849 ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetSource(new EthernetSourceBuilder().setAddress(macAddress).build());
\r
1850 ethernetMatch = ethernetMatchBuilder.build();
\r
1852 SetField setField = new SetFieldBuilder().setEthernetMatch(ethernetMatch).build();
\r
1853 SetFieldCase setFieldCase = new SetFieldCaseBuilder().setSetField(setField).build();
\r
1854 Action actionSetField = new ActionBuilder().setOrder(actionList.size()).setAction(setFieldCase).build();
\r
1855 actionList.add(actionSetField);
\r
1857 ApplyActions applyActions = new ApplyActionsBuilder().setAction(actionList).build();
\r
1858 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
\r
1859 Instruction instructionApply = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(applyActionsCase).build();
\r
1860 instructionList.add(instructionApply);
\r
1862 WriteMetadata writeMetadata = new WriteMetadataBuilder().setMetadata(BigInteger.valueOf(metadatas.get(userId))).setMetadataMask(new BigInteger(DEFAULT_METADATA_MASK, 16)).build();
\r
1863 WriteMetadataCase writeMetadataCase = new WriteMetadataCaseBuilder().setWriteMetadata(writeMetadata).build();
\r
1864 Instruction instructionMeta = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(writeMetadataCase).build();
\r
1865 instructionList.add(instructionMeta);
\r
1867 GoToTable gotoTable = new GoToTableBuilder().setTableId(ARP_TABLE_ID).build();
\r
1868 GoToTableCase gotoTableCase = new GoToTableCaseBuilder().setGoToTable(gotoTable).build();
\r
1869 Instruction instructionGoto = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(gotoTableCase).build();
\r
1870 instructionList.add(instructionGoto);
\r
1872 Instructions instructions = new InstructionsBuilder().setInstruction(instructionList).build();
\r
1874 FlowId flowId = new FlowId(UUID.randomUUID().toString());
\r
1875 FlowBuilder flowBuilder = baseFlowBuilder().setId(flowId).setTableId(IP_TABLE_ID).setPriority(DEFAULT_FLOW_PRIORITY);
\r
1876 Flow flow = flowBuilder.setMatch(match).setInstructions(instructions).build();
\r
1878 NodeId nodeId = createNodeId(physicalNodeId);
\r
1879 InstanceIdentifier<Flow> flowInsId = generateFlowInsId(userId, nodeId, flow.getTableId(), flow.getId());
\r
1881 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowInsId, flow, true);
\r
1882 writeTransaction.submit();
\r
1890 * @author Zhigang Ji
\r
1891 * @param userId TODO
\r
1892 * @param virtualArp TODO
\r
1893 * @param physicalPath TODO
\r
1895 private void configArpTableEntry(UserId userId, VirtualArp virtualArp, PhysicalPath physicalPath) {
\r
1896 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
1897 List<Instruction> instructionList = new LinkedList<Instruction>();
\r
1898 List<Action> actionList = new LinkedList<Action>();
\r
1900 PhysicalLink physicalLink = physicalNetworkHelper.getFirstPhysicalLinkOfPhysicalPath(physicalPath);
\r
1902 EthernetMatchBuilder ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetType(new EthernetTypeBuilder().setType(new EtherType((long)ETH_TYPE_IP)).build());
\r
1903 EthernetMatch ethernetMatch = ethernetMatchBuilder.build();
\r
1905 Ipv4MatchBuilder ipv4MatchBuilder = new Ipv4MatchBuilder().setIpv4Destination(convertIpAddressToIpPrefix(virtualArp.getIpAddress()).getIpv4Prefix());
\r
1906 Ipv4Match ipv4Match = ipv4MatchBuilder.build();
\r
1908 MetadataBuilder metadataBuilder = new MetadataBuilder().setMetadata(BigInteger.valueOf(metadatas.get(userId)));
\r
1909 Metadata metadata = metadataBuilder.build();
\r
1911 Match match = new MatchBuilder().setEthernetMatch(ethernetMatch).setLayer3Match(ipv4Match).setMetadata(metadata).build();
\r
1913 PushMplsAction pushMplsAction = new PushMplsActionBuilder().setEthernetType(ETH_TYPE_MPLS).build();
\r
1914 PushMplsActionCase pushMplsActionCase = new PushMplsActionCaseBuilder().setPushMplsAction(pushMplsAction).build();
\r
1915 Action actionPushMPLS = new ActionBuilder().setOrder(actionList.size()).setAction(pushMplsActionCase).build();
\r
1916 actionList.add(actionPushMPLS);
\r
1918 SetField setField = new SetFieldBuilder().setProtocolMatchFields(new ProtocolMatchFieldsBuilder().setMplsLabel((long)mplsLabelsOfPhysicalPaths.get(physicalPath.getPathId()).get(0)).build()).build();
\r
1919 SetFieldCase setFieldCase = new SetFieldCaseBuilder().setSetField(setField).build();
\r
1920 Action actionSetField = new ActionBuilder().setOrder(actionList.size()).setAction(setFieldCase).build();
\r
1921 actionList.add(actionSetField);
\r
1923 ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetDestination(new EthernetDestinationBuilder().setAddress(virtualArp.getMacAddress()).build());
\r
1924 ethernetMatch = ethernetMatchBuilder.build();
\r
1926 setField = new SetFieldBuilder().setEthernetMatch(ethernetMatch).build();
\r
1927 setFieldCase = new SetFieldCaseBuilder().setSetField(setField).build();
\r
1928 actionSetField = new ActionBuilder().setOrder(actionList.size()).setAction(setFieldCase).build();
\r
1929 actionList.add(actionSetField);
\r
1931 OutputAction outputAction = new OutputActionBuilder().setOutputNodeConnector(createNodeConnectorId(physicalLink.getSrcPortId())).build();
\r
1932 OutputActionCase outputActionCase = new OutputActionCaseBuilder().setOutputAction(outputAction).build();
\r
1933 Action actionOutput = new ActionBuilder().setOrder(actionList.size()).setAction(outputActionCase).build();
\r
1934 actionList.add(actionOutput);
\r
1936 ApplyActions applyActions = new ApplyActionsBuilder().setAction(actionList).build();
\r
1937 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
\r
1938 Instruction instructionApply = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(applyActionsCase).build();
\r
1939 instructionList.add(instructionApply);
\r
1941 Instructions instructions = new InstructionsBuilder().setInstruction(instructionList).build();
\r
1943 FlowId flowId = new FlowId(UUID.randomUUID().toString());
\r
1944 FlowBuilder flowBuilder = baseFlowBuilder().setId(flowId).setTableId(ARP_TABLE_ID).setPriority(DEFAULT_FLOW_PRIORITY);
\r
1945 Flow flow = flowBuilder.setMatch(match).setInstructions(instructions).build();
\r
1947 NodeId nodeId = createNodeId(physicalLink.getSrcNodeId());
\r
1948 InstanceIdentifier<Flow> flowInsId = generateFlowInsId(userId, nodeId, flow.getTableId(), flow.getId());
\r
1950 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowInsId, flow, true);
\r
1951 writeTransaction.submit();
\r
1959 * @author Zhigang Ji
\r
1960 * @param userId TODO
\r
1961 * @param nemoFlow TODO
\r
1962 * @param physicalNodeId TODO
\r
1963 * @param inPhysicalPort TODO
\r
1964 * @param outPhysicalPort TODO
\r
1965 * @param policyPriority TODO
\r
1966 * @param layer3Forwarding TODO
\r
1968 private void configIpTableEntryForOperation(UserId userId,
\r
1969 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Flow nemoFlow,
\r
1970 PhysicalNodeId physicalNodeId,
\r
1971 PhysicalPort inPhysicalPort,
\r
1972 PhysicalPort outPhysicalPort,
\r
1973 short policyPriority,
\r
1974 boolean layer3Forwarding) {
\r
1975 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
1976 List<Instruction> instructionList = new LinkedList<Instruction>();
\r
1977 List<Action> actionList = new LinkedList<Action>();
\r
1979 Match match = createMatch(userId, nemoFlow, inPhysicalPort);
\r
1981 if ( layer3Forwarding )
\r
1983 DecNwTtl decNwTtl = new DecNwTtlBuilder().build();
\r
1984 DecNwTtlCase decNwTtlCase = new DecNwTtlCaseBuilder().setDecNwTtl(decNwTtl).build();
\r
1985 Action actionDecNW = new ActionBuilder().setOrder(actionList.size()).setAction(decNwTtlCase).build();
\r
1986 actionList.add(actionDecNW);
\r
1988 EthernetMatchBuilder ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetSource(new EthernetSourceBuilder().setAddress(outPhysicalPort.getMacAddress()).build());
\r
1989 EthernetMatch ethernetMatch = ethernetMatchBuilder.build();
\r
1991 SetField setField = new SetFieldBuilder().setEthernetMatch(ethernetMatch).build();
\r
1992 SetFieldCase setFieldCase = new SetFieldCaseBuilder().setSetField(setField).build();
\r
1993 Action actionSetField = new ActionBuilder().setOrder(actionList.size()).setAction(setFieldCase).build();
\r
1994 actionList.add(actionSetField);
\r
1997 EthernetMatchBuilder ethernetMatchBuilder = new EthernetMatchBuilder().setEthernetDestination(new EthernetDestinationBuilder().setAddress(getMacAddressOfConnectedExternalDevice(physicalNodeId, outPhysicalPort.getPortId())).build());
\r
1998 EthernetMatch ethernetMatch = ethernetMatchBuilder.build();
\r
2000 SetField setField = new SetFieldBuilder().setEthernetMatch(ethernetMatch).build();
\r
2001 SetFieldCase setFieldCase = new SetFieldCaseBuilder().setSetField(setField).build();
\r
2002 Action actionSetField = new ActionBuilder().setOrder(actionList.size()).setAction(setFieldCase).build();
\r
2003 actionList.add(actionSetField);
\r
2005 OutputAction outputAction = new OutputActionBuilder().setOutputNodeConnector(createNodeConnectorId(outPhysicalPort.getPortId())).build();
\r
2006 OutputActionCase outputActionCase = new OutputActionCaseBuilder().setOutputAction(outputAction).build();
\r
2007 Action actionOutput = new ActionBuilder().setOrder(actionList.size()).setAction(outputActionCase).build();
\r
2008 actionList.add(actionOutput);
\r
2010 ApplyActions applyActions = new ApplyActionsBuilder().setAction(actionList).build();
\r
2011 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
\r
2012 Instruction instructionApply = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(applyActionsCase).build();
\r
2013 instructionList.add(instructionApply);
\r
2015 Instructions instructions = new InstructionsBuilder().setInstruction(instructionList).build();
\r
2017 FlowId flowId = new FlowId(UUID.randomUUID().toString());
\r
2018 FlowBuilder flowBuilder = baseFlowBuilder().setId(flowId).setTableId(layer3Forwarding ? IP_TABLE_ID : MAC_TABLE_ID);
\r
2019 Flow flow = flowBuilder.setPriority(DEFAULT_FLOW_PRIORITY + policyPriority).setMatch(match).setInstructions(instructions).build();
\r
2021 NodeId nodeId = createNodeId(physicalNodeId);
\r
2022 InstanceIdentifier<Flow> flowInsId = generateFlowInsId(userId, nodeId, flow.getTableId(), flow.getId());
\r
2024 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowInsId, flow, true);
\r
2025 writeTransaction.submit();
\r
2033 * @author Zhigang Ji
\r
2034 * @param userId TODO
\r
2035 * @param nemoFlow TODO
\r
2036 * @param inPhysicalPort TODO
\r
2037 * @param outPhysicalPath TODO
\r
2038 * @param policyPriority TODO
\r
2039 * @param layer3Forwarding TODO
\r
2041 private void configIpTableEntryForOperation(UserId userId,
\r
2042 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Flow nemoFlow,
\r
2043 PhysicalPort inPhysicalPort,
\r
2044 PhysicalPath outPhysicalPath,
\r
2045 short policyPriority,
\r
2046 boolean layer3Forwarding) {
\r
2047 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
\r
2048 PhysicalLink physicalLink = physicalNetworkHelper.getFirstPhysicalLinkOfPhysicalPath(outPhysicalPath);
\r
2049 List<Instruction> instructionList = new LinkedList<Instruction>();
\r
2050 List<Action> actionList = new LinkedList<Action>();
\r
2052 Match match = createMatch(userId, nemoFlow, inPhysicalPort);
\r
2054 if ( layer3Forwarding )
\r
2056 DecNwTtl decNwTtl = new DecNwTtlBuilder().build();
\r
2057 DecNwTtlCase decNwTtlCase = new DecNwTtlCaseBuilder().setDecNwTtl(decNwTtl).build();
\r
2058 Action actionDecNW = new ActionBuilder().setOrder(actionList.size()).setAction(decNwTtlCase).build();
\r
2059 actionList.add(actionDecNW);
\r
2062 PushMplsAction pushMplsAction = new PushMplsActionBuilder().setEthernetType(ETH_TYPE_MPLS).build();
\r
2063 PushMplsActionCase pushMplsActionCase = new PushMplsActionCaseBuilder().setPushMplsAction(pushMplsAction).build();
\r
2064 Action actionPushMPLS = new ActionBuilder().setOrder(actionList.size()).setAction(pushMplsActionCase).build();
\r
2065 actionList.add(actionPushMPLS);
\r
2067 SetField setField = new SetFieldBuilder().setProtocolMatchFields(new ProtocolMatchFieldsBuilder().setMplsLabel((long)mplsLabelsOfPhysicalPaths.get(outPhysicalPath.getPathId()).get(0)).build()).build();
\r
2068 SetFieldCase setFieldCase = new SetFieldCaseBuilder().setSetField(setField).build();
\r
2069 Action actionSetField = new ActionBuilder().setOrder(actionList.size()).setAction(setFieldCase).build();
\r
2070 actionList.add(actionSetField);
\r
2072 OutputAction outputAction = new OutputActionBuilder().setOutputNodeConnector(createNodeConnectorId(physicalLink.getSrcPortId())).build();
\r
2073 OutputActionCase outputActionCase = new OutputActionCaseBuilder().setOutputAction(outputAction).build();
\r
2074 Action actionOutput = new ActionBuilder().setOrder(actionList.size()).setAction(outputActionCase).build();
\r
2075 actionList.add(actionOutput);
\r
2077 ApplyActions applyActions = new ApplyActionsBuilder().setAction(actionList).build();
\r
2078 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
\r
2079 Instruction instructionApply = new InstructionBuilder().setOrder(instructionList.size()).setInstruction(applyActionsCase).build();
\r
2080 instructionList.add(instructionApply);
\r
2082 Instructions instructions = new InstructionsBuilder().setInstruction(instructionList).build();
\r
2084 FlowId flowId = new FlowId(UUID.randomUUID().toString());
\r
2085 FlowBuilder flowBuilder = baseFlowBuilder().setId(flowId).setTableId(layer3Forwarding ? IP_TABLE_ID : MAC_TABLE_ID);
\r
2086 Flow flow = flowBuilder.setPriority(DEFAULT_FLOW_PRIORITY + policyPriority).setMatch(match).setInstructions(instructions).build();
\r
2088 NodeId nodeId = createNodeId(physicalLink.getSrcNodeId());
\r
2089 InstanceIdentifier<Flow> flowInsId = generateFlowInsId(userId, nodeId, flow.getTableId(), flow.getId());
\r
2091 writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowInsId, flow, true);
\r
2092 writeTransaction.submit();
\r
2100 * @author Zhigang Ji
\r
2101 * @param userId TODO
\r
2102 * @param nemoFlow TODO
\r
2103 * @param physicalPort TODO
\r
2106 private Match createMatch(UserId userId,
\r
2107 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Flow nemoFlow,
\r
2108 PhysicalPort physicalPort) {
\r
2109 List<MatchItem> matchItems = nemoFlow.getMatchItem();
\r
2110 MatchItem srcIpMatchItem = getMatchItem(matchItems, new MatchItemName("src-ip"));
\r
2111 MatchItem dstIpMatchItem = getMatchItem(matchItems, new MatchItemName("dst-ip"));
\r
2113 EthernetMatchBuilder ethernetMatchBuilder = new EthernetMatchBuilder();
\r
2114 Ipv4MatchBuilder ipv4MatchBuilder = new Ipv4MatchBuilder();
\r
2115 MetadataBuilder metadataBuilder = null;
\r
2116 boolean containEthernetMatch = false;
\r
2117 boolean containIpv4Match = false;
\r
2119 if ( null != userId ) {
\r
2120 metadataBuilder = new MetadataBuilder().setMetadata(BigInteger.valueOf(metadatas.get(userId)));
\r
2123 if ( null != srcIpMatchItem || null != dstIpMatchItem ) {
\r
2124 ethernetMatchBuilder = ethernetMatchBuilder.setEthernetType(new EthernetTypeBuilder().setType(new EtherType((long)ETH_TYPE_IP)).build());
\r
2125 containEthernetMatch = true;
\r
2128 if ( null != srcIpMatchItem ) {
\r
2129 String matchItemValue = srcIpMatchItem.getMatchItemValue().getStringValue();
\r
2130 ipv4MatchBuilder = ipv4MatchBuilder.setIpv4Source(new Ipv4Prefix(matchItemValue));
\r
2131 containIpv4Match = true;
\r
2134 if ( null != dstIpMatchItem ) {
\r
2135 String matchItemValue = dstIpMatchItem.getMatchItemValue().getStringValue();
\r
2136 ipv4MatchBuilder = ipv4MatchBuilder.setIpv4Destination(new Ipv4Prefix(matchItemValue));
\r
2137 containIpv4Match = true;
\r
2140 MatchBuilder matchBuilder = new MatchBuilder();
\r
2142 if ( null != physicalPort ) {
\r
2143 matchBuilder = matchBuilder.setInPort(createNodeConnectorId(physicalPort.getPortId()));
\r
2146 if ( containEthernetMatch ) {
\r
2147 matchBuilder = matchBuilder.setEthernetMatch(ethernetMatchBuilder.build());
\r
2150 if ( null != userId ) {
\r
2151 matchBuilder = matchBuilder.setMetadata(metadataBuilder.build());
\r
2154 if ( containIpv4Match ) {
\r
2155 matchBuilder = matchBuilder.setLayer3Match(ipv4MatchBuilder.build());
\r
2158 return matchBuilder.build();
\r
2164 * @author Zhigang Ji
\r
2167 private FlowBuilder baseFlowBuilder() {
\r
2168 return new FlowBuilder().setBarrier(false).setHardTimeout(0).setIdleTimeout(0);
\r
2174 * @author Zhigang Ji
\r
2175 * @param physicalPortId TODO
\r
2178 private NodeConnectorId createNodeConnectorId(PhysicalPortId physicalPortId) {
\r
2179 return new NodeConnectorId(physicalPortId.getValue());
\r
2185 * @author Zhigang Ji
\r
2186 * @param nodeId TODO
\r
2187 * @param nodeConnectorId TODO
\r
2190 private InstanceIdentifier<NodeConnector> createNodeConnectorPath(NodeId nodeId, NodeConnectorId nodeConnectorId) {
\r
2191 return createNodePath(nodeId).child(NodeConnector.class, new NodeConnectorKey(nodeConnectorId));
\r
2197 * @author Zhigang Ji
\r
2198 * @param physicalNodeId TODO
\r
2199 * @param physicalPortId TODO
\r
2202 private NodeConnectorRef createNodeConnectorRef(PhysicalNodeId physicalNodeId, PhysicalPortId physicalPortId) {
\r
2203 return new NodeConnectorRef(createNodeConnectorPath(createNodeId(physicalNodeId), createNodeConnectorId(physicalPortId)));
\r
2209 * @author Zhigang Ji
\r
2210 * @param physicalNodeId TODO
\r
2213 private NodeId createNodeId(PhysicalNodeId physicalNodeId) {
\r
2214 return new NodeId(physicalNodeId.getValue());
\r
2220 * @author Zhigang Ji
\r
2221 * @param nodeId TODO
\r
2224 private InstanceIdentifier<Node> createNodePath(NodeId nodeId) {
\r
2225 return InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(nodeId)).build();
\r
2231 * @author Zhigang Ji
\r
2232 * @param physicalNodeId TODO
\r
2235 private NodeRef createNodeRef(PhysicalNodeId physicalNodeId) {
\r
2236 return new NodeRef(createNodePath(createNodeId(physicalNodeId)));
\r
2242 * @author Zhigang Ji
\r
2243 * @param nodeId TODO
\r
2244 * @param tableId TODO
\r
2247 private InstanceIdentifier<Table> createTablePath(NodeId nodeId, Short tableId) {
\r
2248 return createNodePath(nodeId).builder().augmentation(FlowCapableNode.class).child(Table.class, new TableKey(tableId)).build();
\r
2254 * @author Zhigang Ji
\r
2255 * @param nodeId TODO
\r
2256 * @param tableId TODO
\r
2257 * @param flowId TODO
\r
2260 private InstanceIdentifier<Flow> createFlowPath(NodeId nodeId, Short tableId, FlowId flowId) {
\r
2261 return createTablePath(nodeId, tableId).child(Flow.class, new FlowKey(flowId));
\r
2267 * @author Zhigang Ji
\r
2268 * @param ipAddress TODO
\r
2271 private IpPrefix convertIpAddressToIpPrefix(IpAddress ipAddress) {
\r
2272 return new IpPrefix(new Ipv4Prefix(ipAddress.getIpv4Address().getValue() + "/32"));
\r
2278 * @author Zhigang Ji
\r
2280 private class MplsLabelGenerator {
\r
2281 private int i = 0;
\r
2283 protected int generateMplsLabel() {
\r
2291 * @author Zhigang Ji
\r
2293 private class MeterIdGenerator {
\r
2294 private long i = 0;
\r
2296 protected long generateMeterId() {
\r
2304 * @author Zhigang Ji
\r
2306 private class PhysicalNetworkHelper {
\r
2307 private Map<PhysicalNodeId, PhysicalNode> physicalNodeMap;
\r
2308 private Map<PhysicalLinkId, PhysicalLink> physicalLinkMap;
\r
2309 private Map<PhysicalPathId, PhysicalPath> physicalPathMap;
\r
2310 private Map<PhysicalNodeId, Map<PhysicalPortId, PhysicalPort>> physicalPortMap;
\r
2312 public PhysicalNetworkHelper(PhysicalNetwork physicalNetwork) {
\r
2313 physicalNodeMap = new HashMap<PhysicalNodeId, PhysicalNode>();
\r
2314 physicalLinkMap = new HashMap<PhysicalLinkId, PhysicalLink>();
\r
2315 physicalPathMap = new HashMap<PhysicalPathId, PhysicalPath>();
\r
2316 physicalPortMap = new HashMap<PhysicalNodeId, Map<PhysicalPortId, PhysicalPort>>();
\r
2318 List<PhysicalNode> physicalNodes = physicalNetwork.getPhysicalNodes().getPhysicalNode();
\r
2319 Map<PhysicalPortId, PhysicalPort> physicalPorts;
\r
2321 for ( PhysicalNode physicalNode : physicalNodes ) {
\r
2322 physicalNodeMap.put(physicalNode.getNodeId(), physicalNode);
\r
2324 physicalPorts = new HashMap<PhysicalPortId, PhysicalPort>();
\r
2325 physicalPortMap.put(physicalNode.getNodeId(), physicalPorts);
\r
2327 for ( PhysicalPort physicalPort : physicalNode.getPhysicalPort() ) {
\r
2328 physicalPorts.put(physicalPort.getPortId(), physicalPort);
\r
2332 List<PhysicalLink> physicalLinks = physicalNetwork.getPhysicalLinks().getPhysicalLink();
\r
2334 for ( PhysicalLink physicalLink : physicalLinks ) {
\r
2335 physicalLinkMap.put(physicalLink.getLinkId(), physicalLink);
\r
2338 if ( null != physicalNetwork.getPhysicalPaths() ) {
\r
2339 List<PhysicalPath> physicalPaths = physicalNetwork.getPhysicalPaths().getPhysicalPath();
\r
2341 if ( null != physicalPaths ) {
\r
2342 for ( PhysicalPath physicalPath : physicalPaths ) {
\r
2343 // physicalPathMap.put(physicalPath.getPathId(), physicalPath);
\r
2344 physicalPathMap.put(physicalPath.getPathId(),
\r
2345 sortPhysicalLinksOfPhysicalPath(physicalPath));
\r
2353 protected PhysicalLink getPhysicalLink(PhysicalLinkId physicalLinkId) {
\r
2354 return physicalLinkMap.get(physicalLinkId);
\r
2357 protected PhysicalPath getPhysicalPath(PhysicalPathId physicalPathId) {
\r
2358 return physicalPathMap.get(physicalPathId);
\r
2361 protected PhysicalPort getPhysicalPort(PhysicalNodeId physicalNodeId, PhysicalPortId physicalPortId) {
\r
2362 return physicalPortMap.get(physicalNodeId).get(physicalPortId);
\r
2365 protected PhysicalLink getFirstPhysicalLinkOfPhysicalPath(PhysicalPath physicalPath) {
\r
2366 // for ( org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.path.instance.PhysicalLink
\r
2367 // physicalLink : physicalPath.getPhysicalLink() ) {
\r
2368 // if ( 0 == physicalLink.getOrder() ) {
\r
2369 // return physicalLinkMap.get(physicalLink.getLinkId());
\r
2375 if ( physicalPath.getPhysicalLink().isEmpty() ) {
\r
2379 PhysicalLinkId physicalLinkId = physicalPath.getPhysicalLink().get(0).getLinkId();
\r
2381 return physicalLinkMap.get(physicalLinkId);
\r
2384 protected PhysicalLink getLastPhysicalLinkOfPhysicalPath(PhysicalPath physicalPath) {
\r
2385 // long order = physicalPath.getPhysicalLink().size() - 1;
\r
2387 // for ( org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.path.instance.PhysicalLink
\r
2388 // physicalLink : physicalPath.getPhysicalLink() ) {
\r
2389 // if ( physicalLink.getOrder() == order ) {
\r
2390 // return physicalLinkMap.get(physicalLink.getLinkId());
\r
2396 if ( physicalPath.getPhysicalLink().isEmpty() ) {
\r
2400 PhysicalLinkId physicalLinkId = physicalPath.getPhysicalLink()
\r
2401 .get(physicalPath.getPhysicalLink().size() - 1).getLinkId();
\r
2403 return physicalLinkMap.get(physicalLinkId);
\r
2406 private PhysicalPath sortPhysicalLinksOfPhysicalPath(PhysicalPath physicalPath) {
\r
2407 if ( physicalPath.getPhysicalLink().isEmpty()
\r
2408 || 1 == physicalPath.getPhysicalLink().size() ) {
\r
2409 return physicalPath;
\r
2412 List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.path.instance.PhysicalLink> sortedPhysicalLinks =
\r
2413 new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.path.instance.PhysicalLink>(physicalPath.getPhysicalLink().size());
\r
2414 sortedPhysicalLinks.addAll(physicalPath.getPhysicalLink());
\r
2416 for ( org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.path.instance.PhysicalLink
\r
2417 physicalLink : physicalPath.getPhysicalLink() ) {
\r
2418 sortedPhysicalLinks.set(physicalLink.getOrder().intValue(), physicalLink);
\r
2421 PhysicalPath physicalPath1 = new PhysicalPathBuilder(physicalPath)
\r
2422 .setPhysicalLink(sortedPhysicalLinks)
\r
2425 return physicalPath1;
\r
2432 * @author Zhigang Ji
\r
2434 private class VirtualNetworkHelper {
\r
2435 private Map<VirtualNodeId, VirtualNode> virtualNodeMap;
\r
2436 private Map<VirtualLinkId, VirtualLink> virtualLinkMap;
\r
2437 private Map<VirtualPathId, VirtualPath> virtualPathMap;
\r
2438 private Map<VirtualNodeId, VirtualNode> virtualRouterMap;
\r
2439 private Map<VirtualNodeId, Map<VirtualPortId, VirtualPort>> virtualPortMap;
\r
2440 private Map<VirtualNodeId, VirtualPort> layer2ExternalVirtualPortMap;
\r
2441 private Map<VirtualNodeId, VirtualPort> layer3ExternalVirtualPortMap;
\r
2442 private Map<VirtualNodeId, Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>>> virtualSwitchConnectedInternalVirtualPortMap;
\r
2443 private Map<VirtualNodeId, Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>>> virtualRouterConnectedInternalVirtualPortMap;
\r
2444 private Map<VirtualArpKey, VirtualArp> virtualArpMap;
\r
2445 private Map<MacAddress, VirtualArp> macAddressKeyVirtualArpMap;
\r
2447 public VirtualNetworkHelper(VirtualNetwork virtualNetwork) {
\r
2448 virtualNodeMap = new HashMap<VirtualNodeId, VirtualNode>();
\r
2449 virtualLinkMap = new HashMap<VirtualLinkId, VirtualLink>();
\r
2450 virtualPathMap = new HashMap<VirtualPathId, VirtualPath>();
\r
2451 virtualRouterMap = new HashMap<VirtualNodeId, VirtualNode>();
\r
2452 virtualPortMap = new HashMap<VirtualNodeId, Map<VirtualPortId, VirtualPort>>();
\r
2453 layer2ExternalVirtualPortMap = new HashMap<VirtualNodeId, VirtualPort>();
\r
2454 layer3ExternalVirtualPortMap = new HashMap<VirtualNodeId, VirtualPort>();
\r
2455 virtualSwitchConnectedInternalVirtualPortMap =
\r
2456 new HashMap<VirtualNodeId, Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>>>();
\r
2457 virtualRouterConnectedInternalVirtualPortMap =
\r
2458 new HashMap<VirtualNodeId, Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>>>();
\r
2459 virtualArpMap = new HashMap<VirtualArpKey, VirtualArp>();
\r
2460 macAddressKeyVirtualArpMap = new HashMap<MacAddress, VirtualArp>();
\r
2462 List<VirtualNode> virtualNodes = virtualNetwork.getVirtualNodes().getVirtualNode();
\r
2463 Map<VirtualPortId, VirtualPort> virtualPorts;
\r
2465 for ( VirtualNode virtualNode : virtualNodes ) {
\r
2466 virtualNodeMap.put(virtualNode.getNodeId(), virtualNode);
\r
2468 if ( VirtualNode.NodeType.Vrouter == virtualNode.getNodeType() ) {
\r
2469 virtualRouterMap.put(virtualNode.getNodeId(), virtualNode);
\r
2472 virtualPorts = new HashMap<VirtualPortId, VirtualPort>();
\r
2473 virtualPortMap.put(virtualNode.getNodeId(), virtualPorts);
\r
2475 for ( VirtualPort virtualPort : virtualNode.getVirtualPort() ) {
\r
2476 virtualPorts.put(virtualPort.getPortId(), virtualPort);
\r
2478 if ( VirtualPort.PortType.External == virtualPort.getPortType() ) {
\r
2479 if ( null == virtualPort.getExternalMacAddresses() ) {
\r
2480 layer3ExternalVirtualPortMap.put(virtualNode.getNodeId(), virtualPort);
\r
2482 layer2ExternalVirtualPortMap.put(virtualNode.getNodeId(), virtualPort);
\r
2488 List<VirtualLink> virtualLinks = virtualNetwork.getVirtualLinks().getVirtualLink();
\r
2489 Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>> virtualSwitchConnectedInternalVirtualPorts;
\r
2490 Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>> virtualRouterConnectedInternalVirtualPorts;
\r
2491 VirtualNode virtualNode;
\r
2492 VirtualPort virtualPort;
\r
2494 for ( VirtualLink virtualLink : virtualLinks ) {
\r
2495 virtualLinkMap.put(virtualLink.getLinkId(), virtualLink);
\r
2497 virtualNode = virtualNodeMap.get(virtualLink.getDestNodeId());
\r
2498 virtualPort = virtualPortMap.get(virtualLink.getSrcNodeId()).get(virtualLink.getSrcPortId());
\r
2500 if ( VirtualNode.NodeType.Vswitch == virtualNode.getNodeType() ) {
\r
2501 virtualSwitchConnectedInternalVirtualPorts =
\r
2502 virtualSwitchConnectedInternalVirtualPortMap.get(virtualLink.getSrcNodeId());
\r
2504 if ( null == virtualSwitchConnectedInternalVirtualPorts ) {
\r
2505 virtualSwitchConnectedInternalVirtualPorts =
\r
2506 new HashMap<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>>();
\r
2507 virtualSwitchConnectedInternalVirtualPortMap.put(
\r
2508 virtualLink.getSrcNodeId(), virtualSwitchConnectedInternalVirtualPorts);
\r
2511 virtualSwitchConnectedInternalVirtualPorts.put(virtualLink.getDestNodeId(),
\r
2512 new AbstractMap.SimpleEntry<VirtualPort, VirtualLink>(virtualPort, virtualLink));
\r
2513 } else if ( VirtualNode.NodeType.Vrouter == virtualNode.getNodeType() ) {
\r
2514 virtualRouterConnectedInternalVirtualPorts =
\r
2515 virtualRouterConnectedInternalVirtualPortMap.get(virtualLink.getSrcNodeId());
\r
2517 if ( null == virtualRouterConnectedInternalVirtualPorts ) {
\r
2518 virtualRouterConnectedInternalVirtualPorts =
\r
2519 new HashMap<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>>();
\r
2520 virtualRouterConnectedInternalVirtualPortMap.put(
\r
2521 virtualLink.getSrcNodeId(), virtualRouterConnectedInternalVirtualPorts);
\r
2524 virtualRouterConnectedInternalVirtualPorts.put(virtualLink.getDestNodeId(),
\r
2525 new AbstractMap.SimpleEntry<VirtualPort, VirtualLink>(virtualPort, virtualLink));
\r
2529 List<VirtualPath> virtualPaths = virtualNetwork.getVirtualPaths().getVirtualPath();
\r
2531 for ( VirtualPath virtualPath : virtualPaths ) {
\r
2532 virtualPathMap.put(virtualPath.getPathId(), virtualPath);
\r
2535 List<VirtualArp> virtualArps = virtualNetwork.getVirtualArps().getVirtualArp();
\r
2537 for ( VirtualArp virtualArp : virtualArps ) {
\r
2538 virtualArpMap.put(virtualArp.getKey(), virtualArp);
\r
2539 macAddressKeyVirtualArpMap.put(virtualArp.getMacAddress(), virtualArp);
\r
2545 protected VirtualLink getVirtualLink(VirtualLinkId virtualLinkId) {
\r
2546 return virtualLinkMap.get(virtualLinkId);
\r
2549 protected VirtualPath getVirtualPath(VirtualPathId virtualPathId) {
\r
2550 return virtualPathMap.get(virtualPathId);
\r
2553 protected Map<VirtualNodeId, VirtualNode> getVirtualRouters() {
\r
2554 return virtualRouterMap;
\r
2557 protected VirtualPort getLayer2ExternalVirtualPort(VirtualNodeId virtualNodeId) {
\r
2558 return layer2ExternalVirtualPortMap.get(virtualNodeId);
\r
2561 protected VirtualPort getLayer3ExternalVirtualPort(VirtualNodeId virtualNodeId) {
\r
2562 return layer3ExternalVirtualPortMap.get(virtualNodeId);
\r
2565 protected Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>> getConnectedVirtualSwitches(
\r
2566 VirtualNodeId virtualNodeId) {
\r
2567 return virtualSwitchConnectedInternalVirtualPortMap.get(virtualNodeId);
\r
2570 protected Map<VirtualNodeId, Map.Entry<VirtualPort, VirtualLink>> getConnectedVirtualRouters(
\r
2571 VirtualNodeId virtualNodeId) {
\r
2572 return virtualRouterConnectedInternalVirtualPortMap.get(virtualNodeId);
\r
2575 protected VirtualArp getVirtualArp(MacAddress macAddress) {
\r
2576 return macAddressKeyVirtualArpMap.get(macAddress);
\r
Code Review / nemo.git / blob