Gitiles
Code Review Sign In
gerrit.onosproject.org / trellis-t3 / 4906ba77cdf816ba134418667ab5ade2495f518d / . / src / test / java / org / onosproject / t3 / impl / T3TestObjects.java
blob: 85014002e10c82aa0326c8026870bed5fad3565a [file] [log] [blame]
Andrea Campanellae4084402017-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 Campanella3970e472018-01-25 16:44:04 +0100[diff] [blame]24import org.onlab.packet.MplsLabel;
Andrea Campanellae4084402017-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 Campanella4906ba72018-03-01 16:22:21 +0100[diff] [blame^]29import org.onosproject.net.DefaultAnnotations;
Andrea Campanellae4084402017-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 Campanella54923d62018-01-23 12:46:04 +0100[diff] [blame]55 private T3TestObjects() {
Andrea Campanella4401bd72018-01-18 16:54:34 +0100[diff] [blame]56 //banning construction
57 }
58
Andrea Campanellae4084402017-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 Campanella4906ba72018-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 Campanellae4084402017-12-15 15:27:31 +0100[diff] [blame]68
Andrea Campanella17d45192018-01-18 17:11:42 +0100[diff] [blame]69 //offline device
70 static final DeviceId OFFLINE_DEVICE = DeviceId.deviceId("offlineDevice");
71
Andrea Campanellae4084402017-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 Campanella7d3cf652018-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 Campanella54923d62018-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 Campanella7d3cf652018-01-22 15:10:30 +0100[diff] [blame]135
Andrea Campanellae4084402017-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 Campanella3970e472018-01-25 16:44:04 +0100[diff] [blame]174 .pushMpls()
175 .setMpls(MplsLabel.mplsLabel(100))
Andrea Campanellae4084402017-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 Campanella3970e472018-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 Campanellae4084402017-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
202 //topology
203
204 static final DeviceId TOPO_FLOW_DEVICE = DeviceId.deviceId("SingleFlowDevice1");
205
206 static final DeviceId TOPO_FLOW_2_DEVICE = DeviceId.deviceId("SingleFlowDevice2");
207
208 static final DeviceId TOPO_FLOW_3_DEVICE = DeviceId.deviceId("SingleFlowDevice3");
209
210 private static final TrafficSelector TOPO_FLOW_SELECTOR = DefaultTrafficSelector.builder()
211 .matchInPort(PortNumber.portNumber(1))
212 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
213 .matchIPDst(IpPrefix.valueOf("127.0.0.3/32"))
214 .build();
215
216 private static final FlowRule TOPO_SINGLE_FLOW = DefaultFlowEntry.builder().forDevice(TOPO_FLOW_DEVICE)
217 .forTable(0)
218 .withPriority(100)
219 .withSelector(TOPO_FLOW_SELECTOR)
220 .withTreatment(OUTPUT_FLOW_TREATMENT)
221 .fromApp(new DefaultApplicationId(0, "TestApp"))
222 .makePermanent()
223 .build();
224
225 static final FlowEntry TOPO_SINGLE_FLOW_ENTRY = new DefaultFlowEntry(TOPO_SINGLE_FLOW);
226
227 static final ConnectPoint TOPO_FLOW_1_IN_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_DEVICE + "/" + 1);
228
229 static final ConnectPoint TOPO_FLOW_1_OUT_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_DEVICE + "/" + 2);
230
231 static final ConnectPoint TOPO_FLOW_2_IN_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_2_DEVICE + "/" + 1);
232
233 static final ConnectPoint TOPO_FLOW_2_OUT_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_2_DEVICE + "/" + 2);
234
235 static final ConnectPoint TOPO_FLOW_3_IN_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_3_DEVICE + "/" + 1);
236
237 static final ConnectPoint TOPO_FLOW_3_OUT_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_3_DEVICE + "/" + 2);
238
239
240 //Topology with Groups
241
242 static final DeviceId TOPO_GROUP_FLOW_DEVICE = DeviceId.deviceId("TopoGroupFlowDevice");
243
244 private static final TrafficSelector TOPO_SECOND_INPUT_FLOW_SELECTOR = DefaultTrafficSelector.builder()
245 .matchInPort(PortNumber.portNumber(3))
246 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
247 .matchIPDst(IpPrefix.valueOf("127.0.0.3/32"))
248 .build();
249
250 private static final FlowRule TOPO_SECOND_INPUT_FLOW = DefaultFlowEntry.builder().forDevice(TOPO_FLOW_3_DEVICE)
251 .forTable(0)
252 .withPriority(100)
253 .withSelector(TOPO_SECOND_INPUT_FLOW_SELECTOR)
254 .withTreatment(OUTPUT_FLOW_TREATMENT)
255 .fromApp(new DefaultApplicationId(0, "TestApp"))
256 .makePermanent()
257 .build();
258
259 private static final TrafficTreatment OUTPUT_2_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
260 .setOutput(PortNumber.portNumber(3)).build();
261
262
263 private static final GroupId TOPO_GROUP_ID = GroupId.valueOf(1);
264
265 private static final TrafficTreatment TOPO_GROUP_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
266 .group(TOPO_GROUP_ID)
267 .build();
268 private static final FlowRule TOPO_GROUP_FLOW = DefaultFlowEntry.builder().forDevice(TOPO_GROUP_FLOW_DEVICE)
269 .forTable(0)
270 .withPriority(100)
271 .withSelector(TOPO_FLOW_SELECTOR)
272 .withTreatment(TOPO_GROUP_FLOW_TREATMENT)
273 .fromApp(new DefaultApplicationId(0, "TestApp"))
274 .makePermanent()
275 .build();
276 static final FlowEntry TOPO_GROUP_FLOW_ENTRY = new DefaultFlowEntry(TOPO_GROUP_FLOW);
277
278 private static final GroupBucket BUCKET_2 = DefaultGroupBucket.createSelectGroupBucket(OUTPUT_2_FLOW_TREATMENT);
279
280 private static final GroupBuckets BUCKETS_MULTIPLE = new GroupBuckets(ImmutableList.of(BUCKET, BUCKET_2));
281
Andrea Campanella4401bd72018-01-18 16:54:34 +0100[diff] [blame]282 static final Group TOPO_GROUP = new DefaultGroup(TOPO_GROUP_ID, TOPO_GROUP_FLOW_DEVICE,
283 Group.Type.SELECT, BUCKETS_MULTIPLE);
Andrea Campanellae4084402017-12-15 15:27:31 +0100[diff] [blame]284
285 static final FlowEntry TOPO_SECOND_INPUT_FLOW_ENTRY = new DefaultFlowEntry(TOPO_SECOND_INPUT_FLOW);
286
287 static final DeviceId TOPO_FLOW_4_DEVICE = DeviceId.deviceId("SingleFlowDevice4");
288
289 static final ConnectPoint TOPO_FLOW_IN_CP = ConnectPoint.deviceConnectPoint(TOPO_GROUP_FLOW_DEVICE + "/" + 1);
290
291 static final ConnectPoint TOPO_FLOW_OUT_CP_1 = ConnectPoint.deviceConnectPoint(TOPO_GROUP_FLOW_DEVICE + "/" + 2);
292
Andrea Campanella4401bd72018-01-18 16:54:34 +0100[diff] [blame]293 protected static final ConnectPoint TOPO_FLOW_OUT_CP_2 =
294 ConnectPoint.deviceConnectPoint(TOPO_GROUP_FLOW_DEVICE + "/" + 3);
Andrea Campanellae4084402017-12-15 15:27:31 +0100[diff] [blame]295
296 static final ConnectPoint TOPO_FLOW_4_IN_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_4_DEVICE + "/" + 1);
297
298 static final ConnectPoint TOPO_FLOW_3_IN_2_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_3_DEVICE + "/" + 3);
299
300 static final ConnectPoint TOPO_FLOW_4_OUT_CP = ConnectPoint.deviceConnectPoint(TOPO_FLOW_4_DEVICE + "/" + 2);
301
302
303 //hardware
304
305 static final DeviceId HARDWARE_DEVICE = DeviceId.deviceId("HardwareDevice");
306
307 static final ConnectPoint HARDWARE_DEVICE_IN_CP = ConnectPoint.deviceConnectPoint(HARDWARE_DEVICE + "/" + 1);
308
309 static final ConnectPoint HARDWARE_DEVICE_OUT_CP = ConnectPoint.deviceConnectPoint(HARDWARE_DEVICE + "/" + 2);
310
311 private static final TrafficSelector HARDWARE_FLOW_SELECTOR = DefaultTrafficSelector.builder()
312 .matchInPort(PortNumber.portNumber(1))
313 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
314 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
315 .build();
316
317 private static final TrafficTreatment HW_TRANSITION_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
318 .pushMpls()
319 .transition(27)
320 .build();
321
322 private static final FlowRule HARDWARE_FLOW = DefaultFlowEntry.builder().forDevice(TOPO_FLOW_3_DEVICE)
323 .forTable(0)
324 .withPriority(100)
325 .withSelector(HARDWARE_FLOW_SELECTOR)
326 .withTreatment(HW_TRANSITION_FLOW_TREATMENT)
327 .fromApp(new DefaultApplicationId(0, "TestApp"))
328 .makePermanent()
329 .build();
330
331 static final FlowEntry HARDWARE_FLOW_ENTRY = new DefaultFlowEntry(HARDWARE_FLOW);
332
333 private static final TrafficSelector HARDWARE_ETH_FLOW_SELECTOR = DefaultTrafficSelector.builder()
334 .matchInPort(PortNumber.portNumber(1))
335 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
336 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
337 .matchEthType(EthType.EtherType.IPV4.ethType().toShort())
338 .build();
339
340 private static final FlowRule HARDWARE_ETH_FLOW = DefaultFlowEntry.builder().forDevice(TOPO_FLOW_3_DEVICE)
341 .forTable(30)
342 .withPriority(100)
343 .withSelector(HARDWARE_ETH_FLOW_SELECTOR)
344 .withTreatment(OUTPUT_FLOW_TREATMENT)
345 .fromApp(new DefaultApplicationId(0, "TestApp"))
346 .makePermanent()
347 .build();
348
349 static final FlowEntry HARDWARE_ETH_FLOW_ENTRY = new DefaultFlowEntry(HARDWARE_ETH_FLOW);
350
Andrea Campanella94c594a2018-02-06 18:58:40 +0100[diff] [blame]351 //HW Double Rule on 10
352
353 static final DeviceId HARDWARE_DEVICE_10 = DeviceId.deviceId("HardwareDevice10");
354
355 static final ConnectPoint HARDWARE_DEVICE_10_IN_CP = ConnectPoint.deviceConnectPoint(HARDWARE_DEVICE_10 + "/" + 1);
356
357 static final ConnectPoint HARDWARE_DEVICE_10_OUT_CP = ConnectPoint.deviceConnectPoint(HARDWARE_DEVICE_10 + "/" + 2);
358
359 private static final TrafficSelector HARDWARE_10_FLOW_SELECTOR = DefaultTrafficSelector.builder()
360 .matchInPort(PortNumber.portNumber(1))
361 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
362 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
363 .matchVlanId(VlanId.NONE)
364 .build();
365
366 private static final TrafficTreatment HARDWARE_10_TRANSITION_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
367 .setVlanId(VlanId.vlanId("10"))
368 .transition(20)
369 .build();
370
371 private static final FlowRule HARDWARE_DEVICE_10_FLOW = DefaultFlowEntry.builder().forDevice(HARDWARE_DEVICE_10)
372 .forTable(10)
373 .withPriority(100)
374 .withSelector(HARDWARE_10_FLOW_SELECTOR)
375 .withTreatment(HARDWARE_10_TRANSITION_FLOW_TREATMENT)
376 .fromApp(new DefaultApplicationId(0, "TestApp"))
377 .makePermanent()
378 .build();
379
380 static final FlowEntry HARDWARE_10_FLOW_ENTRY = new DefaultFlowEntry(HARDWARE_DEVICE_10_FLOW);
381
382 private static final TrafficSelector HARDWARE_10_SECOND_SELECTOR = DefaultTrafficSelector.builder()
383 .matchInPort(PortNumber.portNumber(1))
384 .matchVlanId(VlanId.vlanId("10"))
385 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
386 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
387 .matchEthType(EthType.EtherType.IPV4.ethType().toShort())
388 .build();
389
390 private static final FlowRule HARDWARE_10_SECOND_FLOW = DefaultFlowEntry.builder().forDevice(HARDWARE_DEVICE_10)
391 .forTable(10)
392 .withPriority(100)
393 .withSelector(HARDWARE_10_SECOND_SELECTOR)
394 .withTreatment(HARDWARE_10_TRANSITION_FLOW_TREATMENT)
395 .fromApp(new DefaultApplicationId(0, "TestApp"))
396 .makePermanent()
397 .build();
398
399 static final FlowEntry HARDWARE_10_SECOND_FLOW_ENTRY = new DefaultFlowEntry(HARDWARE_10_SECOND_FLOW);
400
401 private static final FlowRule HARDWARE_10_OUTPUT_FLOW = DefaultFlowEntry.builder().forDevice(HARDWARE_DEVICE_10)
402 .forTable(20)
403 .withPriority(100)
404 .withSelector(SINGLE_FLOW_SELECTOR)
405 .withTreatment(OUTPUT_FLOW_TREATMENT)
406 .fromApp(new DefaultApplicationId(0, "TestApp"))
407 .makePermanent()
408 .build();
409
410 static final FlowEntry HARDWARE_10_OUTPUT_FLOW_ENTRY = new DefaultFlowEntry(HARDWARE_10_OUTPUT_FLOW);
411
Andrea Campanellab022b5e2018-01-31 14:59:03 +0100[diff] [blame]412 //Dual Links
413 // - (1) Device 1 (2-3) - (1-4) Device 2 (2-3) - (1-2) Device 3 (3) -
414 static final DeviceId DUAL_LINK_1 = DeviceId.deviceId("DualLink1");
415 static final DeviceId DUAL_LINK_2 = DeviceId.deviceId("DualLink2");
416 static final DeviceId DUAL_LINK_3 = DeviceId.deviceId("DualLink3");
417
418 static final ConnectPoint DUAL_LINK_1_CP_1_IN = ConnectPoint.deviceConnectPoint(DUAL_LINK_1 + "/" + 1);
419 static final ConnectPoint DUAL_LINK_1_CP_2_OUT = ConnectPoint.deviceConnectPoint(DUAL_LINK_1 + "/" + 2);
420 static final ConnectPoint DUAL_LINK_1_CP_3_OUT = ConnectPoint.deviceConnectPoint(DUAL_LINK_1 + "/" + 3);
421 static final ConnectPoint DUAL_LINK_2_CP_1_IN = ConnectPoint.deviceConnectPoint(DUAL_LINK_2 + "/" + 1);
422 static final ConnectPoint DUAL_LINK_2_CP_4_IN = ConnectPoint.deviceConnectPoint(DUAL_LINK_2 + "/" + 4);
423 static final ConnectPoint DUAL_LINK_2_CP_2_OUT = ConnectPoint.deviceConnectPoint(DUAL_LINK_2 + "/" + 2);
424 static final ConnectPoint DUAL_LINK_2_CP_3_OUT = ConnectPoint.deviceConnectPoint(DUAL_LINK_2 + "/" + 3);
425 static final ConnectPoint DUAL_LINK_3_CP_1_IN = ConnectPoint.deviceConnectPoint(DUAL_LINK_3 + "/" + 1);
426 static final ConnectPoint DUAL_LINK_3_CP_2_IN = ConnectPoint.deviceConnectPoint(DUAL_LINK_3 + "/" + 2);
427 static final ConnectPoint DUAL_LINK_3_CP_3_OUT = ConnectPoint.deviceConnectPoint(DUAL_LINK_3 + "/" + 3);
428
429 //match on port 1 and point to group for device 1 and 2
430 private static final TrafficTreatment DUAL_LINK_1_GROUP_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
431 .pushMpls()
432 .setMpls(MplsLabel.mplsLabel(100))
433 .group(GROUP_ID)
434 .build();
435 private static final FlowRule DUAL_LINK_1_GROUP_FLOW = DefaultFlowEntry.builder().forDevice(DUAL_LINK_1)
436 .forTable(0)
437 .withPriority(100)
438 .withSelector(SINGLE_FLOW_SELECTOR)
439 .withTreatment(DUAL_LINK_1_GROUP_FLOW_TREATMENT)
440 .fromApp(new DefaultApplicationId(0, "TestApp"))
441 .makePermanent()
442 .build();
443 static final FlowEntry DUAL_LINK_1_GROUP_FLOW_ENTRY = new DefaultFlowEntry(DUAL_LINK_1_GROUP_FLOW);
444
445 //Match on port 4 and point to group for device 2
446 private static final TrafficSelector DUAL_LINK_2_FLOW_SELECTOR = DefaultTrafficSelector.builder()
447 .matchInPort(PortNumber.portNumber(4))
448 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
449 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
450 .build();
451
452 private static final FlowRule DUAL_LINK_2_GROUP_FLOW = DefaultFlowEntry.builder().forDevice(DUAL_LINK_2)
453 .forTable(0)
454 .withPriority(100)
455 .withSelector(DUAL_LINK_2_FLOW_SELECTOR)
456 .withTreatment(DUAL_LINK_1_GROUP_FLOW_TREATMENT)
457 .fromApp(new DefaultApplicationId(0, "TestApp"))
458 .makePermanent()
459 .build();
460 static final FlowEntry DUAL_LINK_2_GROUP_FLOW_ENTRY = new DefaultFlowEntry(DUAL_LINK_2_GROUP_FLOW);
461
462 //Flows for device 3 to ouput on port 3
463 private static final TrafficTreatment DUAL_LINK_1_OUTPUT_TREATMENT = DefaultTrafficTreatment.builder()
464 .popMpls(EthType.EtherType.IPV4.ethType())
465 .setOutput(PortNumber.portNumber(3)).build();
466
467 private static final TrafficSelector DUAL_LINK_3_FLOW_SELECTOR_1 = DefaultTrafficSelector.builder()
468 .matchInPort(PortNumber.portNumber(1))
469 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
470 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
471 .build();
472 private static final FlowRule DUAL_LINK_3_FLOW_1 = DefaultFlowEntry.builder().forDevice(DUAL_LINK_3)
473 .forTable(0)
474 .withPriority(100)
475 .withSelector(DUAL_LINK_3_FLOW_SELECTOR_1)
476 .withTreatment(DUAL_LINK_1_OUTPUT_TREATMENT)
477 .fromApp(new DefaultApplicationId(0, "TestApp"))
478 .makePermanent()
479 .build();
480
481 static final FlowEntry DUAL_LINK_3_FLOW_ENTRY = new DefaultFlowEntry(DUAL_LINK_3_FLOW_1);
482
483 private static final TrafficSelector DUAL_LINK_3_FLOW_SELECTOR_2 = DefaultTrafficSelector.builder()
484 .matchInPort(PortNumber.portNumber(2))
485 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
486 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
487 .build();
488 private static final FlowRule DUAL_LINK_3_FLOW_2 = DefaultFlowEntry.builder().forDevice(DUAL_LINK_3)
489 .forTable(0)
490 .withPriority(100)
491 .withSelector(DUAL_LINK_3_FLOW_SELECTOR_2)
492 .withTreatment(DUAL_LINK_1_OUTPUT_TREATMENT)
493 .fromApp(new DefaultApplicationId(0, "TestApp"))
494 .makePermanent()
495 .build();
496
497 static final FlowEntry DUAL_LINK_3_FLOW_ENTRY_2 = new DefaultFlowEntry(DUAL_LINK_3_FLOW_2);
498
499 //Group with two buckets to output on port 2 and 3 of device 1 and 2
500
501 private static final GroupBucket BUCKET_2_DUAL =
502 DefaultGroupBucket.createSelectGroupBucket(DUAL_LINK_1_OUTPUT_TREATMENT);
503
504 private static final GroupBuckets BUCKETS_DUAL = new GroupBuckets(ImmutableList.of(BUCKET, BUCKET_2_DUAL));
505
506 static final Group DUAL_LINK_GROUP = new DefaultGroup(GROUP_ID, DUAL_LINK_1, Group.Type.SELECT, BUCKETS_DUAL);
Andrea Campanellae4084402017-12-15 15:27:31 +0100[diff] [blame]507
Andrea Campanella8292ba62018-01-31 16:43:23 +0100[diff] [blame]508 //Clear Deferred
509 static final DeviceId DEFERRED_1 = DeviceId.deviceId("Deferred");
510
511 static final ConnectPoint DEFERRED_CP_1_IN = ConnectPoint.deviceConnectPoint(DEFERRED_1 + "/" + 1);
512 static final ConnectPoint DEFERRED_CP_2_OUT = ConnectPoint.deviceConnectPoint(DEFERRED_1 + "/" + 2);
513
514 //match on port 1 and apply deferred actions
515 private static final TrafficTreatment DEFERRED_1_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
516 .transition(10)
517 .deferred()
518 .pushMpls()
519 .setMpls(MplsLabel.mplsLabel(100))
520 .build();
521 private static final FlowRule DEFERRED_FLOW = DefaultFlowEntry.builder().forDevice(DEFERRED_1)
522 .forTable(0)
523 .withPriority(100)
524 .withSelector(SINGLE_FLOW_SELECTOR)
525 .withTreatment(DEFERRED_1_FLOW_TREATMENT)
526 .fromApp(new DefaultApplicationId(0, "TestApp"))
527 .makePermanent()
528 .build();
529 static final FlowEntry DEFERRED_FLOW_ENTRY = new DefaultFlowEntry(DEFERRED_FLOW);
530
Andrea Campanella4c6170a2018-01-17 16:34:51 +0100[diff] [blame]531 //Multicast Flow and Group Test
532 static final DeviceId MULTICAST_GROUP_FLOW_DEVICE = DeviceId.deviceId("MulticastGroupFlowDevice");
533
534 private static final TrafficSelector MULTICAST_FLOW_SELECTOR = DefaultTrafficSelector.builder()
535 .matchInPort(PortNumber.portNumber(1))
536 .matchIPDst(IpPrefix.valueOf("224.0.0.1/32"))
537 .matchEthDst(MacAddress.valueOf("01:00:5e:00:00:01"))
538 .build();
539
540 private static final FlowRule MULTICAST_GROUP_FLOW =
541 DefaultFlowEntry.builder().forDevice(MULTICAST_GROUP_FLOW_DEVICE)
542 .forTable(0)
543 .withPriority(100)
544 .withSelector(MULTICAST_FLOW_SELECTOR)
545 .withTreatment(GROUP_FLOW_TREATMENT)
546 .fromApp(new DefaultApplicationId(0, "TestApp"))
547 .makePermanent()
548 .build();
549
550 static final FlowEntry MULTICAST_GROUP_FLOW_ENTRY = new DefaultFlowEntry(MULTICAST_GROUP_FLOW);
551
552 static final Group MULTICAST_GROUP = new DefaultGroup(GROUP_ID, MULTICAST_GROUP_FLOW_DEVICE,
553 Group.Type.SELECT, BUCKETS_MULTIPLE);
554
555 static final ConnectPoint MULTICAST_IN_CP = ConnectPoint.deviceConnectPoint(MULTICAST_GROUP_FLOW_DEVICE + "/" + 1);
556
557 static final ConnectPoint MULTICAST_OUT_CP = ConnectPoint.deviceConnectPoint(MULTICAST_GROUP_FLOW_DEVICE + "/" + 3);
558
559 static final ConnectPoint MULTICAST_OUT_CP_2 =
560 ConnectPoint.deviceConnectPoint(MULTICAST_GROUP_FLOW_DEVICE + "/" + 2);
561
Andrea Campanella8292ba62018-01-31 16:43:23 +0100[diff] [blame]562 //match on port 1, clear deferred actions and output
563 private static final TrafficTreatment DEFERRED_CLEAR_1_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
564 .wipeDeferred()
565 .setOutput(PortNumber.portNumber(2))
566 .build();
567 private static final FlowRule DEFERRED_CLEAR_FLOW = DefaultFlowEntry.builder().forDevice(DEFERRED_1)
568 .forTable(10)
569 .withPriority(100)
570 .withSelector(SINGLE_FLOW_SELECTOR)
571 .withTreatment(DEFERRED_CLEAR_1_FLOW_TREATMENT)
572 .fromApp(new DefaultApplicationId(0, "TestApp"))
573 .makePermanent()
574 .build();
575 static final FlowEntry DEFERRED_CLEAR_FLOW_ENTRY = new DefaultFlowEntry(DEFERRED_CLEAR_FLOW);
576
Andrea Campanella1445f7a2018-02-07 12:00:12 +0100[diff] [blame]577 //LLDP
578
579 static final DeviceId LLDP_FLOW_DEVICE = DeviceId.deviceId("LldpDevice");
580
581 private static final TrafficSelector LLDP_FLOW_SELECTOR = DefaultTrafficSelector.builder()
582 .matchInPort(PortNumber.portNumber(1))
583 .matchEthType(EthType.EtherType.LLDP.ethType().toShort())
584 .build();
585
586 private static final TrafficTreatment LLDP_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
587 .setOutput(PortNumber.CONTROLLER).build();
588 private static final FlowRule LLDP_FLOW = DefaultFlowEntry.builder().forDevice(LLDP_FLOW_DEVICE)
589 .forTable(0)
590 .withPriority(100)
591 .withSelector(LLDP_FLOW_SELECTOR)
592 .withTreatment(LLDP_FLOW_TREATMENT)
593 .fromApp(new DefaultApplicationId(0, "TestApp"))
594 .makePermanent()
595 .build();
596 static final FlowEntry LLDP_FLOW_ENTRY = new DefaultFlowEntry(LLDP_FLOW);
597
598 static final ConnectPoint LLDP_FLOW_CP = ConnectPoint.deviceConnectPoint(LLDP_FLOW_DEVICE + "/" + 1);
599
Andrea Campanella94dfb9e2018-02-27 12:36:00 +0100[diff] [blame]600 //No Buckets
601
602 static final DeviceId NO_BUCKET_DEVICE = DeviceId.deviceId("nobucket");
603
604 private static final TrafficSelector NO_BUCKET_SELECTOR = DefaultTrafficSelector.builder()
605 .matchInPort(PortNumber.portNumber(1))
606 .build();
607
608 private static final GroupId NO_BUCKET_GROUP_ID = GroupId.valueOf(1);
609
610 private static final TrafficTreatment NO_BUCKET_TREATMENT = DefaultTrafficTreatment.builder()
611 .group(NO_BUCKET_GROUP_ID)
612 .build();
613 private static final FlowRule NO_BUCKET_FLOW = DefaultFlowEntry.builder().forDevice(NO_BUCKET_DEVICE)
614 .forTable(0)
615 .withPriority(100)
616 .withSelector(NO_BUCKET_SELECTOR)
617 .withTreatment(NO_BUCKET_TREATMENT)
618 .fromApp(new DefaultApplicationId(0, "TestApp"))
619 .makePermanent()
620 .build();
621 static final FlowEntry NO_BUCKET_ENTRY = new DefaultFlowEntry(NO_BUCKET_FLOW);
622
623 private static final GroupBuckets NO_BUCKETS = new GroupBuckets(ImmutableList.of());
624
625 static final Group NO_BUCKET_GROUP =
626 new DefaultGroup(NO_BUCKET_GROUP_ID, NO_BUCKET_DEVICE, Group.Type.SELECT, NO_BUCKETS);
627
628 static final ConnectPoint NO_BUCKET_CP = ConnectPoint.deviceConnectPoint(NO_BUCKET_DEVICE + "/" + 1);
629
Andrea Campanella4906ba72018-03-01 16:22:21 +0100[diff] [blame^]630 //Dual Homing
631
632 static final DeviceId DUAL_HOME_DEVICE_1 = DeviceId.deviceId("DualHomeDevice1");
633
634 static final DeviceId DUAL_HOME_DEVICE_2 = DeviceId.deviceId("DualHomeDevice2");
635
636 static final DeviceId DUAL_HOME_DEVICE_3 = DeviceId.deviceId("DualHomeDevice3");
637
638 static final ConnectPoint DUAL_HOME_CP_1_1 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_1 + "/" + 1);
639 static final ConnectPoint DUAL_HOME_CP_1_2 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_1 + "/" + 2);
640 static final ConnectPoint DUAL_HOME_CP_1_3 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_1 + "/" + 3);
641
642 static final ConnectPoint DUAL_HOME_CP_2_1 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_2 + "/" + 1);
643 static final ConnectPoint DUAL_HOME_CP_2_2 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_2 + "/" + 2);
644
645 static final ConnectPoint DUAL_HOME_CP_3_1 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_3 + "/" + 1);
646 static final ConnectPoint DUAL_HOME_CP_3_2 = ConnectPoint.deviceConnectPoint(DUAL_HOME_DEVICE_3 + "/" + 2);
647
648
649 private static final TrafficSelector DUAL_HOME_INPUT_FLOW_SELECTOR = DefaultTrafficSelector.builder()
650 .matchInPort(PortNumber.portNumber(1))
651 .build();
652
653 private static final GroupId DUAL_HOME_GROUP_ID = GroupId.valueOf(1);
654
655 private static final TrafficTreatment DUAL_HOME_GROUP_TREATMENT = DefaultTrafficTreatment.builder()
656 .group(DUAL_HOME_GROUP_ID)
657 .build();
658 private static final FlowRule DUAL_HOME_INPUT_FLOW = DefaultFlowEntry.builder().forDevice(DUAL_HOME_DEVICE_1)
659 .forTable(0)
660 .withPriority(100)
661 .withSelector(DUAL_HOME_INPUT_FLOW_SELECTOR)
662 .withTreatment(DUAL_HOME_GROUP_TREATMENT)
663 .fromApp(new DefaultApplicationId(0, "TestApp"))
664 .makePermanent()
665 .build();
666 static final FlowEntry DUAL_HOME_FLOW_ENTRY = new DefaultFlowEntry(DUAL_HOME_INPUT_FLOW);
667
668 private static final TrafficTreatment DUAL_HOME_OUTPUT_1_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
669 .setOutput(PortNumber.portNumber(2)).build();
670 private static final TrafficTreatment DUAL_HOME_OUTPUT_2_FLOW_TREATMENT = DefaultTrafficTreatment.builder()
671 .setOutput(PortNumber.portNumber(3)).build();
672
673 private static final GroupBucket BUCKET_1_DUAL_HOMED =
674 DefaultGroupBucket.createSelectGroupBucket(DUAL_HOME_OUTPUT_1_FLOW_TREATMENT);
675
676 private static final GroupBucket BUCKET_2_DUAL_HOMED =
677 DefaultGroupBucket.createSelectGroupBucket(DUAL_HOME_OUTPUT_2_FLOW_TREATMENT);
678
679 private static final GroupBuckets BUCKETS_MULTIPLE_DUAL = new GroupBuckets(ImmutableList.of(BUCKET_1_DUAL_HOMED,
680 BUCKET_2_DUAL_HOMED));
681
682 static final Group DUAL_HOME_GROUP = new DefaultGroup(DUAL_HOME_GROUP_ID, DUAL_HOME_DEVICE_1,
683 Group.Type.SELECT, BUCKETS_MULTIPLE_DUAL);
684
685 private static final TrafficTreatment DUAL_HOME_TREATMENT = DefaultTrafficTreatment.builder()
686 .setOutput(PortNumber.portNumber("2"))
687 .build();
688 private static final FlowRule DUAL_HOME_OUT_FLOW = DefaultFlowEntry.builder().forDevice(DUAL_HOME_DEVICE_2)
689 .forTable(0)
690 .withPriority(100)
691 .withSelector(DUAL_HOME_INPUT_FLOW_SELECTOR)
692 .withTreatment(DUAL_HOME_TREATMENT)
693 .fromApp(new DefaultApplicationId(0, "TestApp"))
694 .makePermanent()
695 .build();
696 static final FlowEntry DUAL_HOME_OUT_FLOW_ENTRY = new DefaultFlowEntry(DUAL_HOME_OUT_FLOW);
697
Andrea Campanellae4084402017-12-15 15:27:31 +0100[diff] [blame]698 //helper elements
699
Andrea Campanella54923d62018-01-23 12:46:04 +0100[diff] [blame]700 static final String MASTER_1 = "Master1";
701
Andrea Campanellae4084402017-12-15 15:27:31 +0100[diff] [blame]702 static final Host H1 = new DefaultHost(ProviderId.NONE, HostId.hostId(HOST_ONE), MacAddress.valueOf(100),
703 VlanId.NONE, new HostLocation(SINGLE_FLOW_DEVICE, PortNumber.portNumber(2), 0),
704 ImmutableSet.of(IpAddress.valueOf("127.0.0.2")));
705
706 static final Host H2 = new DefaultHost(ProviderId.NONE, HostId.hostId(HOST_TWO), MacAddress.valueOf(100),
707 VlanId.NONE, new HostLocation(TOPO_FLOW_3_DEVICE, PortNumber.portNumber(2), 0),
708 ImmutableSet.of(IpAddress.valueOf("127.0.0.3")));
709
Andrea Campanella4906ba72018-03-01 16:22:21 +0100[diff] [blame^]710 static final Host DUAL_HOME_H = new DefaultHost(ProviderId.NONE, HostId.hostId(HOST_DUAL_HOMED),
711 MacAddress.valueOf(HOST_DUAL_HOMED_MAC),
712 VlanId.NONE, ImmutableSet.of(new HostLocation(DUAL_HOME_DEVICE_2, PortNumber.portNumber(2), 0),
713 new HostLocation(DUAL_HOME_DEVICE_3, PortNumber.portNumber(2), 0)),
714 ImmutableSet.of(IpAddress.valueOf("127.0.0.4")), true, DefaultAnnotations.builder().build());
715
Andrea Campanellae4084402017-12-15 15:27:31 +0100[diff] [blame]716 static final TrafficSelector PACKET_OK = DefaultTrafficSelector.builder()
717 .matchInPort(PortNumber.portNumber(1))
Andrea Campanella4401bd72018-01-18 16:54:34 +0100[diff] [blame]718 .matchEthType(EthType.EtherType.IPV4.ethType().toShort())
Andrea Campanellae4084402017-12-15 15:27:31 +0100[diff] [blame]719 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
720 .matchIPDst(IpPrefix.valueOf("127.0.0.2/32"))
Andrea Campanella94c594a2018-02-06 18:58:40 +0100[diff] [blame]721 .matchVlanId(VlanId.NONE)
Andrea Campanellae4084402017-12-15 15:27:31 +0100[diff] [blame]722 .build();
723
724 static final TrafficSelector PACKET_OK_TOPO = DefaultTrafficSelector.builder()
725 .matchInPort(PortNumber.portNumber(1))
726 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
727 .matchIPDst(IpPrefix.valueOf("127.0.0.3/32"))
728 .build();
729
Andrea Campanella54923d62018-01-23 12:46:04 +0100[diff] [blame]730 static final TrafficSelector PACKET_ARP = DefaultTrafficSelector.builder()
731 .matchInPort(PortNumber.portNumber(1))
732 .matchIPDst(IpPrefix.valueOf("255.255.255.255/32"))
733 .matchEthType(EthType.EtherType.ARP.ethType().toShort())
734 .build();
735
Andrea Campanella1445f7a2018-02-07 12:00:12 +0100[diff] [blame]736 static final TrafficSelector PACKET_LLDP = DefaultTrafficSelector.builder()
737 .matchInPort(PortNumber.portNumber(1))
738 .matchEthType(EthType.EtherType.LLDP.ethType().toShort())
739 .build();
740
Andrea Campanella4c6170a2018-01-17 16:34:51 +0100[diff] [blame]741 static final TrafficSelector PACKET_OK_MULTICAST = DefaultTrafficSelector.builder()
742 .matchInPort(PortNumber.portNumber(1))
743 .matchEthType(EthType.EtherType.IPV4.ethType().toShort())
744 .matchEthDst(MacAddress.valueOf("01:00:5e:00:00:01"))
745 .matchIPDst(IpPrefix.valueOf("224.0.0.1/32"))
746 .build();
747
Andrea Campanella4906ba72018-03-01 16:22:21 +0100[diff] [blame^]748 static final TrafficSelector PACKET_DUAL_HOME = DefaultTrafficSelector.builder()
749 .matchInPort(PortNumber.portNumber(1))
750 .matchEthType(EthType.EtherType.IPV4.ethType().toShort())
751 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
752 .matchIPDst(IpPrefix.valueOf("127.0.0.4/32"))
753 .build();
754
Andrea Campanellae4084402017-12-15 15:27:31 +0100[diff] [blame]755 static final TrafficSelector PACKET_FAIL = DefaultTrafficSelector.builder()
756 .matchInPort(PortNumber.portNumber(1))
757 .matchIPSrc(IpPrefix.valueOf("127.0.0.1/32"))
758 .matchIPDst(IpPrefix.valueOf("127.0.0.99/32"))
759 .build();
760}