Gitiles
Code Review Sign In
gerrit.onosproject.org / onos / 724037b5fd769c53d69bf0039d6c0bcb18e480e6 / . / apps / t3 / app / src / test / java / org / onosproject / t3 / impl / T3TestObjects.java
blob: 2ec39b45de696dfe5446f06c5c31679c645dd7cf [file] [log] [blame]
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]1/*
2 * Copyright 2018-present Open Networking Foundation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package org.onosproject.t3.impl;
17
18import com.google.common.collect.ImmutableList;
19import com.google.common.collect.ImmutableSet;
20import org.onlab.packet.EthType;
21import org.onlab.packet.IpAddress;
22import org.onlab.packet.IpPrefix;
23import org.onlab.packet.MacAddress;
Andrea Campanella09ca07a2018-01-25 16:44:04 +0100[diff] [blame]24import org.onlab.packet.MplsLabel;
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]25import org.onlab.packet.VlanId;
26import org.onosproject.core.DefaultApplicationId;
27import org.onosproject.core.GroupId;
28import org.onosproject.net.ConnectPoint;
Andrea Campanella490ec3a2018-03-01 16:22:21 +0100[diff] [blame]29import org.onosproject.net.DefaultAnnotations;
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]30import org.onosproject.net.DefaultHost;
31import org.onosproject.net.DeviceId;
32import org.onosproject.net.Host;
33import org.onosproject.net.HostId;
34import org.onosproject.net.HostLocation;
35import org.onosproject.net.PortNumber;
36import org.onosproject.net.flow.DefaultFlowEntry;
37import org.onosproject.net.flow.DefaultTrafficSelector;
38import org.onosproject.net.flow.DefaultTrafficTreatment;
39import org.onosproject.net.flow.FlowEntry;
40import org.onosproject.net.flow.FlowRule;
41import org.onosproject.net.flow.TrafficSelector;
42import org.onosproject.net.flow.TrafficTreatment;
43import org.onosproject.net.group.DefaultGroup;
44import org.onosproject.net.group.DefaultGroupBucket;
45import org.onosproject.net.group.Group;
46import org.onosproject.net.group.GroupBucket;
47import org.onosproject.net.group.GroupBuckets;
48import org.onosproject.net.provider.ProviderId;
49
50/**
51 * Helper class for objects related to the Troubleshoot Manager Test.
52 */
53final class T3TestObjects {
54
Andrea Campanella7c8e7912018-01-23 12:46:04 +0100[diff] [blame]55 private T3TestObjects() {
Andrea Campanella2bc55dd2018-01-18 16:54:34 +0100[diff] [blame]56 //banning construction
57 }
58
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]59 private static final String HOST_ONE_MAC = "00:00:00:00:00:01";
60 private static final String HOST_TWO_MAC = "00:00:00:00:00:02";
61 private static final String HOST_ONE_VLAN = "None";
62 private static final String HOST_TWO_VLAN = "None";
63 private static final String HOST_ONE = HOST_ONE_MAC + "/" + HOST_ONE_VLAN;
64 private static final String HOST_TWO = HOST_TWO_MAC + "/" + HOST_TWO_VLAN;
Andrea Campanella490ec3a2018-03-01 16:22:21 +0100[diff] [blame]65 private static final String HOST_DUAL_HOMED_MAC = "00:00:00:00:00:03";
66 private static final String HOST_DUAL_HOMED_VLAN = "None";
67 private static final String HOST_DUAL_HOMED = HOST_DUAL_HOMED_MAC + "/" + HOST_DUAL_HOMED_VLAN;
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]68
Andrea Campanella37d10622018-01-18 17:11:42 +0100[diff] [blame]69 //offline device
70 static final DeviceId OFFLINE_DEVICE = DeviceId.deviceId("offlineDevice");
71
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]72 //Single Flow Test
73 static final DeviceId SINGLE_FLOW_DEVICE = DeviceId.deviceId("SingleFlowDevice");
74 private static final TrafficSelector SINGLE_FLOW_SELECTOR = DefaultTrafficSelector.builder()
75 .matchInPort(PortNumber.portNumber(1))
76 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
77 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
78 .build();
79
80 private static final TrafficTreatment OUTPUT_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
81 .setOutput(PortNumber.portNumber(2)).build();
82 private static final FlowRule SINGLE_FLOW = DefaultFlowEntry.builder().forDevice(SINGLE_FLOW_DEVICE)
83 .forTable(0)
84 .withPriority(100)
85 .withSelector(SINGLE_FLOW_SELECTOR)
86 .withTreatment(OUTPUT_FLOW_TREATMENT)
87 .fromApp(new DefaultApplicationId(0, "TestApp"))
88 .makePermanent()
89 .build();
90 static final FlowEntry SINGLE_FLOW_ENTRY = new DefaultFlowEntry(SINGLE_FLOW);
91
92 static final ConnectPoint SINGLE_FLOW_IN_CP = ConnectPoint.deviceConnectPoint(SINGLE_FLOW_DEVICE + "/" + 1);
93
94 static final ConnectPoint SINGLE_FLOW_OUT_CP = ConnectPoint.deviceConnectPoint(SINGLE_FLOW_DEVICE + "/" + 2);
95
Andrea Campanellabb9d3fb2018-01-22 15:10:30 +0100[diff] [blame]96 //same output as input
97 static final DeviceId SAME_OUTPUT_FLOW_DEVICE = DeviceId.deviceId("sameOutputDevice");
98
99 private static final TrafficTreatment SAME_OUTPUT_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
100 .setOutput(PortNumber.portNumber(1)).build();
101 private static final FlowRule SAME_OUTPUT_FLOW = DefaultFlowEntry.builder().forDevice(SAME_OUTPUT_FLOW_DEVICE)
102 .forTable(0)
103 .withPriority(100)
104 .withSelector(SINGLE_FLOW_SELECTOR)
105 .withTreatment(SAME_OUTPUT_FLOW_TREATMENT)
106 .fromApp(new DefaultApplicationId(0, "TestApp"))
107 .makePermanent()
108 .build();
109 static final FlowEntry SAME_OUTPUT_FLOW_ENTRY = new DefaultFlowEntry(SAME_OUTPUT_FLOW);
110
111 static final ConnectPoint SAME_OUTPUT_FLOW_CP = ConnectPoint.deviceConnectPoint(SAME_OUTPUT_FLOW_DEVICE + "/" + 1);
112
Andrea Campanella7c8e7912018-01-23 12:46:04 +0100[diff] [blame]113 //ARP
114 static final DeviceId ARP_FLOW_DEVICE = DeviceId.deviceId("ArpDevice");
115
116 private static final TrafficSelector ARP_FLOW_SELECTOR = DefaultTrafficSelector.builder()
117 .matchInPort(PortNumber.portNumber(1))
118 .matchEthType(EthType.EtherType.ARP.ethType().toShort())
119 .build();
120
121 private static final TrafficTreatment ARP_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
122 .setOutput(PortNumber.CONTROLLER).build();
123 private static final FlowRule ARP_FLOW = DefaultFlowEntry.builder().forDevice(ARP_FLOW_DEVICE)
124 .forTable(0)
125 .withPriority(100)
126 .withSelector(ARP_FLOW_SELECTOR)
127 .withTreatment(ARP_FLOW_TREATMENT)
128 .fromApp(new DefaultApplicationId(0, "TestApp"))
129 .makePermanent()
130 .build();
131 static final FlowEntry ARP_FLOW_ENTRY = new DefaultFlowEntry(ARP_FLOW);
132
133 static final ConnectPoint ARP_FLOW_CP = ConnectPoint.deviceConnectPoint(ARP_FLOW_DEVICE + "/" + 1);
134
Andrea Campanellabb9d3fb2018-01-22 15:10:30 +0100[diff] [blame]135
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]136 //Dual Flow Test
137 static final DeviceId DUAL_FLOW_DEVICE = DeviceId.deviceId("DualFlowDevice");
138 private static final TrafficTreatment TRANSITION_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
139 .setVlanId(VlanId.vlanId((short) 100))
140 .transition(10)
141 .build();
142 private static final TrafficSelector VLAN_FLOW_SELECTOR = DefaultTrafficSelector.builder()
143 .matchVlanId(VlanId.vlanId((short) 100))
144 .build();
145 private static final FlowRule FIRST_FLOW = DefaultFlowEntry.builder().forDevice(DUAL_FLOW_DEVICE)
146 .forTable(0)
147 .withPriority(100)
148 .withSelector(SINGLE_FLOW_SELECTOR)
149 .withTreatment(TRANSITION_FLOW_TREATMENT)
150 .fromApp(new DefaultApplicationId(0, "TestApp"))
151 .makePermanent()
152 .build();
153 static final FlowEntry FIRST_FLOW_ENTRY = new DefaultFlowEntry(FIRST_FLOW);
154 private static final FlowRule SECOND_FLOW = DefaultFlowEntry.builder().forDevice(DUAL_FLOW_DEVICE)
155 .forTable(10)
156 .withPriority(100)
157 .withSelector(VLAN_FLOW_SELECTOR)
158 .withTreatment(OUTPUT_FLOW_TREATMENT)
159 .fromApp(new DefaultApplicationId(0, "TestApp"))
160 .makePermanent()
161 .build();
162 static final FlowEntry SECOND_FLOW_ENTRY = new DefaultFlowEntry(SECOND_FLOW);
163
164 static final ConnectPoint DUAL_FLOW_IN_CP = ConnectPoint.deviceConnectPoint(DUAL_FLOW_DEVICE + "/" + 1);
165
166 static final ConnectPoint DUAL_FLOW_OUT_CP = ConnectPoint.deviceConnectPoint(DUAL_FLOW_DEVICE + "/" + 2);
167
168 //Flow and Group Test
169 static final DeviceId GROUP_FLOW_DEVICE = DeviceId.deviceId("GroupFlowDevice");
170
171 private static final GroupId GROUP_ID = GroupId.valueOf(1);
172
173 private static final TrafficTreatment GROUP_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
Andrea Campanella09ca07a2018-01-25 16:44:04 +0100[diff] [blame]174 .pushMpls()
175 .setMpls(MplsLabel.mplsLabel(100))
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]176 .group(GROUP_ID)
177 .build();
178 private static final FlowRule GROUP_FLOW = DefaultFlowEntry.builder().forDevice(GROUP_FLOW_DEVICE)
179 .forTable(0)
180 .withPriority(100)
181 .withSelector(SINGLE_FLOW_SELECTOR)
182 .withTreatment(GROUP_FLOW_TREATMENT)
183 .fromApp(new DefaultApplicationId(0, "TestApp"))
184 .makePermanent()
185 .build();
186 static final FlowEntry GROUP_FLOW_ENTRY = new DefaultFlowEntry(GROUP_FLOW);
187
Andrea Campanella09ca07a2018-01-25 16:44:04 +0100[diff] [blame]188 private static final TrafficTreatment OUTPUT_GROUP_TREATMENT = DefaultTrafficTreatment.builder()
189 .popMpls(EthType.EtherType.IPV4.ethType())
190 .setOutput(PortNumber.portNumber(2)).build();
191
192 private static final GroupBucket BUCKET = DefaultGroupBucket.createSelectGroupBucket(OUTPUT_GROUP_TREATMENT);
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]193
194 private static final GroupBuckets BUCKETS = new GroupBuckets(ImmutableList.of(BUCKET));
195
196 static final Group GROUP = new DefaultGroup(GROUP_ID, GROUP_FLOW_DEVICE, Group.Type.SELECT, BUCKETS);
197
198 static final ConnectPoint GROUP_FLOW_IN_CP = ConnectPoint.deviceConnectPoint(GROUP_FLOW_DEVICE + "/" + 1);
199
200 static final ConnectPoint GROUP_FLOW_OUT_CP = ConnectPoint.deviceConnectPoint(GROUP_FLOW_DEVICE + "/" + 2);
201
Seyeon Jeong525b68a2020-04-07 12:06:18 -0700[diff] [blame]202 // Group multiple action order test
203 static final DeviceId ACTION_ORDER_DEVICE = DeviceId.deviceId("ActionOrderDevice");
204 private static final VlanId ACTION_ORDER_VLAN_ID = VlanId.vlanId("999");
205 static final MplsLabel ACTION_ORDER_MPLS_LABEL = MplsLabel.mplsLabel("999");
206 private static final TrafficTreatment ACTION_ORDER_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
207 .pushVlan()
208 .setVlanId(ACTION_ORDER_VLAN_ID)
209 .group(GROUP_ID)
210 .build();
211 private static final FlowRule ACTION_ORDER_FLOW = DefaultFlowEntry.builder().forDevice(ACTION_ORDER_DEVICE)
212 .forTable(0)
213 .withPriority(100)
214 .withSelector(SINGLE_FLOW_SELECTOR)
215 .withTreatment(ACTION_ORDER_FLOW_TREATMENT)
216 .fromApp(new DefaultApplicationId(0, "TestApp"))
217 .makePermanent()
218 .build();
219 static final FlowEntry ACTION_ORDER_FLOW_ENTRY = new DefaultFlowEntry(ACTION_ORDER_FLOW);
220 private static final TrafficTreatment ACTION_ORDER_GROUP_TREATMENT = DefaultTrafficTreatment.builder()
221 // make lower order actions come first
222 .setOutput(PortNumber.portNumber(2))
223 .setMpls(ACTION_ORDER_MPLS_LABEL)
224 .pushMpls()
225 .popVlan()
226 .build();
227 private static final GroupBucket ACTION_ORDER_BUCKET = DefaultGroupBucket
228 .createSelectGroupBucket(ACTION_ORDER_GROUP_TREATMENT);
229 private static final GroupBuckets ACTION_ORDER_BUCKETS = new GroupBuckets(ImmutableList.of(ACTION_ORDER_BUCKET));
230 static final Group ACTION_ORDER_GROUP = new DefaultGroup(
231 GROUP_ID, ACTION_ORDER_DEVICE, Group.Type.SELECT, ACTION_ORDER_BUCKETS);
232 static final ConnectPoint ACTION_ORDER_IN_CP = ConnectPoint.deviceConnectPoint(ACTION_ORDER_DEVICE + "/" + 1);
233 static final ConnectPoint ACTION_ORDER_OUT_CP = ConnectPoint.deviceConnectPoint(ACTION_ORDER_DEVICE + "/" + 2);
234
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]235 //topology
236
237 static final DeviceId TOPO_FLOW_DEVICE = DeviceId.deviceId("SingleFlowDevice1");
238
239 static final DeviceId TOPO_FLOW_2_DEVICE = DeviceId.deviceId("SingleFlowDevice2");
240
241 static final DeviceId TOPO_FLOW_3_DEVICE = DeviceId.deviceId("SingleFlowDevice3");
242
243 private static final TrafficSelector TOPO_FLOW_SELECTOR = DefaultTrafficSelector.builder()
244 .matchInPort(PortNumber.portNumber(1))
245 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
246 .matchIPDst(IpPrefix.valueOf("127.0.0.3/32"))
247 .build();
248
249 private static final FlowRule TOPO_SINGLE_FLOW = DefaultFlowEntry.builder().forDevice(TOPO_FLOW_DEVICE)
250 .forTable(0)
251 .withPriority(100)
252 .withSelector(TOPO_FLOW_SELECTOR)
253 .withTreatment(OUTPUT_FLOW_TREATMENT)
254 .fromApp(new DefaultApplicationId(0, "TestApp"))
255 .makePermanent()
256 .build();
257
258 static final FlowEntry TOPO_SINGLE_FLOW_ENTRY = new DefaultFlowEntry(TOPO_SINGLE_FLOW);
259
260 static final ConnectPoint TOPO_FLOW_1_IN_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_DEVICE + "/" + 1);
261
262 static final ConnectPoint TOPO_FLOW_1_OUT_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_DEVICE + "/" + 2);
263
264 static final ConnectPoint TOPO_FLOW_2_IN_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_2_DEVICE + "/" + 1);
265
266 static final ConnectPoint TOPO_FLOW_2_OUT_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_2_DEVICE + "/" + 2);
267
268 static final ConnectPoint TOPO_FLOW_3_IN_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_3_DEVICE + "/" + 1);
269
270 static final ConnectPoint TOPO_FLOW_3_OUT_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_3_DEVICE + "/" + 2);
271
272
273 //Topology with Groups
274
275 static final DeviceId TOPO_GROUP_FLOW_DEVICE = DeviceId.deviceId("TopoGroupFlowDevice");
276
277 private static final TrafficSelector TOPO_SECOND_INPUT_FLOW_SELECTOR = DefaultTrafficSelector.builder()
278 .matchInPort(PortNumber.portNumber(3))
279 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
280 .matchIPDst(IpPrefix.valueOf("127.0.0.3/32"))
281 .build();
282
283 private static final FlowRule TOPO_SECOND_INPUT_FLOW = DefaultFlowEntry.builder().forDevice(TOPO_FLOW_3_DEVICE)
284 .forTable(0)
285 .withPriority(100)
286 .withSelector(TOPO_SECOND_INPUT_FLOW_SELECTOR)
287 .withTreatment(OUTPUT_FLOW_TREATMENT)
288 .fromApp(new DefaultApplicationId(0, "TestApp"))
289 .makePermanent()
290 .build();
291
292 private static final TrafficTreatment OUTPUT_2_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
293 .setOutput(PortNumber.portNumber(3)).build();
294
295
296 private static final GroupId TOPO_GROUP_ID = GroupId.valueOf(1);
297
298 private static final TrafficTreatment TOPO_GROUP_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
299 .group(TOPO_GROUP_ID)
300 .build();
301 private static final FlowRule TOPO_GROUP_FLOW = DefaultFlowEntry.builder().forDevice(TOPO_GROUP_FLOW_DEVICE)
302 .forTable(0)
303 .withPriority(100)
304 .withSelector(TOPO_FLOW_SELECTOR)
305 .withTreatment(TOPO_GROUP_FLOW_TREATMENT)
306 .fromApp(new DefaultApplicationId(0, "TestApp"))
307 .makePermanent()
308 .build();
309 static final FlowEntry TOPO_GROUP_FLOW_ENTRY = new DefaultFlowEntry(TOPO_GROUP_FLOW);
310
311 private static final GroupBucket BUCKET_2 = DefaultGroupBucket.createSelectGroupBucket(OUTPUT_2_FLOW_TREATMENT);
312
313 private static final GroupBuckets BUCKETS_MULTIPLE = new GroupBuckets(ImmutableList.of(BUCKET, BUCKET_2));
314
Andrea Campanella2bc55dd2018-01-18 16:54:34 +0100[diff] [blame]315 static final Group TOPO_GROUP = new DefaultGroup(TOPO_GROUP_ID, TOPO_GROUP_FLOW_DEVICE,
316 Group.Type.SELECT, BUCKETS_MULTIPLE);
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]317
318 static final FlowEntry TOPO_SECOND_INPUT_FLOW_ENTRY = new DefaultFlowEntry(TOPO_SECOND_INPUT_FLOW);
319
320 static final DeviceId TOPO_FLOW_4_DEVICE = DeviceId.deviceId("SingleFlowDevice4");
321
322 static final ConnectPoint TOPO_FLOW_IN_CP = ConnectPoint.deviceConnectPoint(TOPO_GROUP_FLOW_DEVICE + "/" + 1);
323
324 static final ConnectPoint TOPO_FLOW_OUT_CP_1 = ConnectPoint.deviceConnectPoint(TOPO_GROUP_FLOW_DEVICE + "/" + 2);
325
Andrea Campanella2bc55dd2018-01-18 16:54:34 +0100[diff] [blame]326 protected static final ConnectPoint TOPO_FLOW_OUT_CP_2 =
327 ConnectPoint.deviceConnectPoint(TOPO_GROUP_FLOW_DEVICE + "/" + 3);
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]328
329 static final ConnectPoint TOPO_FLOW_4_IN_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_4_DEVICE + "/" + 1);
330
331 static final ConnectPoint TOPO_FLOW_3_IN_2_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_3_DEVICE + "/" + 3);
332
333 static final ConnectPoint TOPO_FLOW_4_OUT_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_4_DEVICE + "/" + 2);
334
335
336 //hardware
337
338 static final DeviceId HARDWARE_DEVICE = DeviceId.deviceId("HardwareDevice");
339
340 static final ConnectPoint HARDWARE_DEVICE_IN_CP = ConnectPoint.deviceConnectPoint(HARDWARE_DEVICE + "/" + 1);
341
342 static final ConnectPoint HARDWARE_DEVICE_OUT_CP = ConnectPoint.deviceConnectPoint(HARDWARE_DEVICE + "/" + 2);
343
344 private static final TrafficSelector HARDWARE_FLOW_SELECTOR = DefaultTrafficSelector.builder()
345 .matchInPort(PortNumber.portNumber(1))
346 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
347 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
348 .build();
349
350 private static final TrafficTreatment HW_TRANSITION_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
351 .pushMpls()
352 .transition(27)
353 .build();
354
355 private static final FlowRule HARDWARE_FLOW = DefaultFlowEntry.builder().forDevice(TOPO_FLOW_3_DEVICE)
356 .forTable(0)
357 .withPriority(100)
358 .withSelector(HARDWARE_FLOW_SELECTOR)
359 .withTreatment(HW_TRANSITION_FLOW_TREATMENT)
360 .fromApp(new DefaultApplicationId(0, "TestApp"))
361 .makePermanent()
362 .build();
363
364 static final FlowEntry HARDWARE_FLOW_ENTRY = new DefaultFlowEntry(HARDWARE_FLOW);
365
366 private static final TrafficSelector HARDWARE_ETH_FLOW_SELECTOR = DefaultTrafficSelector.builder()
367 .matchInPort(PortNumber.portNumber(1))
368 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
369 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
370 .matchEthType(EthType.EtherType.IPV4.ethType().toShort())
371 .build();
372
373 private static final FlowRule HARDWARE_ETH_FLOW = DefaultFlowEntry.builder().forDevice(TOPO_FLOW_3_DEVICE)
374 .forTable(30)
375 .withPriority(100)
376 .withSelector(HARDWARE_ETH_FLOW_SELECTOR)
377 .withTreatment(OUTPUT_FLOW_TREATMENT)
378 .fromApp(new DefaultApplicationId(0, "TestApp"))
379 .makePermanent()
380 .build();
381
382 static final FlowEntry HARDWARE_ETH_FLOW_ENTRY = new DefaultFlowEntry(HARDWARE_ETH_FLOW);
383
Andrea Campanella97f9d4c2018-02-06 18:58:40 +0100[diff] [blame]384 //HW Double Rule on 10
385
386 static final DeviceId HARDWARE_DEVICE_10 = DeviceId.deviceId("HardwareDevice10");
387
388 static final ConnectPoint HARDWARE_DEVICE_10_IN_CP = ConnectPoint.deviceConnectPoint(HARDWARE_DEVICE_10 + "/" + 1);
389
390 static final ConnectPoint HARDWARE_DEVICE_10_OUT_CP = ConnectPoint.deviceConnectPoint(HARDWARE_DEVICE_10 + "/" + 2);
391
392 private static final TrafficSelector HARDWARE_10_FLOW_SELECTOR = DefaultTrafficSelector.builder()
393 .matchInPort(PortNumber.portNumber(1))
394 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
395 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
396 .matchVlanId(VlanId.NONE)
397 .build();
398
399 private static final TrafficTreatment HARDWARE_10_TRANSITION_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
400 .setVlanId(VlanId.vlanId("10"))
401 .transition(20)
402 .build();
403
404 private static final FlowRule HARDWARE_DEVICE_10_FLOW = DefaultFlowEntry.builder().forDevice(HARDWARE_DEVICE_10)
405 .forTable(10)
406 .withPriority(100)
407 .withSelector(HARDWARE_10_FLOW_SELECTOR)
408 .withTreatment(HARDWARE_10_TRANSITION_FLOW_TREATMENT)
409 .fromApp(new DefaultApplicationId(0, "TestApp"))
410 .makePermanent()
411 .build();
412
413 static final FlowEntry HARDWARE_10_FLOW_ENTRY = new DefaultFlowEntry(HARDWARE_DEVICE_10_FLOW);
414
415 private static final TrafficSelector HARDWARE_10_SECOND_SELECTOR = DefaultTrafficSelector.builder()
416 .matchInPort(PortNumber.portNumber(1))
417 .matchVlanId(VlanId.vlanId("10"))
418 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
419 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
420 .matchEthType(EthType.EtherType.IPV4.ethType().toShort())
421 .build();
422
423 private static final FlowRule HARDWARE_10_SECOND_FLOW = DefaultFlowEntry.builder().forDevice(HARDWARE_DEVICE_10)
424 .forTable(10)
425 .withPriority(100)
426 .withSelector(HARDWARE_10_SECOND_SELECTOR)
427 .withTreatment(HARDWARE_10_TRANSITION_FLOW_TREATMENT)
428 .fromApp(new DefaultApplicationId(0, "TestApp"))
429 .makePermanent()
430 .build();
431
432 static final FlowEntry HARDWARE_10_SECOND_FLOW_ENTRY = new DefaultFlowEntry(HARDWARE_10_SECOND_FLOW);
433
434 private static final FlowRule HARDWARE_10_OUTPUT_FLOW = DefaultFlowEntry.builder().forDevice(HARDWARE_DEVICE_10)
435 .forTable(20)
436 .withPriority(100)
437 .withSelector(SINGLE_FLOW_SELECTOR)
438 .withTreatment(OUTPUT_FLOW_TREATMENT)
439 .fromApp(new DefaultApplicationId(0, "TestApp"))
440 .makePermanent()
441 .build();
442
443 static final FlowEntry HARDWARE_10_OUTPUT_FLOW_ENTRY = new DefaultFlowEntry(HARDWARE_10_OUTPUT_FLOW);
444
Andrea Campanellae04aac92018-01-31 14:59:03 +0100[diff] [blame]445 //Dual Links
446 // - (1) Device 1 (2-3) - (1-4) Device 2 (2-3) - (1-2) Device 3 (3) -
447 static final DeviceId DUAL_LINK_1 = DeviceId.deviceId("DualLink1");
448 static final DeviceId DUAL_LINK_2 = DeviceId.deviceId("DualLink2");
449 static final DeviceId DUAL_LINK_3 = DeviceId.deviceId("DualLink3");
450
451 static final ConnectPoint DUAL_LINK_1_CP_1_IN = ConnectPoint.deviceConnectPoint(DUAL_LINK_1 + "/" + 1);
452 static final ConnectPoint DUAL_LINK_1_CP_2_OUT = ConnectPoint.deviceConnectPoint(DUAL_LINK_1 + "/" + 2);
453 static final ConnectPoint DUAL_LINK_1_CP_3_OUT = ConnectPoint.deviceConnectPoint(DUAL_LINK_1 + "/" + 3);
454 static final ConnectPoint DUAL_LINK_2_CP_1_IN = ConnectPoint.deviceConnectPoint(DUAL_LINK_2 + "/" + 1);
455 static final ConnectPoint DUAL_LINK_2_CP_4_IN = ConnectPoint.deviceConnectPoint(DUAL_LINK_2 + "/" + 4);
456 static final ConnectPoint DUAL_LINK_2_CP_2_OUT = ConnectPoint.deviceConnectPoint(DUAL_LINK_2 + "/" + 2);
457 static final ConnectPoint DUAL_LINK_2_CP_3_OUT = ConnectPoint.deviceConnectPoint(DUAL_LINK_2 + "/" + 3);
458 static final ConnectPoint DUAL_LINK_3_CP_1_IN = ConnectPoint.deviceConnectPoint(DUAL_LINK_3 + "/" + 1);
459 static final ConnectPoint DUAL_LINK_3_CP_2_IN = ConnectPoint.deviceConnectPoint(DUAL_LINK_3 + "/" + 2);
460 static final ConnectPoint DUAL_LINK_3_CP_3_OUT = ConnectPoint.deviceConnectPoint(DUAL_LINK_3 + "/" + 3);
461
462 //match on port 1 and point to group for device 1 and 2
463 private static final TrafficTreatment DUAL_LINK_1_GROUP_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
464 .pushMpls()
465 .setMpls(MplsLabel.mplsLabel(100))
466 .group(GROUP_ID)
467 .build();
468 private static final FlowRule DUAL_LINK_1_GROUP_FLOW = DefaultFlowEntry.builder().forDevice(DUAL_LINK_1)
469 .forTable(0)
470 .withPriority(100)
471 .withSelector(SINGLE_FLOW_SELECTOR)
472 .withTreatment(DUAL_LINK_1_GROUP_FLOW_TREATMENT)
473 .fromApp(new DefaultApplicationId(0, "TestApp"))
474 .makePermanent()
475 .build();
476 static final FlowEntry DUAL_LINK_1_GROUP_FLOW_ENTRY = new DefaultFlowEntry(DUAL_LINK_1_GROUP_FLOW);
477
478 //Match on port 4 and point to group for device 2
479 private static final TrafficSelector DUAL_LINK_2_FLOW_SELECTOR = DefaultTrafficSelector.builder()
480 .matchInPort(PortNumber.portNumber(4))
481 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
482 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
483 .build();
484
485 private static final FlowRule DUAL_LINK_2_GROUP_FLOW = DefaultFlowEntry.builder().forDevice(DUAL_LINK_2)
486 .forTable(0)
487 .withPriority(100)
488 .withSelector(DUAL_LINK_2_FLOW_SELECTOR)
489 .withTreatment(DUAL_LINK_1_GROUP_FLOW_TREATMENT)
490 .fromApp(new DefaultApplicationId(0, "TestApp"))
491 .makePermanent()
492 .build();
493 static final FlowEntry DUAL_LINK_2_GROUP_FLOW_ENTRY = new DefaultFlowEntry(DUAL_LINK_2_GROUP_FLOW);
494
495 //Flows for device 3 to ouput on port 3
496 private static final TrafficTreatment DUAL_LINK_1_OUTPUT_TREATMENT = DefaultTrafficTreatment.builder()
497 .popMpls(EthType.EtherType.IPV4.ethType())
498 .setOutput(PortNumber.portNumber(3)).build();
499
500 private static final TrafficSelector DUAL_LINK_3_FLOW_SELECTOR_1 = DefaultTrafficSelector.builder()
501 .matchInPort(PortNumber.portNumber(1))
502 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
503 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
504 .build();
505 private static final FlowRule DUAL_LINK_3_FLOW_1 = DefaultFlowEntry.builder().forDevice(DUAL_LINK_3)
506 .forTable(0)
507 .withPriority(100)
508 .withSelector(DUAL_LINK_3_FLOW_SELECTOR_1)
509 .withTreatment(DUAL_LINK_1_OUTPUT_TREATMENT)
510 .fromApp(new DefaultApplicationId(0, "TestApp"))
511 .makePermanent()
512 .build();
513
514 static final FlowEntry DUAL_LINK_3_FLOW_ENTRY = new DefaultFlowEntry(DUAL_LINK_3_FLOW_1);
515
516 private static final TrafficSelector DUAL_LINK_3_FLOW_SELECTOR_2 = DefaultTrafficSelector.builder()
517 .matchInPort(PortNumber.portNumber(2))
518 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
519 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
520 .build();
521 private static final FlowRule DUAL_LINK_3_FLOW_2 = DefaultFlowEntry.builder().forDevice(DUAL_LINK_3)
522 .forTable(0)
523 .withPriority(100)
524 .withSelector(DUAL_LINK_3_FLOW_SELECTOR_2)
525 .withTreatment(DUAL_LINK_1_OUTPUT_TREATMENT)
526 .fromApp(new DefaultApplicationId(0, "TestApp"))
527 .makePermanent()
528 .build();
529
530 static final FlowEntry DUAL_LINK_3_FLOW_ENTRY_2 = new DefaultFlowEntry(DUAL_LINK_3_FLOW_2);
531
532 //Group with two buckets to output on port 2 and 3 of device 1 and 2
533
534 private static final GroupBucket BUCKET_2_DUAL =
535 DefaultGroupBucket.createSelectGroupBucket(DUAL_LINK_1_OUTPUT_TREATMENT);
536
537 private static final GroupBuckets BUCKETS_DUAL = new GroupBuckets(ImmutableList.of(BUCKET, BUCKET_2_DUAL));
538
539 static final Group DUAL_LINK_GROUP = new DefaultGroup(GROUP_ID, DUAL_LINK_1, Group.Type.SELECT, BUCKETS_DUAL);
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]540
Andrea Campanellad5bb2ef2018-01-31 16:43:23 +0100[diff] [blame]541 //Clear Deferred
542 static final DeviceId DEFERRED_1 = DeviceId.deviceId("Deferred");
543
544 static final ConnectPoint DEFERRED_CP_1_IN = ConnectPoint.deviceConnectPoint(DEFERRED_1 + "/" + 1);
545 static final ConnectPoint DEFERRED_CP_2_OUT = ConnectPoint.deviceConnectPoint(DEFERRED_1 + "/" + 2);
546
547 //match on port 1 and apply deferred actions
548 private static final TrafficTreatment DEFERRED_1_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
549 .transition(10)
550 .deferred()
551 .pushMpls()
552 .setMpls(MplsLabel.mplsLabel(100))
553 .build();
554 private static final FlowRule DEFERRED_FLOW = DefaultFlowEntry.builder().forDevice(DEFERRED_1)
555 .forTable(0)
556 .withPriority(100)
557 .withSelector(SINGLE_FLOW_SELECTOR)
558 .withTreatment(DEFERRED_1_FLOW_TREATMENT)
559 .fromApp(new DefaultApplicationId(0, "TestApp"))
560 .makePermanent()
561 .build();
562 static final FlowEntry DEFERRED_FLOW_ENTRY = new DefaultFlowEntry(DEFERRED_FLOW);
563
Andrea Campanella04924b92018-01-17 16:34:51 +0100[diff] [blame]564 //Multicast Flow and Group Test
565 static final DeviceId MULTICAST_GROUP_FLOW_DEVICE = DeviceId.deviceId("MulticastGroupFlowDevice");
566
567 private static final TrafficSelector MULTICAST_FLOW_SELECTOR = DefaultTrafficSelector.builder()
568 .matchInPort(PortNumber.portNumber(1))
569 .matchIPDst(IpPrefix.valueOf("224.0.0.1/32"))
570 .matchEthDst(MacAddress.valueOf("01:00:5e:00:00:01"))
571 .build();
572
573 private static final FlowRule MULTICAST_GROUP_FLOW =
574 DefaultFlowEntry.builder().forDevice(MULTICAST_GROUP_FLOW_DEVICE)
575 .forTable(0)
576 .withPriority(100)
577 .withSelector(MULTICAST_FLOW_SELECTOR)
578 .withTreatment(GROUP_FLOW_TREATMENT)
579 .fromApp(new DefaultApplicationId(0, "TestApp"))
580 .makePermanent()
581 .build();
582
583 static final FlowEntry MULTICAST_GROUP_FLOW_ENTRY = new DefaultFlowEntry(MULTICAST_GROUP_FLOW);
584
585 static final Group MULTICAST_GROUP = new DefaultGroup(GROUP_ID, MULTICAST_GROUP_FLOW_DEVICE,
586 Group.Type.SELECT, BUCKETS_MULTIPLE);
587
588 static final ConnectPoint MULTICAST_IN_CP = ConnectPoint.deviceConnectPoint(MULTICAST_GROUP_FLOW_DEVICE + "/" + 1);
589
590 static final ConnectPoint MULTICAST_OUT_CP = ConnectPoint.deviceConnectPoint(MULTICAST_GROUP_FLOW_DEVICE + "/" + 3);
591
592 static final ConnectPoint MULTICAST_OUT_CP_2 =
593 ConnectPoint.deviceConnectPoint(MULTICAST_GROUP_FLOW_DEVICE + "/" + 2);
594
Andrea Campanellad5bb2ef2018-01-31 16:43:23 +0100[diff] [blame]595 //match on port 1, clear deferred actions and output
596 private static final TrafficTreatment DEFERRED_CLEAR_1_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
597 .wipeDeferred()
598 .setOutput(PortNumber.portNumber(2))
599 .build();
600 private static final FlowRule DEFERRED_CLEAR_FLOW = DefaultFlowEntry.builder().forDevice(DEFERRED_1)
601 .forTable(10)
602 .withPriority(100)
603 .withSelector(SINGLE_FLOW_SELECTOR)
604 .withTreatment(DEFERRED_CLEAR_1_FLOW_TREATMENT)
605 .fromApp(new DefaultApplicationId(0, "TestApp"))
606 .makePermanent()
607 .build();
608 static final FlowEntry DEFERRED_CLEAR_FLOW_ENTRY = new DefaultFlowEntry(DEFERRED_CLEAR_FLOW);
609
Andrea Campanella6f2d6742018-02-07 12:00:12 +0100[diff] [blame]610 //LLDP
611
612 static final DeviceId LLDP_FLOW_DEVICE = DeviceId.deviceId("LldpDevice");
613
614 private static final TrafficSelector LLDP_FLOW_SELECTOR = DefaultTrafficSelector.builder()
615 .matchInPort(PortNumber.portNumber(1))
616 .matchEthType(EthType.EtherType.LLDP.ethType().toShort())
617 .build();
618
619 private static final TrafficTreatment LLDP_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
620 .setOutput(PortNumber.CONTROLLER).build();
621 private static final FlowRule LLDP_FLOW = DefaultFlowEntry.builder().forDevice(LLDP_FLOW_DEVICE)
622 .forTable(0)
623 .withPriority(100)
624 .withSelector(LLDP_FLOW_SELECTOR)
625 .withTreatment(LLDP_FLOW_TREATMENT)
626 .fromApp(new DefaultApplicationId(0, "TestApp"))
627 .makePermanent()
628 .build();
629 static final FlowEntry LLDP_FLOW_ENTRY = new DefaultFlowEntry(LLDP_FLOW);
630
631 static final ConnectPoint LLDP_FLOW_CP = ConnectPoint.deviceConnectPoint(LLDP_FLOW_DEVICE + "/" + 1);
632
Andrea Campanella7cb4fd82018-02-27 12:36:00 +0100[diff] [blame]633 //No Buckets
634
635 static final DeviceId NO_BUCKET_DEVICE = DeviceId.deviceId("nobucket");
636
637 private static final TrafficSelector NO_BUCKET_SELECTOR = DefaultTrafficSelector.builder()
638 .matchInPort(PortNumber.portNumber(1))
639 .build();
640
641 private static final GroupId NO_BUCKET_GROUP_ID = GroupId.valueOf(1);
642
643 private static final TrafficTreatment NO_BUCKET_TREATMENT = DefaultTrafficTreatment.builder()
644 .group(NO_BUCKET_GROUP_ID)
645 .build();
646 private static final FlowRule NO_BUCKET_FLOW = DefaultFlowEntry.builder().forDevice(NO_BUCKET_DEVICE)
647 .forTable(0)
648 .withPriority(100)
649 .withSelector(NO_BUCKET_SELECTOR)
650 .withTreatment(NO_BUCKET_TREATMENT)
651 .fromApp(new DefaultApplicationId(0, "TestApp"))
652 .makePermanent()
653 .build();
654 static final FlowEntry NO_BUCKET_ENTRY = new DefaultFlowEntry(NO_BUCKET_FLOW);
655
656 private static final GroupBuckets NO_BUCKETS = new GroupBuckets(ImmutableList.of());
657
658 static final Group NO_BUCKET_GROUP =
659 new DefaultGroup(NO_BUCKET_GROUP_ID, NO_BUCKET_DEVICE, Group.Type.SELECT, NO_BUCKETS);
660
661 static final ConnectPoint NO_BUCKET_CP = ConnectPoint.deviceConnectPoint(NO_BUCKET_DEVICE + "/" + 1);
662
Andrea Campanella490ec3a2018-03-01 16:22:21 +0100[diff] [blame]663 //Dual Homing
664
665 static final DeviceId DUAL_HOME_DEVICE_1 = DeviceId.deviceId("DualHomeDevice1");
666
667 static final DeviceId DUAL_HOME_DEVICE_2 = DeviceId.deviceId("DualHomeDevice2");
668
669 static final DeviceId DUAL_HOME_DEVICE_3 = DeviceId.deviceId("DualHomeDevice3");
670
671 static final ConnectPoint DUAL_HOME_CP_1_1 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_1 + "/" + 1);
672 static final ConnectPoint DUAL_HOME_CP_1_2 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_1 + "/" + 2);
673 static final ConnectPoint DUAL_HOME_CP_1_3 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_1 + "/" + 3);
674
675 static final ConnectPoint DUAL_HOME_CP_2_1 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_2 + "/" + 1);
676 static final ConnectPoint DUAL_HOME_CP_2_2 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_2 + "/" + 2);
677
678 static final ConnectPoint DUAL_HOME_CP_3_1 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_3 + "/" + 1);
679 static final ConnectPoint DUAL_HOME_CP_3_2 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_3 + "/" + 2);
680
681
682 private static final TrafficSelector DUAL_HOME_INPUT_FLOW_SELECTOR = DefaultTrafficSelector.builder()
683 .matchInPort(PortNumber.portNumber(1))
684 .build();
685
686 private static final GroupId DUAL_HOME_GROUP_ID = GroupId.valueOf(1);
687
688 private static final TrafficTreatment DUAL_HOME_GROUP_TREATMENT = DefaultTrafficTreatment.builder()
689 .group(DUAL_HOME_GROUP_ID)
690 .build();
691 private static final FlowRule DUAL_HOME_INPUT_FLOW = DefaultFlowEntry.builder().forDevice(DUAL_HOME_DEVICE_1)
692 .forTable(0)
693 .withPriority(100)
694 .withSelector(DUAL_HOME_INPUT_FLOW_SELECTOR)
695 .withTreatment(DUAL_HOME_GROUP_TREATMENT)
696 .fromApp(new DefaultApplicationId(0, "TestApp"))
697 .makePermanent()
698 .build();
699 static final FlowEntry DUAL_HOME_FLOW_ENTRY = new DefaultFlowEntry(DUAL_HOME_INPUT_FLOW);
700
701 private static final TrafficTreatment DUAL_HOME_OUTPUT_1_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
702 .setOutput(PortNumber.portNumber(2)).build();
703 private static final TrafficTreatment DUAL_HOME_OUTPUT_2_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
704 .setOutput(PortNumber.portNumber(3)).build();
705
706 private static final GroupBucket BUCKET_1_DUAL_HOMED =
707 DefaultGroupBucket.createSelectGroupBucket(DUAL_HOME_OUTPUT_1_FLOW_TREATMENT);
708
709 private static final GroupBucket BUCKET_2_DUAL_HOMED =
710 DefaultGroupBucket.createSelectGroupBucket(DUAL_HOME_OUTPUT_2_FLOW_TREATMENT);
711
712 private static final GroupBuckets BUCKETS_MULTIPLE_DUAL = new GroupBuckets(ImmutableList.of(BUCKET_1_DUAL_HOMED,
713 BUCKET_2_DUAL_HOMED));
714
715 static final Group DUAL_HOME_GROUP = new DefaultGroup(DUAL_HOME_GROUP_ID, DUAL_HOME_DEVICE_1,
716 Group.Type.SELECT, BUCKETS_MULTIPLE_DUAL);
717
718 private static final TrafficTreatment DUAL_HOME_TREATMENT = DefaultTrafficTreatment.builder()
719 .setOutput(PortNumber.portNumber("2"))
720 .build();
721 private static final FlowRule DUAL_HOME_OUT_FLOW = DefaultFlowEntry.builder().forDevice(DUAL_HOME_DEVICE_2)
722 .forTable(0)
723 .withPriority(100)
724 .withSelector(DUAL_HOME_INPUT_FLOW_SELECTOR)
725 .withTreatment(DUAL_HOME_TREATMENT)
726 .fromApp(new DefaultApplicationId(0, "TestApp"))
727 .makePermanent()
728 .build();
729 static final FlowEntry DUAL_HOME_OUT_FLOW_ENTRY = new DefaultFlowEntry(DUAL_HOME_OUT_FLOW);
730
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]731 //helper elements
732
Andrea Campanella7c8e7912018-01-23 12:46:04 +0100[diff] [blame]733 static final String MASTER_1 = "Master1";
734
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]735 static final Host H1 = new DefaultHost(ProviderId.NONE, HostId.hostId(HOST_ONE), MacAddress.valueOf(100),
736 VlanId.NONE, new HostLocation(SINGLE_FLOW_DEVICE, PortNumber.portNumber(2), 0),
737 ImmutableSet.of(IpAddress.valueOf("127.0.0.2")));
738
739 static final Host H2 = new DefaultHost(ProviderId.NONE, HostId.hostId(HOST_TWO), MacAddress.valueOf(100),
740 VlanId.NONE, new HostLocation(TOPO_FLOW_3_DEVICE, PortNumber.portNumber(2), 0),
741 ImmutableSet.of(IpAddress.valueOf("127.0.0.3")));
742
Andrea Campanella490ec3a2018-03-01 16:22:21 +0100[diff] [blame]743 static final Host DUAL_HOME_H = new DefaultHost(ProviderId.NONE, HostId.hostId(HOST_DUAL_HOMED),
744 MacAddress.valueOf(HOST_DUAL_HOMED_MAC),
745 VlanId.NONE, ImmutableSet.of(new HostLocation(DUAL_HOME_DEVICE_2, PortNumber.portNumber(2), 0),
746 new HostLocation(DUAL_HOME_DEVICE_3, PortNumber.portNumber(2), 0)),
747 ImmutableSet.of(IpAddress.valueOf("127.0.0.4")), true, DefaultAnnotations.builder().build());
748
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]749 static final TrafficSelector PACKET_OK = DefaultTrafficSelector.builder()
750 .matchInPort(PortNumber.portNumber(1))
Andrea Campanella2bc55dd2018-01-18 16:54:34 +0100[diff] [blame]751 .matchEthType(EthType.EtherType.IPV4.ethType().toShort())
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]752 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
753 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
Andrea Campanella97f9d4c2018-02-06 18:58:40 +0100[diff] [blame]754 .matchVlanId(VlanId.NONE)
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]755 .build();
756
757 static final TrafficSelector PACKET_OK_TOPO = DefaultTrafficSelector.builder()
758 .matchInPort(PortNumber.portNumber(1))
759 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
760 .matchIPDst(IpPrefix.valueOf("127.0.0.3/32"))
761 .build();
762
Andrea Campanella7c8e7912018-01-23 12:46:04 +0100[diff] [blame]763 static final TrafficSelector PACKET_ARP = DefaultTrafficSelector.builder()
764 .matchInPort(PortNumber.portNumber(1))
765 .matchIPDst(IpPrefix.valueOf("255.255.255.255/32"))
766 .matchEthType(EthType.EtherType.ARP.ethType().toShort())
767 .build();
768
Andrea Campanella6f2d6742018-02-07 12:00:12 +0100[diff] [blame]769 static final TrafficSelector PACKET_LLDP = DefaultTrafficSelector.builder()
770 .matchInPort(PortNumber.portNumber(1))
771 .matchEthType(EthType.EtherType.LLDP.ethType().toShort())
772 .build();
773
Andrea Campanella04924b92018-01-17 16:34:51 +0100[diff] [blame]774 static final TrafficSelector PACKET_OK_MULTICAST = DefaultTrafficSelector.builder()
775 .matchInPort(PortNumber.portNumber(1))
776 .matchEthType(EthType.EtherType.IPV4.ethType().toShort())
777 .matchEthDst(MacAddress.valueOf("01:00:5e:00:00:01"))
778 .matchIPDst(IpPrefix.valueOf("224.0.0.1/32"))
779 .build();
780
Andrea Campanella490ec3a2018-03-01 16:22:21 +0100[diff] [blame]781 static final TrafficSelector PACKET_DUAL_HOME = DefaultTrafficSelector.builder()
782 .matchInPort(PortNumber.portNumber(1))
783 .matchEthType(EthType.EtherType.IPV4.ethType().toShort())
784 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
785 .matchIPDst(IpPrefix.valueOf("127.0.0.4/32"))
786 .build();
787
Andrea Campanella01e886e2017-12-15 15:27:31 +0100[diff] [blame]788 static final TrafficSelector PACKET_FAIL = DefaultTrafficSelector.builder()
789 .matchInPort(PortNumber.portNumber(1))
790 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
791 .matchIPDst(IpPrefix.valueOf("127.0.0.99/32"))
792 .build();
793}