Gitiles
Code Review Sign In
gerrit.opencord.org / certification / e3fefd92f7452e1635b9eb7e66a395e3622ffb09 / . / Fabric / Utilities / src / python / loxi / of14 / message.py
blob: c285bb7f9bd014d7ba2756069941e263f38ffc5a [file] [log] [blame]
Sreeju Sreedhare3fefd92019-04-02 15:57:15 -0700[diff] [blame^]1
2# Copyright 2017-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
16
17# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
18# Copyright (c) 2011, 2012 Open Networking Foundation
19# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
20# See the file LICENSE.pyloxi which should have been included in the source distribution
21
22# Automatically generated by LOXI from template module.py
23# Do not modify
24
25import struct
26import loxi
27import util
28import loxi.generic_util
29
30import sys
31ofp = sys.modules['loxi.of14']
32
33class message(loxi.OFObject):
34 subtypes = {}
35
36 version = 5
37
38 def __init__(self, type=None, xid=None):
39 if type != None:
40 self.type = type
41 else:
42 self.type = 0
43 if xid != None:
44 self.xid = xid
45 else:
46 self.xid = None
47 return
48
49 def pack(self):
50 packed = []
51 packed.append(struct.pack("!B", self.version))
52 packed.append(struct.pack("!B", self.type))
53 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
54 packed.append(struct.pack("!L", self.xid))
55 length = sum([len(x) for x in packed])
56 packed[2] = struct.pack("!H", length)
57 return ''.join(packed)
58
59 @staticmethod
60 def unpack(reader):
61 subtype, = reader.peek('B', 1)
62 subclass = message.subtypes.get(subtype)
63 if subclass:
64 return subclass.unpack(reader)
65
66 obj = message()
67 _version = reader.read("!B")[0]
68 assert(_version == 5)
69 obj.type = reader.read("!B")[0]
70 _length = reader.read("!H")[0]
71 orig_reader = reader
72 reader = orig_reader.slice(_length, 4)
73 obj.xid = reader.read("!L")[0]
74 return obj
75
76 def __eq__(self, other):
77 if type(self) != type(other): return False
78 if self.type != other.type: return False
79 if self.xid != other.xid: return False
80 return True
81
82 def pretty_print(self, q):
83 q.text("message {")
84 with q.group():
85 with q.indent(2):
86 q.breakable()
87 q.text("xid = ");
88 if self.xid != None:
89 q.text("%#x" % self.xid)
90 else:
91 q.text('None')
92 q.breakable()
93 q.text('}')
94
95
96class stats_reply(message):
97 subtypes = {}
98
99 version = 5
100 type = 19
101
102 def __init__(self, xid=None, stats_type=None, flags=None):
103 if xid != None:
104 self.xid = xid
105 else:
106 self.xid = None
107 if stats_type != None:
108 self.stats_type = stats_type
109 else:
110 self.stats_type = 0
111 if flags != None:
112 self.flags = flags
113 else:
114 self.flags = 0
115 return
116
117 def pack(self):
118 packed = []
119 packed.append(struct.pack("!B", self.version))
120 packed.append(struct.pack("!B", self.type))
121 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
122 packed.append(struct.pack("!L", self.xid))
123 packed.append(struct.pack("!H", self.stats_type))
124 packed.append(struct.pack("!H", self.flags))
125 packed.append('\x00' * 4)
126 length = sum([len(x) for x in packed])
127 packed[2] = struct.pack("!H", length)
128 return ''.join(packed)
129
130 @staticmethod
131 def unpack(reader):
132 subtype, = reader.peek('!H', 8)
133 subclass = stats_reply.subtypes.get(subtype)
134 if subclass:
135 return subclass.unpack(reader)
136
137 obj = stats_reply()
138 _version = reader.read("!B")[0]
139 assert(_version == 5)
140 _type = reader.read("!B")[0]
141 assert(_type == 19)
142 _length = reader.read("!H")[0]
143 orig_reader = reader
144 reader = orig_reader.slice(_length, 4)
145 obj.xid = reader.read("!L")[0]
146 obj.stats_type = reader.read("!H")[0]
147 obj.flags = reader.read("!H")[0]
148 reader.skip(4)
149 return obj
150
151 def __eq__(self, other):
152 if type(self) != type(other): return False
153 if self.xid != other.xid: return False
154 if self.stats_type != other.stats_type: return False
155 if self.flags != other.flags: return False
156 return True
157
158 def pretty_print(self, q):
159 q.text("stats_reply {")
160 with q.group():
161 with q.indent(2):
162 q.breakable()
163 q.text("xid = ");
164 if self.xid != None:
165 q.text("%#x" % self.xid)
166 else:
167 q.text('None')
168 q.text(","); q.breakable()
169 q.text("flags = ");
170 q.text("%#x" % self.flags)
171 q.breakable()
172 q.text('}')
173
174message.subtypes[19] = stats_reply
175
176class aggregate_stats_reply(stats_reply):
177 version = 5
178 type = 19
179 stats_type = 2
180
181 def __init__(self, xid=None, flags=None, packet_count=None, byte_count=None, flow_count=None):
182 if xid != None:
183 self.xid = xid
184 else:
185 self.xid = None
186 if flags != None:
187 self.flags = flags
188 else:
189 self.flags = 0
190 if packet_count != None:
191 self.packet_count = packet_count
192 else:
193 self.packet_count = 0
194 if byte_count != None:
195 self.byte_count = byte_count
196 else:
197 self.byte_count = 0
198 if flow_count != None:
199 self.flow_count = flow_count
200 else:
201 self.flow_count = 0
202 return
203
204 def pack(self):
205 packed = []
206 packed.append(struct.pack("!B", self.version))
207 packed.append(struct.pack("!B", self.type))
208 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
209 packed.append(struct.pack("!L", self.xid))
210 packed.append(struct.pack("!H", self.stats_type))
211 packed.append(struct.pack("!H", self.flags))
212 packed.append('\x00' * 4)
213 packed.append(struct.pack("!Q", self.packet_count))
214 packed.append(struct.pack("!Q", self.byte_count))
215 packed.append(struct.pack("!L", self.flow_count))
216 packed.append('\x00' * 4)
217 length = sum([len(x) for x in packed])
218 packed[2] = struct.pack("!H", length)
219 return ''.join(packed)
220
221 @staticmethod
222 def unpack(reader):
223 obj = aggregate_stats_reply()
224 _version = reader.read("!B")[0]
225 assert(_version == 5)
226 _type = reader.read("!B")[0]
227 assert(_type == 19)
228 _length = reader.read("!H")[0]
229 orig_reader = reader
230 reader = orig_reader.slice(_length, 4)
231 obj.xid = reader.read("!L")[0]
232 _stats_type = reader.read("!H")[0]
233 assert(_stats_type == 2)
234 obj.flags = reader.read("!H")[0]
235 reader.skip(4)
236 obj.packet_count = reader.read("!Q")[0]
237 obj.byte_count = reader.read("!Q")[0]
238 obj.flow_count = reader.read("!L")[0]
239 reader.skip(4)
240 return obj
241
242 def __eq__(self, other):
243 if type(self) != type(other): return False
244 if self.xid != other.xid: return False
245 if self.flags != other.flags: return False
246 if self.packet_count != other.packet_count: return False
247 if self.byte_count != other.byte_count: return False
248 if self.flow_count != other.flow_count: return False
249 return True
250
251 def pretty_print(self, q):
252 q.text("aggregate_stats_reply {")
253 with q.group():
254 with q.indent(2):
255 q.breakable()
256 q.text("xid = ");
257 if self.xid != None:
258 q.text("%#x" % self.xid)
259 else:
260 q.text('None')
261 q.text(","); q.breakable()
262 q.text("flags = ");
263 q.text("%#x" % self.flags)
264 q.text(","); q.breakable()
265 q.text("packet_count = ");
266 q.text("%#x" % self.packet_count)
267 q.text(","); q.breakable()
268 q.text("byte_count = ");
269 q.text("%#x" % self.byte_count)
270 q.text(","); q.breakable()
271 q.text("flow_count = ");
272 q.text("%#x" % self.flow_count)
273 q.breakable()
274 q.text('}')
275
276stats_reply.subtypes[2] = aggregate_stats_reply
277
278class stats_request(message):
279 subtypes = {}
280
281 version = 5
282 type = 18
283
284 def __init__(self, xid=None, stats_type=None, flags=None):
285 if xid != None:
286 self.xid = xid
287 else:
288 self.xid = None
289 if stats_type != None:
290 self.stats_type = stats_type
291 else:
292 self.stats_type = 0
293 if flags != None:
294 self.flags = flags
295 else:
296 self.flags = 0
297 return
298
299 def pack(self):
300 packed = []
301 packed.append(struct.pack("!B", self.version))
302 packed.append(struct.pack("!B", self.type))
303 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
304 packed.append(struct.pack("!L", self.xid))
305 packed.append(struct.pack("!H", self.stats_type))
306 packed.append(struct.pack("!H", self.flags))
307 packed.append('\x00' * 4)
308 length = sum([len(x) for x in packed])
309 packed[2] = struct.pack("!H", length)
310 return ''.join(packed)
311
312 @staticmethod
313 def unpack(reader):
314 subtype, = reader.peek('!H', 8)
315 subclass = stats_request.subtypes.get(subtype)
316 if subclass:
317 return subclass.unpack(reader)
318
319 obj = stats_request()
320 _version = reader.read("!B")[0]
321 assert(_version == 5)
322 _type = reader.read("!B")[0]
323 assert(_type == 18)
324 _length = reader.read("!H")[0]
325 orig_reader = reader
326 reader = orig_reader.slice(_length, 4)
327 obj.xid = reader.read("!L")[0]
328 obj.stats_type = reader.read("!H")[0]
329 obj.flags = reader.read("!H")[0]
330 reader.skip(4)
331 return obj
332
333 def __eq__(self, other):
334 if type(self) != type(other): return False
335 if self.xid != other.xid: return False
336 if self.stats_type != other.stats_type: return False
337 if self.flags != other.flags: return False
338 return True
339
340 def pretty_print(self, q):
341 q.text("stats_request {")
342 with q.group():
343 with q.indent(2):
344 q.breakable()
345 q.text("xid = ");
346 if self.xid != None:
347 q.text("%#x" % self.xid)
348 else:
349 q.text('None')
350 q.text(","); q.breakable()
351 q.text("flags = ");
352 q.text("%#x" % self.flags)
353 q.breakable()
354 q.text('}')
355
356message.subtypes[18] = stats_request
357
358class aggregate_stats_request(stats_request):
359 version = 5
360 type = 18
361 stats_type = 2
362
363 def __init__(self, xid=None, flags=None, table_id=None, out_port=None, out_group=None, cookie=None, cookie_mask=None, match=None):
364 if xid != None:
365 self.xid = xid
366 else:
367 self.xid = None
368 if flags != None:
369 self.flags = flags
370 else:
371 self.flags = 0
372 if table_id != None:
373 self.table_id = table_id
374 else:
375 self.table_id = 0
376 if out_port != None:
377 self.out_port = out_port
378 else:
379 self.out_port = 0
380 if out_group != None:
381 self.out_group = out_group
382 else:
383 self.out_group = 0
384 if cookie != None:
385 self.cookie = cookie
386 else:
387 self.cookie = 0
388 if cookie_mask != None:
389 self.cookie_mask = cookie_mask
390 else:
391 self.cookie_mask = 0
392 if match != None:
393 self.match = match
394 else:
395 self.match = ofp.match()
396 return
397
398 def pack(self):
399 packed = []
400 packed.append(struct.pack("!B", self.version))
401 packed.append(struct.pack("!B", self.type))
402 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
403 packed.append(struct.pack("!L", self.xid))
404 packed.append(struct.pack("!H", self.stats_type))
405 packed.append(struct.pack("!H", self.flags))
406 packed.append('\x00' * 4)
407 packed.append(struct.pack("!B", self.table_id))
408 packed.append('\x00' * 3)
409 packed.append(util.pack_port_no(self.out_port))
410 packed.append(struct.pack("!L", self.out_group))
411 packed.append('\x00' * 4)
412 packed.append(struct.pack("!Q", self.cookie))
413 packed.append(struct.pack("!Q", self.cookie_mask))
414 packed.append(self.match.pack())
415 length = sum([len(x) for x in packed])
416 packed[2] = struct.pack("!H", length)
417 return ''.join(packed)
418
419 @staticmethod
420 def unpack(reader):
421 obj = aggregate_stats_request()
422 _version = reader.read("!B")[0]
423 assert(_version == 5)
424 _type = reader.read("!B")[0]
425 assert(_type == 18)
426 _length = reader.read("!H")[0]
427 orig_reader = reader
428 reader = orig_reader.slice(_length, 4)
429 obj.xid = reader.read("!L")[0]
430 _stats_type = reader.read("!H")[0]
431 assert(_stats_type == 2)
432 obj.flags = reader.read("!H")[0]
433 reader.skip(4)
434 obj.table_id = reader.read("!B")[0]
435 reader.skip(3)
436 obj.out_port = util.unpack_port_no(reader)
437 obj.out_group = reader.read("!L")[0]
438 reader.skip(4)
439 obj.cookie = reader.read("!Q")[0]
440 obj.cookie_mask = reader.read("!Q")[0]
441 obj.match = ofp.match.unpack(reader)
442 return obj
443
444 def __eq__(self, other):
445 if type(self) != type(other): return False
446 if self.xid != other.xid: return False
447 if self.flags != other.flags: return False
448 if self.table_id != other.table_id: return False
449 if self.out_port != other.out_port: return False
450 if self.out_group != other.out_group: return False
451 if self.cookie != other.cookie: return False
452 if self.cookie_mask != other.cookie_mask: return False
453 if self.match != other.match: return False
454 return True
455
456 def pretty_print(self, q):
457 q.text("aggregate_stats_request {")
458 with q.group():
459 with q.indent(2):
460 q.breakable()
461 q.text("xid = ");
462 if self.xid != None:
463 q.text("%#x" % self.xid)
464 else:
465 q.text('None')
466 q.text(","); q.breakable()
467 q.text("flags = ");
468 q.text("%#x" % self.flags)
469 q.text(","); q.breakable()
470 q.text("table_id = ");
471 q.text("%#x" % self.table_id)
472 q.text(","); q.breakable()
473 q.text("out_port = ");
474 q.text(util.pretty_port(self.out_port))
475 q.text(","); q.breakable()
476 q.text("out_group = ");
477 q.text("%#x" % self.out_group)
478 q.text(","); q.breakable()
479 q.text("cookie = ");
480 q.text("%#x" % self.cookie)
481 q.text(","); q.breakable()
482 q.text("cookie_mask = ");
483 q.text("%#x" % self.cookie_mask)
484 q.text(","); q.breakable()
485 q.text("match = ");
486 q.pp(self.match)
487 q.breakable()
488 q.text('}')
489
490stats_request.subtypes[2] = aggregate_stats_request
491
492class error_msg(message):
493 subtypes = {}
494
495 version = 5
496 type = 1
497
498 def __init__(self, xid=None, err_type=None):
499 if xid != None:
500 self.xid = xid
501 else:
502 self.xid = None
503 if err_type != None:
504 self.err_type = err_type
505 else:
506 self.err_type = 0
507 return
508
509 def pack(self):
510 packed = []
511 packed.append(struct.pack("!B", self.version))
512 packed.append(struct.pack("!B", self.type))
513 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
514 packed.append(struct.pack("!L", self.xid))
515 packed.append(struct.pack("!H", self.err_type))
516 length = sum([len(x) for x in packed])
517 packed[2] = struct.pack("!H", length)
518 return ''.join(packed)
519
520 @staticmethod
521 def unpack(reader):
522 subtype, = reader.peek('!H', 8)
523 subclass = error_msg.subtypes.get(subtype)
524 if subclass:
525 return subclass.unpack(reader)
526
527 obj = error_msg()
528 _version = reader.read("!B")[0]
529 assert(_version == 5)
530 _type = reader.read("!B")[0]
531 assert(_type == 1)
532 _length = reader.read("!H")[0]
533 orig_reader = reader
534 reader = orig_reader.slice(_length, 4)
535 obj.xid = reader.read("!L")[0]
536 obj.err_type = reader.read("!H")[0]
537 return obj
538
539 def __eq__(self, other):
540 if type(self) != type(other): return False
541 if self.xid != other.xid: return False
542 if self.err_type != other.err_type: return False
543 return True
544
545 def pretty_print(self, q):
546 q.text("error_msg {")
547 with q.group():
548 with q.indent(2):
549 q.breakable()
550 q.text("xid = ");
551 if self.xid != None:
552 q.text("%#x" % self.xid)
553 else:
554 q.text('None')
555 q.breakable()
556 q.text('}')
557
558message.subtypes[1] = error_msg
559
560class async_config_failed_error_msg(error_msg):
561 version = 5
562 type = 1
563 err_type = 15
564
565 def __init__(self, xid=None, code=None, data=None):
566 if xid != None:
567 self.xid = xid
568 else:
569 self.xid = None
570 if code != None:
571 self.code = code
572 else:
573 self.code = 0
574 if data != None:
575 self.data = data
576 else:
577 self.data = ''
578 return
579
580 def pack(self):
581 packed = []
582 packed.append(struct.pack("!B", self.version))
583 packed.append(struct.pack("!B", self.type))
584 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
585 packed.append(struct.pack("!L", self.xid))
586 packed.append(struct.pack("!H", self.err_type))
587 packed.append(struct.pack("!H", self.code))
588 packed.append(self.data)
589 length = sum([len(x) for x in packed])
590 packed[2] = struct.pack("!H", length)
591 return ''.join(packed)
592
593 @staticmethod
594 def unpack(reader):
595 obj = async_config_failed_error_msg()
596 _version = reader.read("!B")[0]
597 assert(_version == 5)
598 _type = reader.read("!B")[0]
599 assert(_type == 1)
600 _length = reader.read("!H")[0]
601 orig_reader = reader
602 reader = orig_reader.slice(_length, 4)
603 obj.xid = reader.read("!L")[0]
604 _err_type = reader.read("!H")[0]
605 assert(_err_type == 15)
606 obj.code = reader.read("!H")[0]
607 obj.data = str(reader.read_all())
608 return obj
609
610 def __eq__(self, other):
611 if type(self) != type(other): return False
612 if self.xid != other.xid: return False
613 if self.code != other.code: return False
614 if self.data != other.data: return False
615 return True
616
617 def pretty_print(self, q):
618 q.text("async_config_failed_error_msg {")
619 with q.group():
620 with q.indent(2):
621 q.breakable()
622 q.text("xid = ");
623 if self.xid != None:
624 q.text("%#x" % self.xid)
625 else:
626 q.text('None')
627 q.text(","); q.breakable()
628 q.text("code = ");
629 q.text("%#x" % self.code)
630 q.text(","); q.breakable()
631 q.text("data = ");
632 q.pp(self.data)
633 q.breakable()
634 q.text('}')
635
636error_msg.subtypes[15] = async_config_failed_error_msg
637
638class async_get_reply(message):
639 version = 5
640 type = 27
641
642 def __init__(self, xid=None, properties=None):
643 if xid != None:
644 self.xid = xid
645 else:
646 self.xid = None
647 if properties != None:
648 self.properties = properties
649 else:
650 self.properties = []
651 return
652
653 def pack(self):
654 packed = []
655 packed.append(struct.pack("!B", self.version))
656 packed.append(struct.pack("!B", self.type))
657 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
658 packed.append(struct.pack("!L", self.xid))
659 packed.append(loxi.generic_util.pack_list(self.properties))
660 length = sum([len(x) for x in packed])
661 packed[2] = struct.pack("!H", length)
662 return ''.join(packed)
663
664 @staticmethod
665 def unpack(reader):
666 obj = async_get_reply()
667 _version = reader.read("!B")[0]
668 assert(_version == 5)
669 _type = reader.read("!B")[0]
670 assert(_type == 27)
671 _length = reader.read("!H")[0]
672 orig_reader = reader
673 reader = orig_reader.slice(_length, 4)
674 obj.xid = reader.read("!L")[0]
675 obj.properties = loxi.generic_util.unpack_list(reader, ofp.async_config_prop.async_config_prop.unpack)
676 return obj
677
678 def __eq__(self, other):
679 if type(self) != type(other): return False
680 if self.xid != other.xid: return False
681 if self.properties != other.properties: return False
682 return True
683
684 def pretty_print(self, q):
685 q.text("async_get_reply {")
686 with q.group():
687 with q.indent(2):
688 q.breakable()
689 q.text("xid = ");
690 if self.xid != None:
691 q.text("%#x" % self.xid)
692 else:
693 q.text('None')
694 q.text(","); q.breakable()
695 q.text("properties = ");
696 q.pp(self.properties)
697 q.breakable()
698 q.text('}')
699
700message.subtypes[27] = async_get_reply
701
702class async_get_request(message):
703 version = 5
704 type = 26
705
706 def __init__(self, xid=None, properties=None):
707 if xid != None:
708 self.xid = xid
709 else:
710 self.xid = None
711 if properties != None:
712 self.properties = properties
713 else:
714 self.properties = []
715 return
716
717 def pack(self):
718 packed = []
719 packed.append(struct.pack("!B", self.version))
720 packed.append(struct.pack("!B", self.type))
721 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
722 packed.append(struct.pack("!L", self.xid))
723 packed.append(loxi.generic_util.pack_list(self.properties))
724 length = sum([len(x) for x in packed])
725 packed[2] = struct.pack("!H", length)
726 return ''.join(packed)
727
728 @staticmethod
729 def unpack(reader):
730 obj = async_get_request()
731 _version = reader.read("!B")[0]
732 assert(_version == 5)
733 _type = reader.read("!B")[0]
734 assert(_type == 26)
735 _length = reader.read("!H")[0]
736 orig_reader = reader
737 reader = orig_reader.slice(_length, 4)
738 obj.xid = reader.read("!L")[0]
739 obj.properties = loxi.generic_util.unpack_list(reader, ofp.async_config_prop.async_config_prop.unpack)
740 return obj
741
742 def __eq__(self, other):
743 if type(self) != type(other): return False
744 if self.xid != other.xid: return False
745 if self.properties != other.properties: return False
746 return True
747
748 def pretty_print(self, q):
749 q.text("async_get_request {")
750 with q.group():
751 with q.indent(2):
752 q.breakable()
753 q.text("xid = ");
754 if self.xid != None:
755 q.text("%#x" % self.xid)
756 else:
757 q.text('None')
758 q.text(","); q.breakable()
759 q.text("properties = ");
760 q.pp(self.properties)
761 q.breakable()
762 q.text('}')
763
764message.subtypes[26] = async_get_request
765
766class async_set(message):
767 version = 5
768 type = 28
769
770 def __init__(self, xid=None, properties=None):
771 if xid != None:
772 self.xid = xid
773 else:
774 self.xid = None
775 if properties != None:
776 self.properties = properties
777 else:
778 self.properties = []
779 return
780
781 def pack(self):
782 packed = []
783 packed.append(struct.pack("!B", self.version))
784 packed.append(struct.pack("!B", self.type))
785 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
786 packed.append(struct.pack("!L", self.xid))
787 packed.append(loxi.generic_util.pack_list(self.properties))
788 length = sum([len(x) for x in packed])
789 packed[2] = struct.pack("!H", length)
790 return ''.join(packed)
791
792 @staticmethod
793 def unpack(reader):
794 obj = async_set()
795 _version = reader.read("!B")[0]
796 assert(_version == 5)
797 _type = reader.read("!B")[0]
798 assert(_type == 28)
799 _length = reader.read("!H")[0]
800 orig_reader = reader
801 reader = orig_reader.slice(_length, 4)
802 obj.xid = reader.read("!L")[0]
803 obj.properties = loxi.generic_util.unpack_list(reader, ofp.async_config_prop.async_config_prop.unpack)
804 return obj
805
806 def __eq__(self, other):
807 if type(self) != type(other): return False
808 if self.xid != other.xid: return False
809 if self.properties != other.properties: return False
810 return True
811
812 def pretty_print(self, q):
813 q.text("async_set {")
814 with q.group():
815 with q.indent(2):
816 q.breakable()
817 q.text("xid = ");
818 if self.xid != None:
819 q.text("%#x" % self.xid)
820 else:
821 q.text('None')
822 q.text(","); q.breakable()
823 q.text("properties = ");
824 q.pp(self.properties)
825 q.breakable()
826 q.text('}')
827
828message.subtypes[28] = async_set
829
830class bad_action_error_msg(error_msg):
831 version = 5
832 type = 1
833 err_type = 2
834
835 def __init__(self, xid=None, code=None, data=None):
836 if xid != None:
837 self.xid = xid
838 else:
839 self.xid = None
840 if code != None:
841 self.code = code
842 else:
843 self.code = 0
844 if data != None:
845 self.data = data
846 else:
847 self.data = ''
848 return
849
850 def pack(self):
851 packed = []
852 packed.append(struct.pack("!B", self.version))
853 packed.append(struct.pack("!B", self.type))
854 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
855 packed.append(struct.pack("!L", self.xid))
856 packed.append(struct.pack("!H", self.err_type))
857 packed.append(struct.pack("!H", self.code))
858 packed.append(self.data)
859 length = sum([len(x) for x in packed])
860 packed[2] = struct.pack("!H", length)
861 return ''.join(packed)
862
863 @staticmethod
864 def unpack(reader):
865 obj = bad_action_error_msg()
866 _version = reader.read("!B")[0]
867 assert(_version == 5)
868 _type = reader.read("!B")[0]
869 assert(_type == 1)
870 _length = reader.read("!H")[0]
871 orig_reader = reader
872 reader = orig_reader.slice(_length, 4)
873 obj.xid = reader.read("!L")[0]
874 _err_type = reader.read("!H")[0]
875 assert(_err_type == 2)
876 obj.code = reader.read("!H")[0]
877 obj.data = str(reader.read_all())
878 return obj
879
880 def __eq__(self, other):
881 if type(self) != type(other): return False
882 if self.xid != other.xid: return False
883 if self.code != other.code: return False
884 if self.data != other.data: return False
885 return True
886
887 def pretty_print(self, q):
888 q.text("bad_action_error_msg {")
889 with q.group():
890 with q.indent(2):
891 q.breakable()
892 q.text("xid = ");
893 if self.xid != None:
894 q.text("%#x" % self.xid)
895 else:
896 q.text('None')
897 q.text(","); q.breakable()
898 q.text("code = ");
899 q.text("%#x" % self.code)
900 q.text(","); q.breakable()
901 q.text("data = ");
902 q.pp(self.data)
903 q.breakable()
904 q.text('}')
905
906error_msg.subtypes[2] = bad_action_error_msg
907
908class bad_instruction_error_msg(error_msg):
909 version = 5
910 type = 1
911 err_type = 3
912
913 def __init__(self, xid=None, code=None, data=None):
914 if xid != None:
915 self.xid = xid
916 else:
917 self.xid = None
918 if code != None:
919 self.code = code
920 else:
921 self.code = 0
922 if data != None:
923 self.data = data
924 else:
925 self.data = ''
926 return
927
928 def pack(self):
929 packed = []
930 packed.append(struct.pack("!B", self.version))
931 packed.append(struct.pack("!B", self.type))
932 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
933 packed.append(struct.pack("!L", self.xid))
934 packed.append(struct.pack("!H", self.err_type))
935 packed.append(struct.pack("!H", self.code))
936 packed.append(self.data)
937 length = sum([len(x) for x in packed])
938 packed[2] = struct.pack("!H", length)
939 return ''.join(packed)
940
941 @staticmethod
942 def unpack(reader):
943 obj = bad_instruction_error_msg()
944 _version = reader.read("!B")[0]
945 assert(_version == 5)
946 _type = reader.read("!B")[0]
947 assert(_type == 1)
948 _length = reader.read("!H")[0]
949 orig_reader = reader
950 reader = orig_reader.slice(_length, 4)
951 obj.xid = reader.read("!L")[0]
952 _err_type = reader.read("!H")[0]
953 assert(_err_type == 3)
954 obj.code = reader.read("!H")[0]
955 obj.data = str(reader.read_all())
956 return obj
957
958 def __eq__(self, other):
959 if type(self) != type(other): return False
960 if self.xid != other.xid: return False
961 if self.code != other.code: return False
962 if self.data != other.data: return False
963 return True
964
965 def pretty_print(self, q):
966 q.text("bad_instruction_error_msg {")
967 with q.group():
968 with q.indent(2):
969 q.breakable()
970 q.text("xid = ");
971 if self.xid != None:
972 q.text("%#x" % self.xid)
973 else:
974 q.text('None')
975 q.text(","); q.breakable()
976 q.text("code = ");
977 q.text("%#x" % self.code)
978 q.text(","); q.breakable()
979 q.text("data = ");
980 q.pp(self.data)
981 q.breakable()
982 q.text('}')
983
984error_msg.subtypes[3] = bad_instruction_error_msg
985
986class bad_match_error_msg(error_msg):
987 version = 5
988 type = 1
989 err_type = 4
990
991 def __init__(self, xid=None, code=None, data=None):
992 if xid != None:
993 self.xid = xid
994 else:
995 self.xid = None
996 if code != None:
997 self.code = code
998 else:
999 self.code = 0
1000 if data != None:
1001 self.data = data
1002 else:
1003 self.data = ''
1004 return
1005
1006 def pack(self):
1007 packed = []
1008 packed.append(struct.pack("!B", self.version))
1009 packed.append(struct.pack("!B", self.type))
1010 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1011 packed.append(struct.pack("!L", self.xid))
1012 packed.append(struct.pack("!H", self.err_type))
1013 packed.append(struct.pack("!H", self.code))
1014 packed.append(self.data)
1015 length = sum([len(x) for x in packed])
1016 packed[2] = struct.pack("!H", length)
1017 return ''.join(packed)
1018
1019 @staticmethod
1020 def unpack(reader):
1021 obj = bad_match_error_msg()
1022 _version = reader.read("!B")[0]
1023 assert(_version == 5)
1024 _type = reader.read("!B")[0]
1025 assert(_type == 1)
1026 _length = reader.read("!H")[0]
1027 orig_reader = reader
1028 reader = orig_reader.slice(_length, 4)
1029 obj.xid = reader.read("!L")[0]
1030 _err_type = reader.read("!H")[0]
1031 assert(_err_type == 4)
1032 obj.code = reader.read("!H")[0]
1033 obj.data = str(reader.read_all())
1034 return obj
1035
1036 def __eq__(self, other):
1037 if type(self) != type(other): return False
1038 if self.xid != other.xid: return False
1039 if self.code != other.code: return False
1040 if self.data != other.data: return False
1041 return True
1042
1043 def pretty_print(self, q):
1044 q.text("bad_match_error_msg {")
1045 with q.group():
1046 with q.indent(2):
1047 q.breakable()
1048 q.text("xid = ");
1049 if self.xid != None:
1050 q.text("%#x" % self.xid)
1051 else:
1052 q.text('None')
1053 q.text(","); q.breakable()
1054 q.text("code = ");
1055 q.text("%#x" % self.code)
1056 q.text(","); q.breakable()
1057 q.text("data = ");
1058 q.pp(self.data)
1059 q.breakable()
1060 q.text('}')
1061
1062error_msg.subtypes[4] = bad_match_error_msg
1063
1064class bad_property_error_msg(error_msg):
1065 version = 5
1066 type = 1
1067 err_type = 14
1068
1069 def __init__(self, xid=None, code=None, data=None):
1070 if xid != None:
1071 self.xid = xid
1072 else:
1073 self.xid = None
1074 if code != None:
1075 self.code = code
1076 else:
1077 self.code = 0
1078 if data != None:
1079 self.data = data
1080 else:
1081 self.data = ''
1082 return
1083
1084 def pack(self):
1085 packed = []
1086 packed.append(struct.pack("!B", self.version))
1087 packed.append(struct.pack("!B", self.type))
1088 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1089 packed.append(struct.pack("!L", self.xid))
1090 packed.append(struct.pack("!H", self.err_type))
1091 packed.append(struct.pack("!H", self.code))
1092 packed.append(self.data)
1093 length = sum([len(x) for x in packed])
1094 packed[2] = struct.pack("!H", length)
1095 return ''.join(packed)
1096
1097 @staticmethod
1098 def unpack(reader):
1099 obj = bad_property_error_msg()
1100 _version = reader.read("!B")[0]
1101 assert(_version == 5)
1102 _type = reader.read("!B")[0]
1103 assert(_type == 1)
1104 _length = reader.read("!H")[0]
1105 orig_reader = reader
1106 reader = orig_reader.slice(_length, 4)
1107 obj.xid = reader.read("!L")[0]
1108 _err_type = reader.read("!H")[0]
1109 assert(_err_type == 14)
1110 obj.code = reader.read("!H")[0]
1111 obj.data = str(reader.read_all())
1112 return obj
1113
1114 def __eq__(self, other):
1115 if type(self) != type(other): return False
1116 if self.xid != other.xid: return False
1117 if self.code != other.code: return False
1118 if self.data != other.data: return False
1119 return True
1120
1121 def pretty_print(self, q):
1122 q.text("bad_property_error_msg {")
1123 with q.group():
1124 with q.indent(2):
1125 q.breakable()
1126 q.text("xid = ");
1127 if self.xid != None:
1128 q.text("%#x" % self.xid)
1129 else:
1130 q.text('None')
1131 q.text(","); q.breakable()
1132 q.text("code = ");
1133 q.text("%#x" % self.code)
1134 q.text(","); q.breakable()
1135 q.text("data = ");
1136 q.pp(self.data)
1137 q.breakable()
1138 q.text('}')
1139
1140error_msg.subtypes[14] = bad_property_error_msg
1141
1142class bad_request_error_msg(error_msg):
1143 version = 5
1144 type = 1
1145 err_type = 1
1146
1147 def __init__(self, xid=None, code=None, data=None):
1148 if xid != None:
1149 self.xid = xid
1150 else:
1151 self.xid = None
1152 if code != None:
1153 self.code = code
1154 else:
1155 self.code = 0
1156 if data != None:
1157 self.data = data
1158 else:
1159 self.data = ''
1160 return
1161
1162 def pack(self):
1163 packed = []
1164 packed.append(struct.pack("!B", self.version))
1165 packed.append(struct.pack("!B", self.type))
1166 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1167 packed.append(struct.pack("!L", self.xid))
1168 packed.append(struct.pack("!H", self.err_type))
1169 packed.append(struct.pack("!H", self.code))
1170 packed.append(self.data)
1171 length = sum([len(x) for x in packed])
1172 packed[2] = struct.pack("!H", length)
1173 return ''.join(packed)
1174
1175 @staticmethod
1176 def unpack(reader):
1177 obj = bad_request_error_msg()
1178 _version = reader.read("!B")[0]
1179 assert(_version == 5)
1180 _type = reader.read("!B")[0]
1181 assert(_type == 1)
1182 _length = reader.read("!H")[0]
1183 orig_reader = reader
1184 reader = orig_reader.slice(_length, 4)
1185 obj.xid = reader.read("!L")[0]
1186 _err_type = reader.read("!H")[0]
1187 assert(_err_type == 1)
1188 obj.code = reader.read("!H")[0]
1189 obj.data = str(reader.read_all())
1190 return obj
1191
1192 def __eq__(self, other):
1193 if type(self) != type(other): return False
1194 if self.xid != other.xid: return False
1195 if self.code != other.code: return False
1196 if self.data != other.data: return False
1197 return True
1198
1199 def pretty_print(self, q):
1200 q.text("bad_request_error_msg {")
1201 with q.group():
1202 with q.indent(2):
1203 q.breakable()
1204 q.text("xid = ");
1205 if self.xid != None:
1206 q.text("%#x" % self.xid)
1207 else:
1208 q.text('None')
1209 q.text(","); q.breakable()
1210 q.text("code = ");
1211 q.text("%#x" % self.code)
1212 q.text(","); q.breakable()
1213 q.text("data = ");
1214 q.pp(self.data)
1215 q.breakable()
1216 q.text('}')
1217
1218error_msg.subtypes[1] = bad_request_error_msg
1219
1220class barrier_reply(message):
1221 version = 5
1222 type = 21
1223
1224 def __init__(self, xid=None):
1225 if xid != None:
1226 self.xid = xid
1227 else:
1228 self.xid = None
1229 return
1230
1231 def pack(self):
1232 packed = []
1233 packed.append(struct.pack("!B", self.version))
1234 packed.append(struct.pack("!B", self.type))
1235 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1236 packed.append(struct.pack("!L", self.xid))
1237 length = sum([len(x) for x in packed])
1238 packed[2] = struct.pack("!H", length)
1239 return ''.join(packed)
1240
1241 @staticmethod
1242 def unpack(reader):
1243 obj = barrier_reply()
1244 _version = reader.read("!B")[0]
1245 assert(_version == 5)
1246 _type = reader.read("!B")[0]
1247 assert(_type == 21)
1248 _length = reader.read("!H")[0]
1249 orig_reader = reader
1250 reader = orig_reader.slice(_length, 4)
1251 obj.xid = reader.read("!L")[0]
1252 return obj
1253
1254 def __eq__(self, other):
1255 if type(self) != type(other): return False
1256 if self.xid != other.xid: return False
1257 return True
1258
1259 def pretty_print(self, q):
1260 q.text("barrier_reply {")
1261 with q.group():
1262 with q.indent(2):
1263 q.breakable()
1264 q.text("xid = ");
1265 if self.xid != None:
1266 q.text("%#x" % self.xid)
1267 else:
1268 q.text('None')
1269 q.breakable()
1270 q.text('}')
1271
1272message.subtypes[21] = barrier_reply
1273
1274class barrier_request(message):
1275 version = 5
1276 type = 20
1277
1278 def __init__(self, xid=None):
1279 if xid != None:
1280 self.xid = xid
1281 else:
1282 self.xid = None
1283 return
1284
1285 def pack(self):
1286 packed = []
1287 packed.append(struct.pack("!B", self.version))
1288 packed.append(struct.pack("!B", self.type))
1289 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1290 packed.append(struct.pack("!L", self.xid))
1291 length = sum([len(x) for x in packed])
1292 packed[2] = struct.pack("!H", length)
1293 return ''.join(packed)
1294
1295 @staticmethod
1296 def unpack(reader):
1297 obj = barrier_request()
1298 _version = reader.read("!B")[0]
1299 assert(_version == 5)
1300 _type = reader.read("!B")[0]
1301 assert(_type == 20)
1302 _length = reader.read("!H")[0]
1303 orig_reader = reader
1304 reader = orig_reader.slice(_length, 4)
1305 obj.xid = reader.read("!L")[0]
1306 return obj
1307
1308 def __eq__(self, other):
1309 if type(self) != type(other): return False
1310 if self.xid != other.xid: return False
1311 return True
1312
1313 def pretty_print(self, q):
1314 q.text("barrier_request {")
1315 with q.group():
1316 with q.indent(2):
1317 q.breakable()
1318 q.text("xid = ");
1319 if self.xid != None:
1320 q.text("%#x" % self.xid)
1321 else:
1322 q.text('None')
1323 q.breakable()
1324 q.text('}')
1325
1326message.subtypes[20] = barrier_request
1327
1328class experimenter(message):
1329 subtypes = {}
1330
1331 version = 5
1332 type = 4
1333
1334 def __init__(self, xid=None, experimenter=None, subtype=None, data=None):
1335 if xid != None:
1336 self.xid = xid
1337 else:
1338 self.xid = None
1339 if experimenter != None:
1340 self.experimenter = experimenter
1341 else:
1342 self.experimenter = 0
1343 if subtype != None:
1344 self.subtype = subtype
1345 else:
1346 self.subtype = 0
1347 if data != None:
1348 self.data = data
1349 else:
1350 self.data = ''
1351 return
1352
1353 def pack(self):
1354 packed = []
1355 packed.append(struct.pack("!B", self.version))
1356 packed.append(struct.pack("!B", self.type))
1357 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1358 packed.append(struct.pack("!L", self.xid))
1359 packed.append(struct.pack("!L", self.experimenter))
1360 packed.append(struct.pack("!L", self.subtype))
1361 packed.append(self.data)
1362 length = sum([len(x) for x in packed])
1363 packed[2] = struct.pack("!H", length)
1364 return ''.join(packed)
1365
1366 @staticmethod
1367 def unpack(reader):
1368 subtype, = reader.peek('!L', 8)
1369 subclass = experimenter.subtypes.get(subtype)
1370 if subclass:
1371 return subclass.unpack(reader)
1372
1373 obj = experimenter()
1374 _version = reader.read("!B")[0]
1375 assert(_version == 5)
1376 _type = reader.read("!B")[0]
1377 assert(_type == 4)
1378 _length = reader.read("!H")[0]
1379 orig_reader = reader
1380 reader = orig_reader.slice(_length, 4)
1381 obj.xid = reader.read("!L")[0]
1382 obj.experimenter = reader.read("!L")[0]
1383 obj.subtype = reader.read("!L")[0]
1384 obj.data = str(reader.read_all())
1385 return obj
1386
1387 def __eq__(self, other):
1388 if type(self) != type(other): return False
1389 if self.xid != other.xid: return False
1390 if self.experimenter != other.experimenter: return False
1391 if self.subtype != other.subtype: return False
1392 if self.data != other.data: return False
1393 return True
1394
1395 def pretty_print(self, q):
1396 q.text("experimenter {")
1397 with q.group():
1398 with q.indent(2):
1399 q.breakable()
1400 q.text("xid = ");
1401 if self.xid != None:
1402 q.text("%#x" % self.xid)
1403 else:
1404 q.text('None')
1405 q.text(","); q.breakable()
1406 q.text("subtype = ");
1407 q.text("%#x" % self.subtype)
1408 q.text(","); q.breakable()
1409 q.text("data = ");
1410 q.pp(self.data)
1411 q.breakable()
1412 q.text('}')
1413
1414message.subtypes[4] = experimenter
1415
1416class bsn_header(experimenter):
1417 subtypes = {}
1418
1419 version = 5
1420 type = 4
1421 experimenter = 6035143
1422
1423 def __init__(self, xid=None, subtype=None):
1424 if xid != None:
1425 self.xid = xid
1426 else:
1427 self.xid = None
1428 if subtype != None:
1429 self.subtype = subtype
1430 else:
1431 self.subtype = 0
1432 return
1433
1434 def pack(self):
1435 packed = []
1436 packed.append(struct.pack("!B", self.version))
1437 packed.append(struct.pack("!B", self.type))
1438 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1439 packed.append(struct.pack("!L", self.xid))
1440 packed.append(struct.pack("!L", self.experimenter))
1441 packed.append(struct.pack("!L", self.subtype))
1442 length = sum([len(x) for x in packed])
1443 packed[2] = struct.pack("!H", length)
1444 return ''.join(packed)
1445
1446 @staticmethod
1447 def unpack(reader):
1448 subtype, = reader.peek('!L', 12)
1449 subclass = bsn_header.subtypes.get(subtype)
1450 if subclass:
1451 return subclass.unpack(reader)
1452
1453 obj = bsn_header()
1454 _version = reader.read("!B")[0]
1455 assert(_version == 5)
1456 _type = reader.read("!B")[0]
1457 assert(_type == 4)
1458 _length = reader.read("!H")[0]
1459 orig_reader = reader
1460 reader = orig_reader.slice(_length, 4)
1461 obj.xid = reader.read("!L")[0]
1462 _experimenter = reader.read("!L")[0]
1463 assert(_experimenter == 6035143)
1464 obj.subtype = reader.read("!L")[0]
1465 return obj
1466
1467 def __eq__(self, other):
1468 if type(self) != type(other): return False
1469 if self.xid != other.xid: return False
1470 if self.subtype != other.subtype: return False
1471 return True
1472
1473 def pretty_print(self, q):
1474 q.text("bsn_header {")
1475 with q.group():
1476 with q.indent(2):
1477 q.breakable()
1478 q.text("xid = ");
1479 if self.xid != None:
1480 q.text("%#x" % self.xid)
1481 else:
1482 q.text('None')
1483 q.breakable()
1484 q.text('}')
1485
1486experimenter.subtypes[6035143] = bsn_header
1487
1488class bsn_arp_idle(bsn_header):
1489 version = 5
1490 type = 4
1491 experimenter = 6035143
1492 subtype = 60
1493
1494 def __init__(self, xid=None, vlan_vid=None, ipv4_addr=None):
1495 if xid != None:
1496 self.xid = xid
1497 else:
1498 self.xid = None
1499 if vlan_vid != None:
1500 self.vlan_vid = vlan_vid
1501 else:
1502 self.vlan_vid = 0
1503 if ipv4_addr != None:
1504 self.ipv4_addr = ipv4_addr
1505 else:
1506 self.ipv4_addr = 0
1507 return
1508
1509 def pack(self):
1510 packed = []
1511 packed.append(struct.pack("!B", self.version))
1512 packed.append(struct.pack("!B", self.type))
1513 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1514 packed.append(struct.pack("!L", self.xid))
1515 packed.append(struct.pack("!L", self.experimenter))
1516 packed.append(struct.pack("!L", self.subtype))
1517 packed.append(struct.pack("!H", self.vlan_vid))
1518 packed.append('\x00' * 2)
1519 packed.append(struct.pack("!L", self.ipv4_addr))
1520 length = sum([len(x) for x in packed])
1521 packed[2] = struct.pack("!H", length)
1522 return ''.join(packed)
1523
1524 @staticmethod
1525 def unpack(reader):
1526 obj = bsn_arp_idle()
1527 _version = reader.read("!B")[0]
1528 assert(_version == 5)
1529 _type = reader.read("!B")[0]
1530 assert(_type == 4)
1531 _length = reader.read("!H")[0]
1532 orig_reader = reader
1533 reader = orig_reader.slice(_length, 4)
1534 obj.xid = reader.read("!L")[0]
1535 _experimenter = reader.read("!L")[0]
1536 assert(_experimenter == 6035143)
1537 _subtype = reader.read("!L")[0]
1538 assert(_subtype == 60)
1539 obj.vlan_vid = reader.read("!H")[0]
1540 reader.skip(2)
1541 obj.ipv4_addr = reader.read("!L")[0]
1542 return obj
1543
1544 def __eq__(self, other):
1545 if type(self) != type(other): return False
1546 if self.xid != other.xid: return False
1547 if self.vlan_vid != other.vlan_vid: return False
1548 if self.ipv4_addr != other.ipv4_addr: return False
1549 return True
1550
1551 def pretty_print(self, q):
1552 q.text("bsn_arp_idle {")
1553 with q.group():
1554 with q.indent(2):
1555 q.breakable()
1556 q.text("xid = ");
1557 if self.xid != None:
1558 q.text("%#x" % self.xid)
1559 else:
1560 q.text('None')
1561 q.text(","); q.breakable()
1562 q.text("vlan_vid = ");
1563 q.text("%#x" % self.vlan_vid)
1564 q.text(","); q.breakable()
1565 q.text("ipv4_addr = ");
1566 q.text(util.pretty_ipv4(self.ipv4_addr))
1567 q.breakable()
1568 q.text('}')
1569
1570bsn_header.subtypes[60] = bsn_arp_idle
1571
1572class bsn_bw_clear_data_reply(bsn_header):
1573 version = 5
1574 type = 4
1575 experimenter = 6035143
1576 subtype = 22
1577
1578 def __init__(self, xid=None, status=None):
1579 if xid != None:
1580 self.xid = xid
1581 else:
1582 self.xid = None
1583 if status != None:
1584 self.status = status
1585 else:
1586 self.status = 0
1587 return
1588
1589 def pack(self):
1590 packed = []
1591 packed.append(struct.pack("!B", self.version))
1592 packed.append(struct.pack("!B", self.type))
1593 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1594 packed.append(struct.pack("!L", self.xid))
1595 packed.append(struct.pack("!L", self.experimenter))
1596 packed.append(struct.pack("!L", self.subtype))
1597 packed.append(struct.pack("!L", self.status))
1598 length = sum([len(x) for x in packed])
1599 packed[2] = struct.pack("!H", length)
1600 return ''.join(packed)
1601
1602 @staticmethod
1603 def unpack(reader):
1604 obj = bsn_bw_clear_data_reply()
1605 _version = reader.read("!B")[0]
1606 assert(_version == 5)
1607 _type = reader.read("!B")[0]
1608 assert(_type == 4)
1609 _length = reader.read("!H")[0]
1610 orig_reader = reader
1611 reader = orig_reader.slice(_length, 4)
1612 obj.xid = reader.read("!L")[0]
1613 _experimenter = reader.read("!L")[0]
1614 assert(_experimenter == 6035143)
1615 _subtype = reader.read("!L")[0]
1616 assert(_subtype == 22)
1617 obj.status = reader.read("!L")[0]
1618 return obj
1619
1620 def __eq__(self, other):
1621 if type(self) != type(other): return False
1622 if self.xid != other.xid: return False
1623 if self.status != other.status: return False
1624 return True
1625
1626 def pretty_print(self, q):
1627 q.text("bsn_bw_clear_data_reply {")
1628 with q.group():
1629 with q.indent(2):
1630 q.breakable()
1631 q.text("xid = ");
1632 if self.xid != None:
1633 q.text("%#x" % self.xid)
1634 else:
1635 q.text('None')
1636 q.text(","); q.breakable()
1637 q.text("status = ");
1638 q.text("%#x" % self.status)
1639 q.breakable()
1640 q.text('}')
1641
1642bsn_header.subtypes[22] = bsn_bw_clear_data_reply
1643
1644class bsn_bw_clear_data_request(bsn_header):
1645 version = 5
1646 type = 4
1647 experimenter = 6035143
1648 subtype = 21
1649
1650 def __init__(self, xid=None):
1651 if xid != None:
1652 self.xid = xid
1653 else:
1654 self.xid = None
1655 return
1656
1657 def pack(self):
1658 packed = []
1659 packed.append(struct.pack("!B", self.version))
1660 packed.append(struct.pack("!B", self.type))
1661 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1662 packed.append(struct.pack("!L", self.xid))
1663 packed.append(struct.pack("!L", self.experimenter))
1664 packed.append(struct.pack("!L", self.subtype))
1665 length = sum([len(x) for x in packed])
1666 packed[2] = struct.pack("!H", length)
1667 return ''.join(packed)
1668
1669 @staticmethod
1670 def unpack(reader):
1671 obj = bsn_bw_clear_data_request()
1672 _version = reader.read("!B")[0]
1673 assert(_version == 5)
1674 _type = reader.read("!B")[0]
1675 assert(_type == 4)
1676 _length = reader.read("!H")[0]
1677 orig_reader = reader
1678 reader = orig_reader.slice(_length, 4)
1679 obj.xid = reader.read("!L")[0]
1680 _experimenter = reader.read("!L")[0]
1681 assert(_experimenter == 6035143)
1682 _subtype = reader.read("!L")[0]
1683 assert(_subtype == 21)
1684 return obj
1685
1686 def __eq__(self, other):
1687 if type(self) != type(other): return False
1688 if self.xid != other.xid: return False
1689 return True
1690
1691 def pretty_print(self, q):
1692 q.text("bsn_bw_clear_data_request {")
1693 with q.group():
1694 with q.indent(2):
1695 q.breakable()
1696 q.text("xid = ");
1697 if self.xid != None:
1698 q.text("%#x" % self.xid)
1699 else:
1700 q.text('None')
1701 q.breakable()
1702 q.text('}')
1703
1704bsn_header.subtypes[21] = bsn_bw_clear_data_request
1705
1706class bsn_bw_enable_get_reply(bsn_header):
1707 version = 5
1708 type = 4
1709 experimenter = 6035143
1710 subtype = 20
1711
1712 def __init__(self, xid=None, enabled=None):
1713 if xid != None:
1714 self.xid = xid
1715 else:
1716 self.xid = None
1717 if enabled != None:
1718 self.enabled = enabled
1719 else:
1720 self.enabled = 0
1721 return
1722
1723 def pack(self):
1724 packed = []
1725 packed.append(struct.pack("!B", self.version))
1726 packed.append(struct.pack("!B", self.type))
1727 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1728 packed.append(struct.pack("!L", self.xid))
1729 packed.append(struct.pack("!L", self.experimenter))
1730 packed.append(struct.pack("!L", self.subtype))
1731 packed.append(struct.pack("!L", self.enabled))
1732 length = sum([len(x) for x in packed])
1733 packed[2] = struct.pack("!H", length)
1734 return ''.join(packed)
1735
1736 @staticmethod
1737 def unpack(reader):
1738 obj = bsn_bw_enable_get_reply()
1739 _version = reader.read("!B")[0]
1740 assert(_version == 5)
1741 _type = reader.read("!B")[0]
1742 assert(_type == 4)
1743 _length = reader.read("!H")[0]
1744 orig_reader = reader
1745 reader = orig_reader.slice(_length, 4)
1746 obj.xid = reader.read("!L")[0]
1747 _experimenter = reader.read("!L")[0]
1748 assert(_experimenter == 6035143)
1749 _subtype = reader.read("!L")[0]
1750 assert(_subtype == 20)
1751 obj.enabled = reader.read("!L")[0]
1752 return obj
1753
1754 def __eq__(self, other):
1755 if type(self) != type(other): return False
1756 if self.xid != other.xid: return False
1757 if self.enabled != other.enabled: return False
1758 return True
1759
1760 def pretty_print(self, q):
1761 q.text("bsn_bw_enable_get_reply {")
1762 with q.group():
1763 with q.indent(2):
1764 q.breakable()
1765 q.text("xid = ");
1766 if self.xid != None:
1767 q.text("%#x" % self.xid)
1768 else:
1769 q.text('None')
1770 q.text(","); q.breakable()
1771 q.text("enabled = ");
1772 q.text("%#x" % self.enabled)
1773 q.breakable()
1774 q.text('}')
1775
1776bsn_header.subtypes[20] = bsn_bw_enable_get_reply
1777
1778class bsn_bw_enable_get_request(bsn_header):
1779 version = 5
1780 type = 4
1781 experimenter = 6035143
1782 subtype = 19
1783
1784 def __init__(self, xid=None):
1785 if xid != None:
1786 self.xid = xid
1787 else:
1788 self.xid = None
1789 return
1790
1791 def pack(self):
1792 packed = []
1793 packed.append(struct.pack("!B", self.version))
1794 packed.append(struct.pack("!B", self.type))
1795 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1796 packed.append(struct.pack("!L", self.xid))
1797 packed.append(struct.pack("!L", self.experimenter))
1798 packed.append(struct.pack("!L", self.subtype))
1799 length = sum([len(x) for x in packed])
1800 packed[2] = struct.pack("!H", length)
1801 return ''.join(packed)
1802
1803 @staticmethod
1804 def unpack(reader):
1805 obj = bsn_bw_enable_get_request()
1806 _version = reader.read("!B")[0]
1807 assert(_version == 5)
1808 _type = reader.read("!B")[0]
1809 assert(_type == 4)
1810 _length = reader.read("!H")[0]
1811 orig_reader = reader
1812 reader = orig_reader.slice(_length, 4)
1813 obj.xid = reader.read("!L")[0]
1814 _experimenter = reader.read("!L")[0]
1815 assert(_experimenter == 6035143)
1816 _subtype = reader.read("!L")[0]
1817 assert(_subtype == 19)
1818 return obj
1819
1820 def __eq__(self, other):
1821 if type(self) != type(other): return False
1822 if self.xid != other.xid: return False
1823 return True
1824
1825 def pretty_print(self, q):
1826 q.text("bsn_bw_enable_get_request {")
1827 with q.group():
1828 with q.indent(2):
1829 q.breakable()
1830 q.text("xid = ");
1831 if self.xid != None:
1832 q.text("%#x" % self.xid)
1833 else:
1834 q.text('None')
1835 q.breakable()
1836 q.text('}')
1837
1838bsn_header.subtypes[19] = bsn_bw_enable_get_request
1839
1840class bsn_bw_enable_set_reply(bsn_header):
1841 version = 5
1842 type = 4
1843 experimenter = 6035143
1844 subtype = 23
1845
1846 def __init__(self, xid=None, enable=None, status=None):
1847 if xid != None:
1848 self.xid = xid
1849 else:
1850 self.xid = None
1851 if enable != None:
1852 self.enable = enable
1853 else:
1854 self.enable = 0
1855 if status != None:
1856 self.status = status
1857 else:
1858 self.status = 0
1859 return
1860
1861 def pack(self):
1862 packed = []
1863 packed.append(struct.pack("!B", self.version))
1864 packed.append(struct.pack("!B", self.type))
1865 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1866 packed.append(struct.pack("!L", self.xid))
1867 packed.append(struct.pack("!L", self.experimenter))
1868 packed.append(struct.pack("!L", self.subtype))
1869 packed.append(struct.pack("!L", self.enable))
1870 packed.append(struct.pack("!L", self.status))
1871 length = sum([len(x) for x in packed])
1872 packed[2] = struct.pack("!H", length)
1873 return ''.join(packed)
1874
1875 @staticmethod
1876 def unpack(reader):
1877 obj = bsn_bw_enable_set_reply()
1878 _version = reader.read("!B")[0]
1879 assert(_version == 5)
1880 _type = reader.read("!B")[0]
1881 assert(_type == 4)
1882 _length = reader.read("!H")[0]
1883 orig_reader = reader
1884 reader = orig_reader.slice(_length, 4)
1885 obj.xid = reader.read("!L")[0]
1886 _experimenter = reader.read("!L")[0]
1887 assert(_experimenter == 6035143)
1888 _subtype = reader.read("!L")[0]
1889 assert(_subtype == 23)
1890 obj.enable = reader.read("!L")[0]
1891 obj.status = reader.read("!L")[0]
1892 return obj
1893
1894 def __eq__(self, other):
1895 if type(self) != type(other): return False
1896 if self.xid != other.xid: return False
1897 if self.enable != other.enable: return False
1898 if self.status != other.status: return False
1899 return True
1900
1901 def pretty_print(self, q):
1902 q.text("bsn_bw_enable_set_reply {")
1903 with q.group():
1904 with q.indent(2):
1905 q.breakable()
1906 q.text("xid = ");
1907 if self.xid != None:
1908 q.text("%#x" % self.xid)
1909 else:
1910 q.text('None')
1911 q.text(","); q.breakable()
1912 q.text("enable = ");
1913 q.text("%#x" % self.enable)
1914 q.text(","); q.breakable()
1915 q.text("status = ");
1916 q.text("%#x" % self.status)
1917 q.breakable()
1918 q.text('}')
1919
1920bsn_header.subtypes[23] = bsn_bw_enable_set_reply
1921
1922class bsn_bw_enable_set_request(bsn_header):
1923 version = 5
1924 type = 4
1925 experimenter = 6035143
1926 subtype = 18
1927
1928 def __init__(self, xid=None, enable=None):
1929 if xid != None:
1930 self.xid = xid
1931 else:
1932 self.xid = None
1933 if enable != None:
1934 self.enable = enable
1935 else:
1936 self.enable = 0
1937 return
1938
1939 def pack(self):
1940 packed = []
1941 packed.append(struct.pack("!B", self.version))
1942 packed.append(struct.pack("!B", self.type))
1943 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1944 packed.append(struct.pack("!L", self.xid))
1945 packed.append(struct.pack("!L", self.experimenter))
1946 packed.append(struct.pack("!L", self.subtype))
1947 packed.append(struct.pack("!L", self.enable))
1948 length = sum([len(x) for x in packed])
1949 packed[2] = struct.pack("!H", length)
1950 return ''.join(packed)
1951
1952 @staticmethod
1953 def unpack(reader):
1954 obj = bsn_bw_enable_set_request()
1955 _version = reader.read("!B")[0]
1956 assert(_version == 5)
1957 _type = reader.read("!B")[0]
1958 assert(_type == 4)
1959 _length = reader.read("!H")[0]
1960 orig_reader = reader
1961 reader = orig_reader.slice(_length, 4)
1962 obj.xid = reader.read("!L")[0]
1963 _experimenter = reader.read("!L")[0]
1964 assert(_experimenter == 6035143)
1965 _subtype = reader.read("!L")[0]
1966 assert(_subtype == 18)
1967 obj.enable = reader.read("!L")[0]
1968 return obj
1969
1970 def __eq__(self, other):
1971 if type(self) != type(other): return False
1972 if self.xid != other.xid: return False
1973 if self.enable != other.enable: return False
1974 return True
1975
1976 def pretty_print(self, q):
1977 q.text("bsn_bw_enable_set_request {")
1978 with q.group():
1979 with q.indent(2):
1980 q.breakable()
1981 q.text("xid = ");
1982 if self.xid != None:
1983 q.text("%#x" % self.xid)
1984 else:
1985 q.text('None')
1986 q.text(","); q.breakable()
1987 q.text("enable = ");
1988 q.text("%#x" % self.enable)
1989 q.breakable()
1990 q.text('}')
1991
1992bsn_header.subtypes[18] = bsn_bw_enable_set_request
1993
1994class bsn_controller_connections_reply(bsn_header):
1995 version = 5
1996 type = 4
1997 experimenter = 6035143
1998 subtype = 57
1999
2000 def __init__(self, xid=None, connections=None):
2001 if xid != None:
2002 self.xid = xid
2003 else:
2004 self.xid = None
2005 if connections != None:
2006 self.connections = connections
2007 else:
2008 self.connections = []
2009 return
2010
2011 def pack(self):
2012 packed = []
2013 packed.append(struct.pack("!B", self.version))
2014 packed.append(struct.pack("!B", self.type))
2015 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2016 packed.append(struct.pack("!L", self.xid))
2017 packed.append(struct.pack("!L", self.experimenter))
2018 packed.append(struct.pack("!L", self.subtype))
2019 packed.append(loxi.generic_util.pack_list(self.connections))
2020 length = sum([len(x) for x in packed])
2021 packed[2] = struct.pack("!H", length)
2022 return ''.join(packed)
2023
2024 @staticmethod
2025 def unpack(reader):
2026 obj = bsn_controller_connections_reply()
2027 _version = reader.read("!B")[0]
2028 assert(_version == 5)
2029 _type = reader.read("!B")[0]
2030 assert(_type == 4)
2031 _length = reader.read("!H")[0]
2032 orig_reader = reader
2033 reader = orig_reader.slice(_length, 4)
2034 obj.xid = reader.read("!L")[0]
2035 _experimenter = reader.read("!L")[0]
2036 assert(_experimenter == 6035143)
2037 _subtype = reader.read("!L")[0]
2038 assert(_subtype == 57)
2039 obj.connections = loxi.generic_util.unpack_list(reader, ofp.common.bsn_controller_connection.unpack)
2040 return obj
2041
2042 def __eq__(self, other):
2043 if type(self) != type(other): return False
2044 if self.xid != other.xid: return False
2045 if self.connections != other.connections: return False
2046 return True
2047
2048 def pretty_print(self, q):
2049 q.text("bsn_controller_connections_reply {")
2050 with q.group():
2051 with q.indent(2):
2052 q.breakable()
2053 q.text("xid = ");
2054 if self.xid != None:
2055 q.text("%#x" % self.xid)
2056 else:
2057 q.text('None')
2058 q.text(","); q.breakable()
2059 q.text("connections = ");
2060 q.pp(self.connections)
2061 q.breakable()
2062 q.text('}')
2063
2064bsn_header.subtypes[57] = bsn_controller_connections_reply
2065
2066class bsn_controller_connections_request(bsn_header):
2067 version = 5
2068 type = 4
2069 experimenter = 6035143
2070 subtype = 56
2071
2072 def __init__(self, xid=None):
2073 if xid != None:
2074 self.xid = xid
2075 else:
2076 self.xid = None
2077 return
2078
2079 def pack(self):
2080 packed = []
2081 packed.append(struct.pack("!B", self.version))
2082 packed.append(struct.pack("!B", self.type))
2083 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2084 packed.append(struct.pack("!L", self.xid))
2085 packed.append(struct.pack("!L", self.experimenter))
2086 packed.append(struct.pack("!L", self.subtype))
2087 length = sum([len(x) for x in packed])
2088 packed[2] = struct.pack("!H", length)
2089 return ''.join(packed)
2090
2091 @staticmethod
2092 def unpack(reader):
2093 obj = bsn_controller_connections_request()
2094 _version = reader.read("!B")[0]
2095 assert(_version == 5)
2096 _type = reader.read("!B")[0]
2097 assert(_type == 4)
2098 _length = reader.read("!H")[0]
2099 orig_reader = reader
2100 reader = orig_reader.slice(_length, 4)
2101 obj.xid = reader.read("!L")[0]
2102 _experimenter = reader.read("!L")[0]
2103 assert(_experimenter == 6035143)
2104 _subtype = reader.read("!L")[0]
2105 assert(_subtype == 56)
2106 return obj
2107
2108 def __eq__(self, other):
2109 if type(self) != type(other): return False
2110 if self.xid != other.xid: return False
2111 return True
2112
2113 def pretty_print(self, q):
2114 q.text("bsn_controller_connections_request {")
2115 with q.group():
2116 with q.indent(2):
2117 q.breakable()
2118 q.text("xid = ");
2119 if self.xid != None:
2120 q.text("%#x" % self.xid)
2121 else:
2122 q.text('None')
2123 q.breakable()
2124 q.text('}')
2125
2126bsn_header.subtypes[56] = bsn_controller_connections_request
2127
2128class experimenter_stats_reply(stats_reply):
2129 subtypes = {}
2130
2131 version = 5
2132 type = 19
2133 stats_type = 65535
2134
2135 def __init__(self, xid=None, flags=None, experimenter=None, subtype=None):
2136 if xid != None:
2137 self.xid = xid
2138 else:
2139 self.xid = None
2140 if flags != None:
2141 self.flags = flags
2142 else:
2143 self.flags = 0
2144 if experimenter != None:
2145 self.experimenter = experimenter
2146 else:
2147 self.experimenter = 0
2148 if subtype != None:
2149 self.subtype = subtype
2150 else:
2151 self.subtype = 0
2152 return
2153
2154 def pack(self):
2155 packed = []
2156 packed.append(struct.pack("!B", self.version))
2157 packed.append(struct.pack("!B", self.type))
2158 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2159 packed.append(struct.pack("!L", self.xid))
2160 packed.append(struct.pack("!H", self.stats_type))
2161 packed.append(struct.pack("!H", self.flags))
2162 packed.append('\x00' * 4)
2163 packed.append(struct.pack("!L", self.experimenter))
2164 packed.append(struct.pack("!L", self.subtype))
2165 length = sum([len(x) for x in packed])
2166 packed[2] = struct.pack("!H", length)
2167 return ''.join(packed)
2168
2169 @staticmethod
2170 def unpack(reader):
2171 subtype, = reader.peek('!L', 16)
2172 subclass = experimenter_stats_reply.subtypes.get(subtype)
2173 if subclass:
2174 return subclass.unpack(reader)
2175
2176 obj = experimenter_stats_reply()
2177 _version = reader.read("!B")[0]
2178 assert(_version == 5)
2179 _type = reader.read("!B")[0]
2180 assert(_type == 19)
2181 _length = reader.read("!H")[0]
2182 orig_reader = reader
2183 reader = orig_reader.slice(_length, 4)
2184 obj.xid = reader.read("!L")[0]
2185 _stats_type = reader.read("!H")[0]
2186 assert(_stats_type == 65535)
2187 obj.flags = reader.read("!H")[0]
2188 reader.skip(4)
2189 obj.experimenter = reader.read("!L")[0]
2190 obj.subtype = reader.read("!L")[0]
2191 return obj
2192
2193 def __eq__(self, other):
2194 if type(self) != type(other): return False
2195 if self.xid != other.xid: return False
2196 if self.flags != other.flags: return False
2197 if self.experimenter != other.experimenter: return False
2198 if self.subtype != other.subtype: return False
2199 return True
2200
2201 def pretty_print(self, q):
2202 q.text("experimenter_stats_reply {")
2203 with q.group():
2204 with q.indent(2):
2205 q.breakable()
2206 q.text("xid = ");
2207 if self.xid != None:
2208 q.text("%#x" % self.xid)
2209 else:
2210 q.text('None')
2211 q.text(","); q.breakable()
2212 q.text("flags = ");
2213 q.text("%#x" % self.flags)
2214 q.text(","); q.breakable()
2215 q.text("subtype = ");
2216 q.text("%#x" % self.subtype)
2217 q.breakable()
2218 q.text('}')
2219
2220stats_reply.subtypes[65535] = experimenter_stats_reply
2221
2222class bsn_stats_reply(experimenter_stats_reply):
2223 subtypes = {}
2224
2225 version = 5
2226 type = 19
2227 stats_type = 65535
2228 experimenter = 6035143
2229
2230 def __init__(self, xid=None, flags=None, subtype=None):
2231 if xid != None:
2232 self.xid = xid
2233 else:
2234 self.xid = None
2235 if flags != None:
2236 self.flags = flags
2237 else:
2238 self.flags = 0
2239 if subtype != None:
2240 self.subtype = subtype
2241 else:
2242 self.subtype = 0
2243 return
2244
2245 def pack(self):
2246 packed = []
2247 packed.append(struct.pack("!B", self.version))
2248 packed.append(struct.pack("!B", self.type))
2249 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2250 packed.append(struct.pack("!L", self.xid))
2251 packed.append(struct.pack("!H", self.stats_type))
2252 packed.append(struct.pack("!H", self.flags))
2253 packed.append('\x00' * 4)
2254 packed.append(struct.pack("!L", self.experimenter))
2255 packed.append(struct.pack("!L", self.subtype))
2256 length = sum([len(x) for x in packed])
2257 packed[2] = struct.pack("!H", length)
2258 return ''.join(packed)
2259
2260 @staticmethod
2261 def unpack(reader):
2262 subtype, = reader.peek('!L', 20)
2263 subclass = bsn_stats_reply.subtypes.get(subtype)
2264 if subclass:
2265 return subclass.unpack(reader)
2266
2267 obj = bsn_stats_reply()
2268 _version = reader.read("!B")[0]
2269 assert(_version == 5)
2270 _type = reader.read("!B")[0]
2271 assert(_type == 19)
2272 _length = reader.read("!H")[0]
2273 orig_reader = reader
2274 reader = orig_reader.slice(_length, 4)
2275 obj.xid = reader.read("!L")[0]
2276 _stats_type = reader.read("!H")[0]
2277 assert(_stats_type == 65535)
2278 obj.flags = reader.read("!H")[0]
2279 reader.skip(4)
2280 _experimenter = reader.read("!L")[0]
2281 assert(_experimenter == 6035143)
2282 obj.subtype = reader.read("!L")[0]
2283 return obj
2284
2285 def __eq__(self, other):
2286 if type(self) != type(other): return False
2287 if self.xid != other.xid: return False
2288 if self.flags != other.flags: return False
2289 if self.subtype != other.subtype: return False
2290 return True
2291
2292 def pretty_print(self, q):
2293 q.text("bsn_stats_reply {")
2294 with q.group():
2295 with q.indent(2):
2296 q.breakable()
2297 q.text("xid = ");
2298 if self.xid != None:
2299 q.text("%#x" % self.xid)
2300 else:
2301 q.text('None')
2302 q.text(","); q.breakable()
2303 q.text("flags = ");
2304 q.text("%#x" % self.flags)
2305 q.breakable()
2306 q.text('}')
2307
2308experimenter_stats_reply.subtypes[6035143] = bsn_stats_reply
2309
2310class bsn_debug_counter_desc_stats_reply(bsn_stats_reply):
2311 version = 5
2312 type = 19
2313 stats_type = 65535
2314 experimenter = 6035143
2315 subtype = 13
2316
2317 def __init__(self, xid=None, flags=None, entries=None):
2318 if xid != None:
2319 self.xid = xid
2320 else:
2321 self.xid = None
2322 if flags != None:
2323 self.flags = flags
2324 else:
2325 self.flags = 0
2326 if entries != None:
2327 self.entries = entries
2328 else:
2329 self.entries = []
2330 return
2331
2332 def pack(self):
2333 packed = []
2334 packed.append(struct.pack("!B", self.version))
2335 packed.append(struct.pack("!B", self.type))
2336 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2337 packed.append(struct.pack("!L", self.xid))
2338 packed.append(struct.pack("!H", self.stats_type))
2339 packed.append(struct.pack("!H", self.flags))
2340 packed.append('\x00' * 4)
2341 packed.append(struct.pack("!L", self.experimenter))
2342 packed.append(struct.pack("!L", self.subtype))
2343 packed.append(loxi.generic_util.pack_list(self.entries))
2344 length = sum([len(x) for x in packed])
2345 packed[2] = struct.pack("!H", length)
2346 return ''.join(packed)
2347
2348 @staticmethod
2349 def unpack(reader):
2350 obj = bsn_debug_counter_desc_stats_reply()
2351 _version = reader.read("!B")[0]
2352 assert(_version == 5)
2353 _type = reader.read("!B")[0]
2354 assert(_type == 19)
2355 _length = reader.read("!H")[0]
2356 orig_reader = reader
2357 reader = orig_reader.slice(_length, 4)
2358 obj.xid = reader.read("!L")[0]
2359 _stats_type = reader.read("!H")[0]
2360 assert(_stats_type == 65535)
2361 obj.flags = reader.read("!H")[0]
2362 reader.skip(4)
2363 _experimenter = reader.read("!L")[0]
2364 assert(_experimenter == 6035143)
2365 _subtype = reader.read("!L")[0]
2366 assert(_subtype == 13)
2367 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_debug_counter_desc_stats_entry.unpack)
2368 return obj
2369
2370 def __eq__(self, other):
2371 if type(self) != type(other): return False
2372 if self.xid != other.xid: return False
2373 if self.flags != other.flags: return False
2374 if self.entries != other.entries: return False
2375 return True
2376
2377 def pretty_print(self, q):
2378 q.text("bsn_debug_counter_desc_stats_reply {")
2379 with q.group():
2380 with q.indent(2):
2381 q.breakable()
2382 q.text("xid = ");
2383 if self.xid != None:
2384 q.text("%#x" % self.xid)
2385 else:
2386 q.text('None')
2387 q.text(","); q.breakable()
2388 q.text("flags = ");
2389 q.text("%#x" % self.flags)
2390 q.text(","); q.breakable()
2391 q.text("entries = ");
2392 q.pp(self.entries)
2393 q.breakable()
2394 q.text('}')
2395
2396bsn_stats_reply.subtypes[13] = bsn_debug_counter_desc_stats_reply
2397
2398class experimenter_stats_request(stats_request):
2399 subtypes = {}
2400
2401 version = 5
2402 type = 18
2403 stats_type = 65535
2404
2405 def __init__(self, xid=None, flags=None, experimenter=None, subtype=None):
2406 if xid != None:
2407 self.xid = xid
2408 else:
2409 self.xid = None
2410 if flags != None:
2411 self.flags = flags
2412 else:
2413 self.flags = 0
2414 if experimenter != None:
2415 self.experimenter = experimenter
2416 else:
2417 self.experimenter = 0
2418 if subtype != None:
2419 self.subtype = subtype
2420 else:
2421 self.subtype = 0
2422 return
2423
2424 def pack(self):
2425 packed = []
2426 packed.append(struct.pack("!B", self.version))
2427 packed.append(struct.pack("!B", self.type))
2428 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2429 packed.append(struct.pack("!L", self.xid))
2430 packed.append(struct.pack("!H", self.stats_type))
2431 packed.append(struct.pack("!H", self.flags))
2432 packed.append('\x00' * 4)
2433 packed.append(struct.pack("!L", self.experimenter))
2434 packed.append(struct.pack("!L", self.subtype))
2435 length = sum([len(x) for x in packed])
2436 packed[2] = struct.pack("!H", length)
2437 return ''.join(packed)
2438
2439 @staticmethod
2440 def unpack(reader):
2441 subtype, = reader.peek('!L', 16)
2442 subclass = experimenter_stats_request.subtypes.get(subtype)
2443 if subclass:
2444 return subclass.unpack(reader)
2445
2446 obj = experimenter_stats_request()
2447 _version = reader.read("!B")[0]
2448 assert(_version == 5)
2449 _type = reader.read("!B")[0]
2450 assert(_type == 18)
2451 _length = reader.read("!H")[0]
2452 orig_reader = reader
2453 reader = orig_reader.slice(_length, 4)
2454 obj.xid = reader.read("!L")[0]
2455 _stats_type = reader.read("!H")[0]
2456 assert(_stats_type == 65535)
2457 obj.flags = reader.read("!H")[0]
2458 reader.skip(4)
2459 obj.experimenter = reader.read("!L")[0]
2460 obj.subtype = reader.read("!L")[0]
2461 return obj
2462
2463 def __eq__(self, other):
2464 if type(self) != type(other): return False
2465 if self.xid != other.xid: return False
2466 if self.flags != other.flags: return False
2467 if self.experimenter != other.experimenter: return False
2468 if self.subtype != other.subtype: return False
2469 return True
2470
2471 def pretty_print(self, q):
2472 q.text("experimenter_stats_request {")
2473 with q.group():
2474 with q.indent(2):
2475 q.breakable()
2476 q.text("xid = ");
2477 if self.xid != None:
2478 q.text("%#x" % self.xid)
2479 else:
2480 q.text('None')
2481 q.text(","); q.breakable()
2482 q.text("flags = ");
2483 q.text("%#x" % self.flags)
2484 q.text(","); q.breakable()
2485 q.text("subtype = ");
2486 q.text("%#x" % self.subtype)
2487 q.breakable()
2488 q.text('}')
2489
2490stats_request.subtypes[65535] = experimenter_stats_request
2491
2492class bsn_stats_request(experimenter_stats_request):
2493 subtypes = {}
2494
2495 version = 5
2496 type = 18
2497 stats_type = 65535
2498 experimenter = 6035143
2499
2500 def __init__(self, xid=None, flags=None, subtype=None):
2501 if xid != None:
2502 self.xid = xid
2503 else:
2504 self.xid = None
2505 if flags != None:
2506 self.flags = flags
2507 else:
2508 self.flags = 0
2509 if subtype != None:
2510 self.subtype = subtype
2511 else:
2512 self.subtype = 0
2513 return
2514
2515 def pack(self):
2516 packed = []
2517 packed.append(struct.pack("!B", self.version))
2518 packed.append(struct.pack("!B", self.type))
2519 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2520 packed.append(struct.pack("!L", self.xid))
2521 packed.append(struct.pack("!H", self.stats_type))
2522 packed.append(struct.pack("!H", self.flags))
2523 packed.append('\x00' * 4)
2524 packed.append(struct.pack("!L", self.experimenter))
2525 packed.append(struct.pack("!L", self.subtype))
2526 length = sum([len(x) for x in packed])
2527 packed[2] = struct.pack("!H", length)
2528 return ''.join(packed)
2529
2530 @staticmethod
2531 def unpack(reader):
2532 subtype, = reader.peek('!L', 20)
2533 subclass = bsn_stats_request.subtypes.get(subtype)
2534 if subclass:
2535 return subclass.unpack(reader)
2536
2537 obj = bsn_stats_request()
2538 _version = reader.read("!B")[0]
2539 assert(_version == 5)
2540 _type = reader.read("!B")[0]
2541 assert(_type == 18)
2542 _length = reader.read("!H")[0]
2543 orig_reader = reader
2544 reader = orig_reader.slice(_length, 4)
2545 obj.xid = reader.read("!L")[0]
2546 _stats_type = reader.read("!H")[0]
2547 assert(_stats_type == 65535)
2548 obj.flags = reader.read("!H")[0]
2549 reader.skip(4)
2550 _experimenter = reader.read("!L")[0]
2551 assert(_experimenter == 6035143)
2552 obj.subtype = reader.read("!L")[0]
2553 return obj
2554
2555 def __eq__(self, other):
2556 if type(self) != type(other): return False
2557 if self.xid != other.xid: return False
2558 if self.flags != other.flags: return False
2559 if self.subtype != other.subtype: return False
2560 return True
2561
2562 def pretty_print(self, q):
2563 q.text("bsn_stats_request {")
2564 with q.group():
2565 with q.indent(2):
2566 q.breakable()
2567 q.text("xid = ");
2568 if self.xid != None:
2569 q.text("%#x" % self.xid)
2570 else:
2571 q.text('None')
2572 q.text(","); q.breakable()
2573 q.text("flags = ");
2574 q.text("%#x" % self.flags)
2575 q.breakable()
2576 q.text('}')
2577
2578experimenter_stats_request.subtypes[6035143] = bsn_stats_request
2579
2580class bsn_debug_counter_desc_stats_request(bsn_stats_request):
2581 version = 5
2582 type = 18
2583 stats_type = 65535
2584 experimenter = 6035143
2585 subtype = 13
2586
2587 def __init__(self, xid=None, flags=None):
2588 if xid != None:
2589 self.xid = xid
2590 else:
2591 self.xid = None
2592 if flags != None:
2593 self.flags = flags
2594 else:
2595 self.flags = 0
2596 return
2597
2598 def pack(self):
2599 packed = []
2600 packed.append(struct.pack("!B", self.version))
2601 packed.append(struct.pack("!B", self.type))
2602 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2603 packed.append(struct.pack("!L", self.xid))
2604 packed.append(struct.pack("!H", self.stats_type))
2605 packed.append(struct.pack("!H", self.flags))
2606 packed.append('\x00' * 4)
2607 packed.append(struct.pack("!L", self.experimenter))
2608 packed.append(struct.pack("!L", self.subtype))
2609 length = sum([len(x) for x in packed])
2610 packed[2] = struct.pack("!H", length)
2611 return ''.join(packed)
2612
2613 @staticmethod
2614 def unpack(reader):
2615 obj = bsn_debug_counter_desc_stats_request()
2616 _version = reader.read("!B")[0]
2617 assert(_version == 5)
2618 _type = reader.read("!B")[0]
2619 assert(_type == 18)
2620 _length = reader.read("!H")[0]
2621 orig_reader = reader
2622 reader = orig_reader.slice(_length, 4)
2623 obj.xid = reader.read("!L")[0]
2624 _stats_type = reader.read("!H")[0]
2625 assert(_stats_type == 65535)
2626 obj.flags = reader.read("!H")[0]
2627 reader.skip(4)
2628 _experimenter = reader.read("!L")[0]
2629 assert(_experimenter == 6035143)
2630 _subtype = reader.read("!L")[0]
2631 assert(_subtype == 13)
2632 return obj
2633
2634 def __eq__(self, other):
2635 if type(self) != type(other): return False
2636 if self.xid != other.xid: return False
2637 if self.flags != other.flags: return False
2638 return True
2639
2640 def pretty_print(self, q):
2641 q.text("bsn_debug_counter_desc_stats_request {")
2642 with q.group():
2643 with q.indent(2):
2644 q.breakable()
2645 q.text("xid = ");
2646 if self.xid != None:
2647 q.text("%#x" % self.xid)
2648 else:
2649 q.text('None')
2650 q.text(","); q.breakable()
2651 q.text("flags = ");
2652 q.text("%#x" % self.flags)
2653 q.breakable()
2654 q.text('}')
2655
2656bsn_stats_request.subtypes[13] = bsn_debug_counter_desc_stats_request
2657
2658class bsn_debug_counter_stats_reply(bsn_stats_reply):
2659 version = 5
2660 type = 19
2661 stats_type = 65535
2662 experimenter = 6035143
2663 subtype = 12
2664
2665 def __init__(self, xid=None, flags=None, entries=None):
2666 if xid != None:
2667 self.xid = xid
2668 else:
2669 self.xid = None
2670 if flags != None:
2671 self.flags = flags
2672 else:
2673 self.flags = 0
2674 if entries != None:
2675 self.entries = entries
2676 else:
2677 self.entries = []
2678 return
2679
2680 def pack(self):
2681 packed = []
2682 packed.append(struct.pack("!B", self.version))
2683 packed.append(struct.pack("!B", self.type))
2684 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2685 packed.append(struct.pack("!L", self.xid))
2686 packed.append(struct.pack("!H", self.stats_type))
2687 packed.append(struct.pack("!H", self.flags))
2688 packed.append('\x00' * 4)
2689 packed.append(struct.pack("!L", self.experimenter))
2690 packed.append(struct.pack("!L", self.subtype))
2691 packed.append(loxi.generic_util.pack_list(self.entries))
2692 length = sum([len(x) for x in packed])
2693 packed[2] = struct.pack("!H", length)
2694 return ''.join(packed)
2695
2696 @staticmethod
2697 def unpack(reader):
2698 obj = bsn_debug_counter_stats_reply()
2699 _version = reader.read("!B")[0]
2700 assert(_version == 5)
2701 _type = reader.read("!B")[0]
2702 assert(_type == 19)
2703 _length = reader.read("!H")[0]
2704 orig_reader = reader
2705 reader = orig_reader.slice(_length, 4)
2706 obj.xid = reader.read("!L")[0]
2707 _stats_type = reader.read("!H")[0]
2708 assert(_stats_type == 65535)
2709 obj.flags = reader.read("!H")[0]
2710 reader.skip(4)
2711 _experimenter = reader.read("!L")[0]
2712 assert(_experimenter == 6035143)
2713 _subtype = reader.read("!L")[0]
2714 assert(_subtype == 12)
2715 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_debug_counter_stats_entry.unpack)
2716 return obj
2717
2718 def __eq__(self, other):
2719 if type(self) != type(other): return False
2720 if self.xid != other.xid: return False
2721 if self.flags != other.flags: return False
2722 if self.entries != other.entries: return False
2723 return True
2724
2725 def pretty_print(self, q):
2726 q.text("bsn_debug_counter_stats_reply {")
2727 with q.group():
2728 with q.indent(2):
2729 q.breakable()
2730 q.text("xid = ");
2731 if self.xid != None:
2732 q.text("%#x" % self.xid)
2733 else:
2734 q.text('None')
2735 q.text(","); q.breakable()
2736 q.text("flags = ");
2737 q.text("%#x" % self.flags)
2738 q.text(","); q.breakable()
2739 q.text("entries = ");
2740 q.pp(self.entries)
2741 q.breakable()
2742 q.text('}')
2743
2744bsn_stats_reply.subtypes[12] = bsn_debug_counter_stats_reply
2745
2746class bsn_debug_counter_stats_request(bsn_stats_request):
2747 version = 5
2748 type = 18
2749 stats_type = 65535
2750 experimenter = 6035143
2751 subtype = 12
2752
2753 def __init__(self, xid=None, flags=None):
2754 if xid != None:
2755 self.xid = xid
2756 else:
2757 self.xid = None
2758 if flags != None:
2759 self.flags = flags
2760 else:
2761 self.flags = 0
2762 return
2763
2764 def pack(self):
2765 packed = []
2766 packed.append(struct.pack("!B", self.version))
2767 packed.append(struct.pack("!B", self.type))
2768 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2769 packed.append(struct.pack("!L", self.xid))
2770 packed.append(struct.pack("!H", self.stats_type))
2771 packed.append(struct.pack("!H", self.flags))
2772 packed.append('\x00' * 4)
2773 packed.append(struct.pack("!L", self.experimenter))
2774 packed.append(struct.pack("!L", self.subtype))
2775 length = sum([len(x) for x in packed])
2776 packed[2] = struct.pack("!H", length)
2777 return ''.join(packed)
2778
2779 @staticmethod
2780 def unpack(reader):
2781 obj = bsn_debug_counter_stats_request()
2782 _version = reader.read("!B")[0]
2783 assert(_version == 5)
2784 _type = reader.read("!B")[0]
2785 assert(_type == 18)
2786 _length = reader.read("!H")[0]
2787 orig_reader = reader
2788 reader = orig_reader.slice(_length, 4)
2789 obj.xid = reader.read("!L")[0]
2790 _stats_type = reader.read("!H")[0]
2791 assert(_stats_type == 65535)
2792 obj.flags = reader.read("!H")[0]
2793 reader.skip(4)
2794 _experimenter = reader.read("!L")[0]
2795 assert(_experimenter == 6035143)
2796 _subtype = reader.read("!L")[0]
2797 assert(_subtype == 12)
2798 return obj
2799
2800 def __eq__(self, other):
2801 if type(self) != type(other): return False
2802 if self.xid != other.xid: return False
2803 if self.flags != other.flags: return False
2804 return True
2805
2806 def pretty_print(self, q):
2807 q.text("bsn_debug_counter_stats_request {")
2808 with q.group():
2809 with q.indent(2):
2810 q.breakable()
2811 q.text("xid = ");
2812 if self.xid != None:
2813 q.text("%#x" % self.xid)
2814 else:
2815 q.text('None')
2816 q.text(","); q.breakable()
2817 q.text("flags = ");
2818 q.text("%#x" % self.flags)
2819 q.breakable()
2820 q.text('}')
2821
2822bsn_stats_request.subtypes[12] = bsn_debug_counter_stats_request
2823
2824class bsn_flow_checksum_bucket_stats_reply(bsn_stats_reply):
2825 version = 5
2826 type = 19
2827 stats_type = 65535
2828 experimenter = 6035143
2829 subtype = 10
2830
2831 def __init__(self, xid=None, flags=None, entries=None):
2832 if xid != None:
2833 self.xid = xid
2834 else:
2835 self.xid = None
2836 if flags != None:
2837 self.flags = flags
2838 else:
2839 self.flags = 0
2840 if entries != None:
2841 self.entries = entries
2842 else:
2843 self.entries = []
2844 return
2845
2846 def pack(self):
2847 packed = []
2848 packed.append(struct.pack("!B", self.version))
2849 packed.append(struct.pack("!B", self.type))
2850 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2851 packed.append(struct.pack("!L", self.xid))
2852 packed.append(struct.pack("!H", self.stats_type))
2853 packed.append(struct.pack("!H", self.flags))
2854 packed.append('\x00' * 4)
2855 packed.append(struct.pack("!L", self.experimenter))
2856 packed.append(struct.pack("!L", self.subtype))
2857 packed.append(loxi.generic_util.pack_list(self.entries))
2858 length = sum([len(x) for x in packed])
2859 packed[2] = struct.pack("!H", length)
2860 return ''.join(packed)
2861
2862 @staticmethod
2863 def unpack(reader):
2864 obj = bsn_flow_checksum_bucket_stats_reply()
2865 _version = reader.read("!B")[0]
2866 assert(_version == 5)
2867 _type = reader.read("!B")[0]
2868 assert(_type == 19)
2869 _length = reader.read("!H")[0]
2870 orig_reader = reader
2871 reader = orig_reader.slice(_length, 4)
2872 obj.xid = reader.read("!L")[0]
2873 _stats_type = reader.read("!H")[0]
2874 assert(_stats_type == 65535)
2875 obj.flags = reader.read("!H")[0]
2876 reader.skip(4)
2877 _experimenter = reader.read("!L")[0]
2878 assert(_experimenter == 6035143)
2879 _subtype = reader.read("!L")[0]
2880 assert(_subtype == 10)
2881 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_flow_checksum_bucket_stats_entry.unpack)
2882 return obj
2883
2884 def __eq__(self, other):
2885 if type(self) != type(other): return False
2886 if self.xid != other.xid: return False
2887 if self.flags != other.flags: return False
2888 if self.entries != other.entries: return False
2889 return True
2890
2891 def pretty_print(self, q):
2892 q.text("bsn_flow_checksum_bucket_stats_reply {")
2893 with q.group():
2894 with q.indent(2):
2895 q.breakable()
2896 q.text("xid = ");
2897 if self.xid != None:
2898 q.text("%#x" % self.xid)
2899 else:
2900 q.text('None')
2901 q.text(","); q.breakable()
2902 q.text("flags = ");
2903 q.text("%#x" % self.flags)
2904 q.text(","); q.breakable()
2905 q.text("entries = ");
2906 q.pp(self.entries)
2907 q.breakable()
2908 q.text('}')
2909
2910bsn_stats_reply.subtypes[10] = bsn_flow_checksum_bucket_stats_reply
2911
2912class bsn_flow_checksum_bucket_stats_request(bsn_stats_request):
2913 version = 5
2914 type = 18
2915 stats_type = 65535
2916 experimenter = 6035143
2917 subtype = 10
2918
2919 def __init__(self, xid=None, flags=None, table_id=None):
2920 if xid != None:
2921 self.xid = xid
2922 else:
2923 self.xid = None
2924 if flags != None:
2925 self.flags = flags
2926 else:
2927 self.flags = 0
2928 if table_id != None:
2929 self.table_id = table_id
2930 else:
2931 self.table_id = 0
2932 return
2933
2934 def pack(self):
2935 packed = []
2936 packed.append(struct.pack("!B", self.version))
2937 packed.append(struct.pack("!B", self.type))
2938 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2939 packed.append(struct.pack("!L", self.xid))
2940 packed.append(struct.pack("!H", self.stats_type))
2941 packed.append(struct.pack("!H", self.flags))
2942 packed.append('\x00' * 4)
2943 packed.append(struct.pack("!L", self.experimenter))
2944 packed.append(struct.pack("!L", self.subtype))
2945 packed.append(struct.pack("!B", self.table_id))
2946 length = sum([len(x) for x in packed])
2947 packed[2] = struct.pack("!H", length)
2948 return ''.join(packed)
2949
2950 @staticmethod
2951 def unpack(reader):
2952 obj = bsn_flow_checksum_bucket_stats_request()
2953 _version = reader.read("!B")[0]
2954 assert(_version == 5)
2955 _type = reader.read("!B")[0]
2956 assert(_type == 18)
2957 _length = reader.read("!H")[0]
2958 orig_reader = reader
2959 reader = orig_reader.slice(_length, 4)
2960 obj.xid = reader.read("!L")[0]
2961 _stats_type = reader.read("!H")[0]
2962 assert(_stats_type == 65535)
2963 obj.flags = reader.read("!H")[0]
2964 reader.skip(4)
2965 _experimenter = reader.read("!L")[0]
2966 assert(_experimenter == 6035143)
2967 _subtype = reader.read("!L")[0]
2968 assert(_subtype == 10)
2969 obj.table_id = reader.read("!B")[0]
2970 return obj
2971
2972 def __eq__(self, other):
2973 if type(self) != type(other): return False
2974 if self.xid != other.xid: return False
2975 if self.flags != other.flags: return False
2976 if self.table_id != other.table_id: return False
2977 return True
2978
2979 def pretty_print(self, q):
2980 q.text("bsn_flow_checksum_bucket_stats_request {")
2981 with q.group():
2982 with q.indent(2):
2983 q.breakable()
2984 q.text("xid = ");
2985 if self.xid != None:
2986 q.text("%#x" % self.xid)
2987 else:
2988 q.text('None')
2989 q.text(","); q.breakable()
2990 q.text("flags = ");
2991 q.text("%#x" % self.flags)
2992 q.text(","); q.breakable()
2993 q.text("table_id = ");
2994 q.text("%#x" % self.table_id)
2995 q.breakable()
2996 q.text('}')
2997
2998bsn_stats_request.subtypes[10] = bsn_flow_checksum_bucket_stats_request
2999
3000class bsn_flow_idle(bsn_header):
3001 version = 5
3002 type = 4
3003 experimenter = 6035143
3004 subtype = 40
3005
3006 def __init__(self, xid=None, cookie=None, priority=None, table_id=None, match=None):
3007 if xid != None:
3008 self.xid = xid
3009 else:
3010 self.xid = None
3011 if cookie != None:
3012 self.cookie = cookie
3013 else:
3014 self.cookie = 0
3015 if priority != None:
3016 self.priority = priority
3017 else:
3018 self.priority = 0
3019 if table_id != None:
3020 self.table_id = table_id
3021 else:
3022 self.table_id = 0
3023 if match != None:
3024 self.match = match
3025 else:
3026 self.match = ofp.match()
3027 return
3028
3029 def pack(self):
3030 packed = []
3031 packed.append(struct.pack("!B", self.version))
3032 packed.append(struct.pack("!B", self.type))
3033 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3034 packed.append(struct.pack("!L", self.xid))
3035 packed.append(struct.pack("!L", self.experimenter))
3036 packed.append(struct.pack("!L", self.subtype))
3037 packed.append(struct.pack("!Q", self.cookie))
3038 packed.append(struct.pack("!H", self.priority))
3039 packed.append(struct.pack("!B", self.table_id))
3040 packed.append('\x00' * 5)
3041 packed.append(self.match.pack())
3042 length = sum([len(x) for x in packed])
3043 packed[2] = struct.pack("!H", length)
3044 return ''.join(packed)
3045
3046 @staticmethod
3047 def unpack(reader):
3048 obj = bsn_flow_idle()
3049 _version = reader.read("!B")[0]
3050 assert(_version == 5)
3051 _type = reader.read("!B")[0]
3052 assert(_type == 4)
3053 _length = reader.read("!H")[0]
3054 orig_reader = reader
3055 reader = orig_reader.slice(_length, 4)
3056 obj.xid = reader.read("!L")[0]
3057 _experimenter = reader.read("!L")[0]
3058 assert(_experimenter == 6035143)
3059 _subtype = reader.read("!L")[0]
3060 assert(_subtype == 40)
3061 obj.cookie = reader.read("!Q")[0]
3062 obj.priority = reader.read("!H")[0]
3063 obj.table_id = reader.read("!B")[0]
3064 reader.skip(5)
3065 obj.match = ofp.match.unpack(reader)
3066 return obj
3067
3068 def __eq__(self, other):
3069 if type(self) != type(other): return False
3070 if self.xid != other.xid: return False
3071 if self.cookie != other.cookie: return False
3072 if self.priority != other.priority: return False
3073 if self.table_id != other.table_id: return False
3074 if self.match != other.match: return False
3075 return True
3076
3077 def pretty_print(self, q):
3078 q.text("bsn_flow_idle {")
3079 with q.group():
3080 with q.indent(2):
3081 q.breakable()
3082 q.text("xid = ");
3083 if self.xid != None:
3084 q.text("%#x" % self.xid)
3085 else:
3086 q.text('None')
3087 q.text(","); q.breakable()
3088 q.text("cookie = ");
3089 q.text("%#x" % self.cookie)
3090 q.text(","); q.breakable()
3091 q.text("priority = ");
3092 q.text("%#x" % self.priority)
3093 q.text(","); q.breakable()
3094 q.text("table_id = ");
3095 q.text("%#x" % self.table_id)
3096 q.text(","); q.breakable()
3097 q.text("match = ");
3098 q.pp(self.match)
3099 q.breakable()
3100 q.text('}')
3101
3102bsn_header.subtypes[40] = bsn_flow_idle
3103
3104class bsn_flow_idle_enable_get_reply(bsn_header):
3105 version = 5
3106 type = 4
3107 experimenter = 6035143
3108 subtype = 39
3109
3110 def __init__(self, xid=None, enabled=None):
3111 if xid != None:
3112 self.xid = xid
3113 else:
3114 self.xid = None
3115 if enabled != None:
3116 self.enabled = enabled
3117 else:
3118 self.enabled = 0
3119 return
3120
3121 def pack(self):
3122 packed = []
3123 packed.append(struct.pack("!B", self.version))
3124 packed.append(struct.pack("!B", self.type))
3125 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3126 packed.append(struct.pack("!L", self.xid))
3127 packed.append(struct.pack("!L", self.experimenter))
3128 packed.append(struct.pack("!L", self.subtype))
3129 packed.append(struct.pack("!L", self.enabled))
3130 length = sum([len(x) for x in packed])
3131 packed[2] = struct.pack("!H", length)
3132 return ''.join(packed)
3133
3134 @staticmethod
3135 def unpack(reader):
3136 obj = bsn_flow_idle_enable_get_reply()
3137 _version = reader.read("!B")[0]
3138 assert(_version == 5)
3139 _type = reader.read("!B")[0]
3140 assert(_type == 4)
3141 _length = reader.read("!H")[0]
3142 orig_reader = reader
3143 reader = orig_reader.slice(_length, 4)
3144 obj.xid = reader.read("!L")[0]
3145 _experimenter = reader.read("!L")[0]
3146 assert(_experimenter == 6035143)
3147 _subtype = reader.read("!L")[0]
3148 assert(_subtype == 39)
3149 obj.enabled = reader.read("!L")[0]
3150 return obj
3151
3152 def __eq__(self, other):
3153 if type(self) != type(other): return False
3154 if self.xid != other.xid: return False
3155 if self.enabled != other.enabled: return False
3156 return True
3157
3158 def pretty_print(self, q):
3159 q.text("bsn_flow_idle_enable_get_reply {")
3160 with q.group():
3161 with q.indent(2):
3162 q.breakable()
3163 q.text("xid = ");
3164 if self.xid != None:
3165 q.text("%#x" % self.xid)
3166 else:
3167 q.text('None')
3168 q.text(","); q.breakable()
3169 q.text("enabled = ");
3170 q.text("%#x" % self.enabled)
3171 q.breakable()
3172 q.text('}')
3173
3174bsn_header.subtypes[39] = bsn_flow_idle_enable_get_reply
3175
3176class bsn_flow_idle_enable_get_request(bsn_header):
3177 version = 5
3178 type = 4
3179 experimenter = 6035143
3180 subtype = 38
3181
3182 def __init__(self, xid=None):
3183 if xid != None:
3184 self.xid = xid
3185 else:
3186 self.xid = None
3187 return
3188
3189 def pack(self):
3190 packed = []
3191 packed.append(struct.pack("!B", self.version))
3192 packed.append(struct.pack("!B", self.type))
3193 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3194 packed.append(struct.pack("!L", self.xid))
3195 packed.append(struct.pack("!L", self.experimenter))
3196 packed.append(struct.pack("!L", self.subtype))
3197 length = sum([len(x) for x in packed])
3198 packed[2] = struct.pack("!H", length)
3199 return ''.join(packed)
3200
3201 @staticmethod
3202 def unpack(reader):
3203 obj = bsn_flow_idle_enable_get_request()
3204 _version = reader.read("!B")[0]
3205 assert(_version == 5)
3206 _type = reader.read("!B")[0]
3207 assert(_type == 4)
3208 _length = reader.read("!H")[0]
3209 orig_reader = reader
3210 reader = orig_reader.slice(_length, 4)
3211 obj.xid = reader.read("!L")[0]
3212 _experimenter = reader.read("!L")[0]
3213 assert(_experimenter == 6035143)
3214 _subtype = reader.read("!L")[0]
3215 assert(_subtype == 38)
3216 return obj
3217
3218 def __eq__(self, other):
3219 if type(self) != type(other): return False
3220 if self.xid != other.xid: return False
3221 return True
3222
3223 def pretty_print(self, q):
3224 q.text("bsn_flow_idle_enable_get_request {")
3225 with q.group():
3226 with q.indent(2):
3227 q.breakable()
3228 q.text("xid = ");
3229 if self.xid != None:
3230 q.text("%#x" % self.xid)
3231 else:
3232 q.text('None')
3233 q.breakable()
3234 q.text('}')
3235
3236bsn_header.subtypes[38] = bsn_flow_idle_enable_get_request
3237
3238class bsn_flow_idle_enable_set_reply(bsn_header):
3239 version = 5
3240 type = 4
3241 experimenter = 6035143
3242 subtype = 37
3243
3244 def __init__(self, xid=None, enable=None, status=None):
3245 if xid != None:
3246 self.xid = xid
3247 else:
3248 self.xid = None
3249 if enable != None:
3250 self.enable = enable
3251 else:
3252 self.enable = 0
3253 if status != None:
3254 self.status = status
3255 else:
3256 self.status = 0
3257 return
3258
3259 def pack(self):
3260 packed = []
3261 packed.append(struct.pack("!B", self.version))
3262 packed.append(struct.pack("!B", self.type))
3263 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3264 packed.append(struct.pack("!L", self.xid))
3265 packed.append(struct.pack("!L", self.experimenter))
3266 packed.append(struct.pack("!L", self.subtype))
3267 packed.append(struct.pack("!L", self.enable))
3268 packed.append(struct.pack("!L", self.status))
3269 length = sum([len(x) for x in packed])
3270 packed[2] = struct.pack("!H", length)
3271 return ''.join(packed)
3272
3273 @staticmethod
3274 def unpack(reader):
3275 obj = bsn_flow_idle_enable_set_reply()
3276 _version = reader.read("!B")[0]
3277 assert(_version == 5)
3278 _type = reader.read("!B")[0]
3279 assert(_type == 4)
3280 _length = reader.read("!H")[0]
3281 orig_reader = reader
3282 reader = orig_reader.slice(_length, 4)
3283 obj.xid = reader.read("!L")[0]
3284 _experimenter = reader.read("!L")[0]
3285 assert(_experimenter == 6035143)
3286 _subtype = reader.read("!L")[0]
3287 assert(_subtype == 37)
3288 obj.enable = reader.read("!L")[0]
3289 obj.status = reader.read("!L")[0]
3290 return obj
3291
3292 def __eq__(self, other):
3293 if type(self) != type(other): return False
3294 if self.xid != other.xid: return False
3295 if self.enable != other.enable: return False
3296 if self.status != other.status: return False
3297 return True
3298
3299 def pretty_print(self, q):
3300 q.text("bsn_flow_idle_enable_set_reply {")
3301 with q.group():
3302 with q.indent(2):
3303 q.breakable()
3304 q.text("xid = ");
3305 if self.xid != None:
3306 q.text("%#x" % self.xid)
3307 else:
3308 q.text('None')
3309 q.text(","); q.breakable()
3310 q.text("enable = ");
3311 q.text("%#x" % self.enable)
3312 q.text(","); q.breakable()
3313 q.text("status = ");
3314 q.text("%#x" % self.status)
3315 q.breakable()
3316 q.text('}')
3317
3318bsn_header.subtypes[37] = bsn_flow_idle_enable_set_reply
3319
3320class bsn_flow_idle_enable_set_request(bsn_header):
3321 version = 5
3322 type = 4
3323 experimenter = 6035143
3324 subtype = 36
3325
3326 def __init__(self, xid=None, enable=None):
3327 if xid != None:
3328 self.xid = xid
3329 else:
3330 self.xid = None
3331 if enable != None:
3332 self.enable = enable
3333 else:
3334 self.enable = 0
3335 return
3336
3337 def pack(self):
3338 packed = []
3339 packed.append(struct.pack("!B", self.version))
3340 packed.append(struct.pack("!B", self.type))
3341 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3342 packed.append(struct.pack("!L", self.xid))
3343 packed.append(struct.pack("!L", self.experimenter))
3344 packed.append(struct.pack("!L", self.subtype))
3345 packed.append(struct.pack("!L", self.enable))
3346 length = sum([len(x) for x in packed])
3347 packed[2] = struct.pack("!H", length)
3348 return ''.join(packed)
3349
3350 @staticmethod
3351 def unpack(reader):
3352 obj = bsn_flow_idle_enable_set_request()
3353 _version = reader.read("!B")[0]
3354 assert(_version == 5)
3355 _type = reader.read("!B")[0]
3356 assert(_type == 4)
3357 _length = reader.read("!H")[0]
3358 orig_reader = reader
3359 reader = orig_reader.slice(_length, 4)
3360 obj.xid = reader.read("!L")[0]
3361 _experimenter = reader.read("!L")[0]
3362 assert(_experimenter == 6035143)
3363 _subtype = reader.read("!L")[0]
3364 assert(_subtype == 36)
3365 obj.enable = reader.read("!L")[0]
3366 return obj
3367
3368 def __eq__(self, other):
3369 if type(self) != type(other): return False
3370 if self.xid != other.xid: return False
3371 if self.enable != other.enable: return False
3372 return True
3373
3374 def pretty_print(self, q):
3375 q.text("bsn_flow_idle_enable_set_request {")
3376 with q.group():
3377 with q.indent(2):
3378 q.breakable()
3379 q.text("xid = ");
3380 if self.xid != None:
3381 q.text("%#x" % self.xid)
3382 else:
3383 q.text('None')
3384 q.text(","); q.breakable()
3385 q.text("enable = ");
3386 q.text("%#x" % self.enable)
3387 q.breakable()
3388 q.text('}')
3389
3390bsn_header.subtypes[36] = bsn_flow_idle_enable_set_request
3391
3392class bsn_generic_async(bsn_header):
3393 version = 5
3394 type = 4
3395 experimenter = 6035143
3396 subtype = 68
3397
3398 def __init__(self, xid=None, name=None, tlvs=None):
3399 if xid != None:
3400 self.xid = xid
3401 else:
3402 self.xid = None
3403 if name != None:
3404 self.name = name
3405 else:
3406 self.name = ""
3407 if tlvs != None:
3408 self.tlvs = tlvs
3409 else:
3410 self.tlvs = []
3411 return
3412
3413 def pack(self):
3414 packed = []
3415 packed.append(struct.pack("!B", self.version))
3416 packed.append(struct.pack("!B", self.type))
3417 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3418 packed.append(struct.pack("!L", self.xid))
3419 packed.append(struct.pack("!L", self.experimenter))
3420 packed.append(struct.pack("!L", self.subtype))
3421 packed.append(struct.pack("!64s", self.name))
3422 packed.append(loxi.generic_util.pack_list(self.tlvs))
3423 length = sum([len(x) for x in packed])
3424 packed[2] = struct.pack("!H", length)
3425 return ''.join(packed)
3426
3427 @staticmethod
3428 def unpack(reader):
3429 obj = bsn_generic_async()
3430 _version = reader.read("!B")[0]
3431 assert(_version == 5)
3432 _type = reader.read("!B")[0]
3433 assert(_type == 4)
3434 _length = reader.read("!H")[0]
3435 orig_reader = reader
3436 reader = orig_reader.slice(_length, 4)
3437 obj.xid = reader.read("!L")[0]
3438 _experimenter = reader.read("!L")[0]
3439 assert(_experimenter == 6035143)
3440 _subtype = reader.read("!L")[0]
3441 assert(_subtype == 68)
3442 obj.name = reader.read("!64s")[0].rstrip("\x00")
3443 obj.tlvs = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
3444 return obj
3445
3446 def __eq__(self, other):
3447 if type(self) != type(other): return False
3448 if self.xid != other.xid: return False
3449 if self.name != other.name: return False
3450 if self.tlvs != other.tlvs: return False
3451 return True
3452
3453 def pretty_print(self, q):
3454 q.text("bsn_generic_async {")
3455 with q.group():
3456 with q.indent(2):
3457 q.breakable()
3458 q.text("xid = ");
3459 if self.xid != None:
3460 q.text("%#x" % self.xid)
3461 else:
3462 q.text('None')
3463 q.text(","); q.breakable()
3464 q.text("name = ");
3465 q.pp(self.name)
3466 q.text(","); q.breakable()
3467 q.text("tlvs = ");
3468 q.pp(self.tlvs)
3469 q.breakable()
3470 q.text('}')
3471
3472bsn_header.subtypes[68] = bsn_generic_async
3473
3474class bsn_generic_stats_reply(bsn_stats_reply):
3475 version = 5
3476 type = 19
3477 stats_type = 65535
3478 experimenter = 6035143
3479 subtype = 16
3480
3481 def __init__(self, xid=None, flags=None, entries=None):
3482 if xid != None:
3483 self.xid = xid
3484 else:
3485 self.xid = None
3486 if flags != None:
3487 self.flags = flags
3488 else:
3489 self.flags = 0
3490 if entries != None:
3491 self.entries = entries
3492 else:
3493 self.entries = []
3494 return
3495
3496 def pack(self):
3497 packed = []
3498 packed.append(struct.pack("!B", self.version))
3499 packed.append(struct.pack("!B", self.type))
3500 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3501 packed.append(struct.pack("!L", self.xid))
3502 packed.append(struct.pack("!H", self.stats_type))
3503 packed.append(struct.pack("!H", self.flags))
3504 packed.append('\x00' * 4)
3505 packed.append(struct.pack("!L", self.experimenter))
3506 packed.append(struct.pack("!L", self.subtype))
3507 packed.append(loxi.generic_util.pack_list(self.entries))
3508 length = sum([len(x) for x in packed])
3509 packed[2] = struct.pack("!H", length)
3510 return ''.join(packed)
3511
3512 @staticmethod
3513 def unpack(reader):
3514 obj = bsn_generic_stats_reply()
3515 _version = reader.read("!B")[0]
3516 assert(_version == 5)
3517 _type = reader.read("!B")[0]
3518 assert(_type == 19)
3519 _length = reader.read("!H")[0]
3520 orig_reader = reader
3521 reader = orig_reader.slice(_length, 4)
3522 obj.xid = reader.read("!L")[0]
3523 _stats_type = reader.read("!H")[0]
3524 assert(_stats_type == 65535)
3525 obj.flags = reader.read("!H")[0]
3526 reader.skip(4)
3527 _experimenter = reader.read("!L")[0]
3528 assert(_experimenter == 6035143)
3529 _subtype = reader.read("!L")[0]
3530 assert(_subtype == 16)
3531 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_generic_stats_entry.unpack)
3532 return obj
3533
3534 def __eq__(self, other):
3535 if type(self) != type(other): return False
3536 if self.xid != other.xid: return False
3537 if self.flags != other.flags: return False
3538 if self.entries != other.entries: return False
3539 return True
3540
3541 def pretty_print(self, q):
3542 q.text("bsn_generic_stats_reply {")
3543 with q.group():
3544 with q.indent(2):
3545 q.breakable()
3546 q.text("xid = ");
3547 if self.xid != None:
3548 q.text("%#x" % self.xid)
3549 else:
3550 q.text('None')
3551 q.text(","); q.breakable()
3552 q.text("flags = ");
3553 q.text("%#x" % self.flags)
3554 q.text(","); q.breakable()
3555 q.text("entries = ");
3556 q.pp(self.entries)
3557 q.breakable()
3558 q.text('}')
3559
3560bsn_stats_reply.subtypes[16] = bsn_generic_stats_reply
3561
3562class bsn_generic_stats_request(bsn_stats_request):
3563 version = 5
3564 type = 18
3565 stats_type = 65535
3566 experimenter = 6035143
3567 subtype = 16
3568
3569 def __init__(self, xid=None, flags=None, name=None, tlvs=None):
3570 if xid != None:
3571 self.xid = xid
3572 else:
3573 self.xid = None
3574 if flags != None:
3575 self.flags = flags
3576 else:
3577 self.flags = 0
3578 if name != None:
3579 self.name = name
3580 else:
3581 self.name = ""
3582 if tlvs != None:
3583 self.tlvs = tlvs
3584 else:
3585 self.tlvs = []
3586 return
3587
3588 def pack(self):
3589 packed = []
3590 packed.append(struct.pack("!B", self.version))
3591 packed.append(struct.pack("!B", self.type))
3592 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3593 packed.append(struct.pack("!L", self.xid))
3594 packed.append(struct.pack("!H", self.stats_type))
3595 packed.append(struct.pack("!H", self.flags))
3596 packed.append('\x00' * 4)
3597 packed.append(struct.pack("!L", self.experimenter))
3598 packed.append(struct.pack("!L", self.subtype))
3599 packed.append(struct.pack("!64s", self.name))
3600 packed.append(loxi.generic_util.pack_list(self.tlvs))
3601 length = sum([len(x) for x in packed])
3602 packed[2] = struct.pack("!H", length)
3603 return ''.join(packed)
3604
3605 @staticmethod
3606 def unpack(reader):
3607 obj = bsn_generic_stats_request()
3608 _version = reader.read("!B")[0]
3609 assert(_version == 5)
3610 _type = reader.read("!B")[0]
3611 assert(_type == 18)
3612 _length = reader.read("!H")[0]
3613 orig_reader = reader
3614 reader = orig_reader.slice(_length, 4)
3615 obj.xid = reader.read("!L")[0]
3616 _stats_type = reader.read("!H")[0]
3617 assert(_stats_type == 65535)
3618 obj.flags = reader.read("!H")[0]
3619 reader.skip(4)
3620 _experimenter = reader.read("!L")[0]
3621 assert(_experimenter == 6035143)
3622 _subtype = reader.read("!L")[0]
3623 assert(_subtype == 16)
3624 obj.name = reader.read("!64s")[0].rstrip("\x00")
3625 obj.tlvs = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
3626 return obj
3627
3628 def __eq__(self, other):
3629 if type(self) != type(other): return False
3630 if self.xid != other.xid: return False
3631 if self.flags != other.flags: return False
3632 if self.name != other.name: return False
3633 if self.tlvs != other.tlvs: return False
3634 return True
3635
3636 def pretty_print(self, q):
3637 q.text("bsn_generic_stats_request {")
3638 with q.group():
3639 with q.indent(2):
3640 q.breakable()
3641 q.text("xid = ");
3642 if self.xid != None:
3643 q.text("%#x" % self.xid)
3644 else:
3645 q.text('None')
3646 q.text(","); q.breakable()
3647 q.text("flags = ");
3648 q.text("%#x" % self.flags)
3649 q.text(","); q.breakable()
3650 q.text("name = ");
3651 q.pp(self.name)
3652 q.text(","); q.breakable()
3653 q.text("tlvs = ");
3654 q.pp(self.tlvs)
3655 q.breakable()
3656 q.text('}')
3657
3658bsn_stats_request.subtypes[16] = bsn_generic_stats_request
3659
3660class bsn_gentable_bucket_stats_reply(bsn_stats_reply):
3661 version = 5
3662 type = 19
3663 stats_type = 65535
3664 experimenter = 6035143
3665 subtype = 5
3666
3667 def __init__(self, xid=None, flags=None, entries=None):
3668 if xid != None:
3669 self.xid = xid
3670 else:
3671 self.xid = None
3672 if flags != None:
3673 self.flags = flags
3674 else:
3675 self.flags = 0
3676 if entries != None:
3677 self.entries = entries
3678 else:
3679 self.entries = []
3680 return
3681
3682 def pack(self):
3683 packed = []
3684 packed.append(struct.pack("!B", self.version))
3685 packed.append(struct.pack("!B", self.type))
3686 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3687 packed.append(struct.pack("!L", self.xid))
3688 packed.append(struct.pack("!H", self.stats_type))
3689 packed.append(struct.pack("!H", self.flags))
3690 packed.append('\x00' * 4)
3691 packed.append(struct.pack("!L", self.experimenter))
3692 packed.append(struct.pack("!L", self.subtype))
3693 packed.append(loxi.generic_util.pack_list(self.entries))
3694 length = sum([len(x) for x in packed])
3695 packed[2] = struct.pack("!H", length)
3696 return ''.join(packed)
3697
3698 @staticmethod
3699 def unpack(reader):
3700 obj = bsn_gentable_bucket_stats_reply()
3701 _version = reader.read("!B")[0]
3702 assert(_version == 5)
3703 _type = reader.read("!B")[0]
3704 assert(_type == 19)
3705 _length = reader.read("!H")[0]
3706 orig_reader = reader
3707 reader = orig_reader.slice(_length, 4)
3708 obj.xid = reader.read("!L")[0]
3709 _stats_type = reader.read("!H")[0]
3710 assert(_stats_type == 65535)
3711 obj.flags = reader.read("!H")[0]
3712 reader.skip(4)
3713 _experimenter = reader.read("!L")[0]
3714 assert(_experimenter == 6035143)
3715 _subtype = reader.read("!L")[0]
3716 assert(_subtype == 5)
3717 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_bucket_stats_entry.unpack)
3718 return obj
3719
3720 def __eq__(self, other):
3721 if type(self) != type(other): return False
3722 if self.xid != other.xid: return False
3723 if self.flags != other.flags: return False
3724 if self.entries != other.entries: return False
3725 return True
3726
3727 def pretty_print(self, q):
3728 q.text("bsn_gentable_bucket_stats_reply {")
3729 with q.group():
3730 with q.indent(2):
3731 q.breakable()
3732 q.text("xid = ");
3733 if self.xid != None:
3734 q.text("%#x" % self.xid)
3735 else:
3736 q.text('None')
3737 q.text(","); q.breakable()
3738 q.text("flags = ");
3739 q.text("%#x" % self.flags)
3740 q.text(","); q.breakable()
3741 q.text("entries = ");
3742 q.pp(self.entries)
3743 q.breakable()
3744 q.text('}')
3745
3746bsn_stats_reply.subtypes[5] = bsn_gentable_bucket_stats_reply
3747
3748class bsn_gentable_bucket_stats_request(bsn_stats_request):
3749 version = 5
3750 type = 18
3751 stats_type = 65535
3752 experimenter = 6035143
3753 subtype = 5
3754
3755 def __init__(self, xid=None, flags=None, table_id=None):
3756 if xid != None:
3757 self.xid = xid
3758 else:
3759 self.xid = None
3760 if flags != None:
3761 self.flags = flags
3762 else:
3763 self.flags = 0
3764 if table_id != None:
3765 self.table_id = table_id
3766 else:
3767 self.table_id = 0
3768 return
3769
3770 def pack(self):
3771 packed = []
3772 packed.append(struct.pack("!B", self.version))
3773 packed.append(struct.pack("!B", self.type))
3774 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3775 packed.append(struct.pack("!L", self.xid))
3776 packed.append(struct.pack("!H", self.stats_type))
3777 packed.append(struct.pack("!H", self.flags))
3778 packed.append('\x00' * 4)
3779 packed.append(struct.pack("!L", self.experimenter))
3780 packed.append(struct.pack("!L", self.subtype))
3781 packed.append(struct.pack("!H", self.table_id))
3782 length = sum([len(x) for x in packed])
3783 packed[2] = struct.pack("!H", length)
3784 return ''.join(packed)
3785
3786 @staticmethod
3787 def unpack(reader):
3788 obj = bsn_gentable_bucket_stats_request()
3789 _version = reader.read("!B")[0]
3790 assert(_version == 5)
3791 _type = reader.read("!B")[0]
3792 assert(_type == 18)
3793 _length = reader.read("!H")[0]
3794 orig_reader = reader
3795 reader = orig_reader.slice(_length, 4)
3796 obj.xid = reader.read("!L")[0]
3797 _stats_type = reader.read("!H")[0]
3798 assert(_stats_type == 65535)
3799 obj.flags = reader.read("!H")[0]
3800 reader.skip(4)
3801 _experimenter = reader.read("!L")[0]
3802 assert(_experimenter == 6035143)
3803 _subtype = reader.read("!L")[0]
3804 assert(_subtype == 5)
3805 obj.table_id = reader.read("!H")[0]
3806 return obj
3807
3808 def __eq__(self, other):
3809 if type(self) != type(other): return False
3810 if self.xid != other.xid: return False
3811 if self.flags != other.flags: return False
3812 if self.table_id != other.table_id: return False
3813 return True
3814
3815 def pretty_print(self, q):
3816 q.text("bsn_gentable_bucket_stats_request {")
3817 with q.group():
3818 with q.indent(2):
3819 q.breakable()
3820 q.text("xid = ");
3821 if self.xid != None:
3822 q.text("%#x" % self.xid)
3823 else:
3824 q.text('None')
3825 q.text(","); q.breakable()
3826 q.text("flags = ");
3827 q.text("%#x" % self.flags)
3828 q.text(","); q.breakable()
3829 q.text("table_id = ");
3830 q.text("%#x" % self.table_id)
3831 q.breakable()
3832 q.text('}')
3833
3834bsn_stats_request.subtypes[5] = bsn_gentable_bucket_stats_request
3835
3836class bsn_gentable_clear_reply(bsn_header):
3837 version = 5
3838 type = 4
3839 experimenter = 6035143
3840 subtype = 49
3841
3842 def __init__(self, xid=None, table_id=None, deleted_count=None, error_count=None):
3843 if xid != None:
3844 self.xid = xid
3845 else:
3846 self.xid = None
3847 if table_id != None:
3848 self.table_id = table_id
3849 else:
3850 self.table_id = 0
3851 if deleted_count != None:
3852 self.deleted_count = deleted_count
3853 else:
3854 self.deleted_count = 0
3855 if error_count != None:
3856 self.error_count = error_count
3857 else:
3858 self.error_count = 0
3859 return
3860
3861 def pack(self):
3862 packed = []
3863 packed.append(struct.pack("!B", self.version))
3864 packed.append(struct.pack("!B", self.type))
3865 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3866 packed.append(struct.pack("!L", self.xid))
3867 packed.append(struct.pack("!L", self.experimenter))
3868 packed.append(struct.pack("!L", self.subtype))
3869 packed.append(struct.pack("!H", self.table_id))
3870 packed.append('\x00' * 2)
3871 packed.append(struct.pack("!L", self.deleted_count))
3872 packed.append(struct.pack("!L", self.error_count))
3873 length = sum([len(x) for x in packed])
3874 packed[2] = struct.pack("!H", length)
3875 return ''.join(packed)
3876
3877 @staticmethod
3878 def unpack(reader):
3879 obj = bsn_gentable_clear_reply()
3880 _version = reader.read("!B")[0]
3881 assert(_version == 5)
3882 _type = reader.read("!B")[0]
3883 assert(_type == 4)
3884 _length = reader.read("!H")[0]
3885 orig_reader = reader
3886 reader = orig_reader.slice(_length, 4)
3887 obj.xid = reader.read("!L")[0]
3888 _experimenter = reader.read("!L")[0]
3889 assert(_experimenter == 6035143)
3890 _subtype = reader.read("!L")[0]
3891 assert(_subtype == 49)
3892 obj.table_id = reader.read("!H")[0]
3893 reader.skip(2)
3894 obj.deleted_count = reader.read("!L")[0]
3895 obj.error_count = reader.read("!L")[0]
3896 return obj
3897
3898 def __eq__(self, other):
3899 if type(self) != type(other): return False
3900 if self.xid != other.xid: return False
3901 if self.table_id != other.table_id: return False
3902 if self.deleted_count != other.deleted_count: return False
3903 if self.error_count != other.error_count: return False
3904 return True
3905
3906 def pretty_print(self, q):
3907 q.text("bsn_gentable_clear_reply {")
3908 with q.group():
3909 with q.indent(2):
3910 q.breakable()
3911 q.text("xid = ");
3912 if self.xid != None:
3913 q.text("%#x" % self.xid)
3914 else:
3915 q.text('None')
3916 q.text(","); q.breakable()
3917 q.text("table_id = ");
3918 q.text("%#x" % self.table_id)
3919 q.text(","); q.breakable()
3920 q.text("deleted_count = ");
3921 q.text("%#x" % self.deleted_count)
3922 q.text(","); q.breakable()
3923 q.text("error_count = ");
3924 q.text("%#x" % self.error_count)
3925 q.breakable()
3926 q.text('}')
3927
3928bsn_header.subtypes[49] = bsn_gentable_clear_reply
3929
3930class bsn_gentable_clear_request(bsn_header):
3931 version = 5
3932 type = 4
3933 experimenter = 6035143
3934 subtype = 48
3935
3936 def __init__(self, xid=None, table_id=None, checksum=None, checksum_mask=None):
3937 if xid != None:
3938 self.xid = xid
3939 else:
3940 self.xid = None
3941 if table_id != None:
3942 self.table_id = table_id
3943 else:
3944 self.table_id = 0
3945 if checksum != None:
3946 self.checksum = checksum
3947 else:
3948 self.checksum = 0
3949 if checksum_mask != None:
3950 self.checksum_mask = checksum_mask
3951 else:
3952 self.checksum_mask = 0
3953 return
3954
3955 def pack(self):
3956 packed = []
3957 packed.append(struct.pack("!B", self.version))
3958 packed.append(struct.pack("!B", self.type))
3959 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3960 packed.append(struct.pack("!L", self.xid))
3961 packed.append(struct.pack("!L", self.experimenter))
3962 packed.append(struct.pack("!L", self.subtype))
3963 packed.append(struct.pack("!H", self.table_id))
3964 packed.append('\x00' * 2)
3965 packed.append(util.pack_checksum_128(self.checksum))
3966 packed.append(util.pack_checksum_128(self.checksum_mask))
3967 length = sum([len(x) for x in packed])
3968 packed[2] = struct.pack("!H", length)
3969 return ''.join(packed)
3970
3971 @staticmethod
3972 def unpack(reader):
3973 obj = bsn_gentable_clear_request()
3974 _version = reader.read("!B")[0]
3975 assert(_version == 5)
3976 _type = reader.read("!B")[0]
3977 assert(_type == 4)
3978 _length = reader.read("!H")[0]
3979 orig_reader = reader
3980 reader = orig_reader.slice(_length, 4)
3981 obj.xid = reader.read("!L")[0]
3982 _experimenter = reader.read("!L")[0]
3983 assert(_experimenter == 6035143)
3984 _subtype = reader.read("!L")[0]
3985 assert(_subtype == 48)
3986 obj.table_id = reader.read("!H")[0]
3987 reader.skip(2)
3988 obj.checksum = util.unpack_checksum_128(reader)
3989 obj.checksum_mask = util.unpack_checksum_128(reader)
3990 return obj
3991
3992 def __eq__(self, other):
3993 if type(self) != type(other): return False
3994 if self.xid != other.xid: return False
3995 if self.table_id != other.table_id: return False
3996 if self.checksum != other.checksum: return False
3997 if self.checksum_mask != other.checksum_mask: return False
3998 return True
3999
4000 def pretty_print(self, q):
4001 q.text("bsn_gentable_clear_request {")
4002 with q.group():
4003 with q.indent(2):
4004 q.breakable()
4005 q.text("xid = ");
4006 if self.xid != None:
4007 q.text("%#x" % self.xid)
4008 else:
4009 q.text('None')
4010 q.text(","); q.breakable()
4011 q.text("table_id = ");
4012 q.text("%#x" % self.table_id)
4013 q.text(","); q.breakable()
4014 q.text("checksum = ");
4015 q.pp(self.checksum)
4016 q.text(","); q.breakable()
4017 q.text("checksum_mask = ");
4018 q.pp(self.checksum_mask)
4019 q.breakable()
4020 q.text('}')
4021
4022bsn_header.subtypes[48] = bsn_gentable_clear_request
4023
4024class bsn_gentable_desc_stats_reply(bsn_stats_reply):
4025 version = 5
4026 type = 19
4027 stats_type = 65535
4028 experimenter = 6035143
4029 subtype = 4
4030
4031 def __init__(self, xid=None, flags=None, entries=None):
4032 if xid != None:
4033 self.xid = xid
4034 else:
4035 self.xid = None
4036 if flags != None:
4037 self.flags = flags
4038 else:
4039 self.flags = 0
4040 if entries != None:
4041 self.entries = entries
4042 else:
4043 self.entries = []
4044 return
4045
4046 def pack(self):
4047 packed = []
4048 packed.append(struct.pack("!B", self.version))
4049 packed.append(struct.pack("!B", self.type))
4050 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4051 packed.append(struct.pack("!L", self.xid))
4052 packed.append(struct.pack("!H", self.stats_type))
4053 packed.append(struct.pack("!H", self.flags))
4054 packed.append('\x00' * 4)
4055 packed.append(struct.pack("!L", self.experimenter))
4056 packed.append(struct.pack("!L", self.subtype))
4057 packed.append(loxi.generic_util.pack_list(self.entries))
4058 length = sum([len(x) for x in packed])
4059 packed[2] = struct.pack("!H", length)
4060 return ''.join(packed)
4061
4062 @staticmethod
4063 def unpack(reader):
4064 obj = bsn_gentable_desc_stats_reply()
4065 _version = reader.read("!B")[0]
4066 assert(_version == 5)
4067 _type = reader.read("!B")[0]
4068 assert(_type == 19)
4069 _length = reader.read("!H")[0]
4070 orig_reader = reader
4071 reader = orig_reader.slice(_length, 4)
4072 obj.xid = reader.read("!L")[0]
4073 _stats_type = reader.read("!H")[0]
4074 assert(_stats_type == 65535)
4075 obj.flags = reader.read("!H")[0]
4076 reader.skip(4)
4077 _experimenter = reader.read("!L")[0]
4078 assert(_experimenter == 6035143)
4079 _subtype = reader.read("!L")[0]
4080 assert(_subtype == 4)
4081 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_desc_stats_entry.unpack)
4082 return obj
4083
4084 def __eq__(self, other):
4085 if type(self) != type(other): return False
4086 if self.xid != other.xid: return False
4087 if self.flags != other.flags: return False
4088 if self.entries != other.entries: return False
4089 return True
4090
4091 def pretty_print(self, q):
4092 q.text("bsn_gentable_desc_stats_reply {")
4093 with q.group():
4094 with q.indent(2):
4095 q.breakable()
4096 q.text("xid = ");
4097 if self.xid != None:
4098 q.text("%#x" % self.xid)
4099 else:
4100 q.text('None')
4101 q.text(","); q.breakable()
4102 q.text("flags = ");
4103 q.text("%#x" % self.flags)
4104 q.text(","); q.breakable()
4105 q.text("entries = ");
4106 q.pp(self.entries)
4107 q.breakable()
4108 q.text('}')
4109
4110bsn_stats_reply.subtypes[4] = bsn_gentable_desc_stats_reply
4111
4112class bsn_gentable_desc_stats_request(bsn_stats_request):
4113 version = 5
4114 type = 18
4115 stats_type = 65535
4116 experimenter = 6035143
4117 subtype = 4
4118
4119 def __init__(self, xid=None, flags=None):
4120 if xid != None:
4121 self.xid = xid
4122 else:
4123 self.xid = None
4124 if flags != None:
4125 self.flags = flags
4126 else:
4127 self.flags = 0
4128 return
4129
4130 def pack(self):
4131 packed = []
4132 packed.append(struct.pack("!B", self.version))
4133 packed.append(struct.pack("!B", self.type))
4134 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4135 packed.append(struct.pack("!L", self.xid))
4136 packed.append(struct.pack("!H", self.stats_type))
4137 packed.append(struct.pack("!H", self.flags))
4138 packed.append('\x00' * 4)
4139 packed.append(struct.pack("!L", self.experimenter))
4140 packed.append(struct.pack("!L", self.subtype))
4141 length = sum([len(x) for x in packed])
4142 packed[2] = struct.pack("!H", length)
4143 return ''.join(packed)
4144
4145 @staticmethod
4146 def unpack(reader):
4147 obj = bsn_gentable_desc_stats_request()
4148 _version = reader.read("!B")[0]
4149 assert(_version == 5)
4150 _type = reader.read("!B")[0]
4151 assert(_type == 18)
4152 _length = reader.read("!H")[0]
4153 orig_reader = reader
4154 reader = orig_reader.slice(_length, 4)
4155 obj.xid = reader.read("!L")[0]
4156 _stats_type = reader.read("!H")[0]
4157 assert(_stats_type == 65535)
4158 obj.flags = reader.read("!H")[0]
4159 reader.skip(4)
4160 _experimenter = reader.read("!L")[0]
4161 assert(_experimenter == 6035143)
4162 _subtype = reader.read("!L")[0]
4163 assert(_subtype == 4)
4164 return obj
4165
4166 def __eq__(self, other):
4167 if type(self) != type(other): return False
4168 if self.xid != other.xid: return False
4169 if self.flags != other.flags: return False
4170 return True
4171
4172 def pretty_print(self, q):
4173 q.text("bsn_gentable_desc_stats_request {")
4174 with q.group():
4175 with q.indent(2):
4176 q.breakable()
4177 q.text("xid = ");
4178 if self.xid != None:
4179 q.text("%#x" % self.xid)
4180 else:
4181 q.text('None')
4182 q.text(","); q.breakable()
4183 q.text("flags = ");
4184 q.text("%#x" % self.flags)
4185 q.breakable()
4186 q.text('}')
4187
4188bsn_stats_request.subtypes[4] = bsn_gentable_desc_stats_request
4189
4190class bsn_gentable_entry_add(bsn_header):
4191 version = 5
4192 type = 4
4193 experimenter = 6035143
4194 subtype = 46
4195
4196 def __init__(self, xid=None, table_id=None, checksum=None, key=None, value=None):
4197 if xid != None:
4198 self.xid = xid
4199 else:
4200 self.xid = None
4201 if table_id != None:
4202 self.table_id = table_id
4203 else:
4204 self.table_id = 0
4205 if checksum != None:
4206 self.checksum = checksum
4207 else:
4208 self.checksum = 0
4209 if key != None:
4210 self.key = key
4211 else:
4212 self.key = []
4213 if value != None:
4214 self.value = value
4215 else:
4216 self.value = []
4217 return
4218
4219 def pack(self):
4220 packed = []
4221 packed.append(struct.pack("!B", self.version))
4222 packed.append(struct.pack("!B", self.type))
4223 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4224 packed.append(struct.pack("!L", self.xid))
4225 packed.append(struct.pack("!L", self.experimenter))
4226 packed.append(struct.pack("!L", self.subtype))
4227 packed.append(struct.pack("!H", self.table_id))
4228 packed.append(struct.pack("!H", 0)) # placeholder for key_length at index 7
4229 packed.append(util.pack_checksum_128(self.checksum))
4230 packed.append(loxi.generic_util.pack_list(self.key))
4231 packed[7] = struct.pack("!H", len(packed[-1]))
4232 packed.append(loxi.generic_util.pack_list(self.value))
4233 length = sum([len(x) for x in packed])
4234 packed[2] = struct.pack("!H", length)
4235 return ''.join(packed)
4236
4237 @staticmethod
4238 def unpack(reader):
4239 obj = bsn_gentable_entry_add()
4240 _version = reader.read("!B")[0]
4241 assert(_version == 5)
4242 _type = reader.read("!B")[0]
4243 assert(_type == 4)
4244 _length = reader.read("!H")[0]
4245 orig_reader = reader
4246 reader = orig_reader.slice(_length, 4)
4247 obj.xid = reader.read("!L")[0]
4248 _experimenter = reader.read("!L")[0]
4249 assert(_experimenter == 6035143)
4250 _subtype = reader.read("!L")[0]
4251 assert(_subtype == 46)
4252 obj.table_id = reader.read("!H")[0]
4253 _key_length = reader.read("!H")[0]
4254 obj.checksum = util.unpack_checksum_128(reader)
4255 obj.key = loxi.generic_util.unpack_list(reader.slice(_key_length), ofp.bsn_tlv.bsn_tlv.unpack)
4256 obj.value = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
4257 return obj
4258
4259 def __eq__(self, other):
4260 if type(self) != type(other): return False
4261 if self.xid != other.xid: return False
4262 if self.table_id != other.table_id: return False
4263 if self.checksum != other.checksum: return False
4264 if self.key != other.key: return False
4265 if self.value != other.value: return False
4266 return True
4267
4268 def pretty_print(self, q):
4269 q.text("bsn_gentable_entry_add {")
4270 with q.group():
4271 with q.indent(2):
4272 q.breakable()
4273 q.text("xid = ");
4274 if self.xid != None:
4275 q.text("%#x" % self.xid)
4276 else:
4277 q.text('None')
4278 q.text(","); q.breakable()
4279 q.text("table_id = ");
4280 q.text("%#x" % self.table_id)
4281 q.text(","); q.breakable()
4282 q.text("checksum = ");
4283 q.pp(self.checksum)
4284 q.text(","); q.breakable()
4285 q.text("key = ");
4286 q.pp(self.key)
4287 q.text(","); q.breakable()
4288 q.text("value = ");
4289 q.pp(self.value)
4290 q.breakable()
4291 q.text('}')
4292
4293bsn_header.subtypes[46] = bsn_gentable_entry_add
4294
4295class bsn_gentable_entry_delete(bsn_header):
4296 version = 5
4297 type = 4
4298 experimenter = 6035143
4299 subtype = 47
4300
4301 def __init__(self, xid=None, table_id=None, key=None):
4302 if xid != None:
4303 self.xid = xid
4304 else:
4305 self.xid = None
4306 if table_id != None:
4307 self.table_id = table_id
4308 else:
4309 self.table_id = 0
4310 if key != None:
4311 self.key = key
4312 else:
4313 self.key = []
4314 return
4315
4316 def pack(self):
4317 packed = []
4318 packed.append(struct.pack("!B", self.version))
4319 packed.append(struct.pack("!B", self.type))
4320 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4321 packed.append(struct.pack("!L", self.xid))
4322 packed.append(struct.pack("!L", self.experimenter))
4323 packed.append(struct.pack("!L", self.subtype))
4324 packed.append(struct.pack("!H", self.table_id))
4325 packed.append(loxi.generic_util.pack_list(self.key))
4326 length = sum([len(x) for x in packed])
4327 packed[2] = struct.pack("!H", length)
4328 return ''.join(packed)
4329
4330 @staticmethod
4331 def unpack(reader):
4332 obj = bsn_gentable_entry_delete()
4333 _version = reader.read("!B")[0]
4334 assert(_version == 5)
4335 _type = reader.read("!B")[0]
4336 assert(_type == 4)
4337 _length = reader.read("!H")[0]
4338 orig_reader = reader
4339 reader = orig_reader.slice(_length, 4)
4340 obj.xid = reader.read("!L")[0]
4341 _experimenter = reader.read("!L")[0]
4342 assert(_experimenter == 6035143)
4343 _subtype = reader.read("!L")[0]
4344 assert(_subtype == 47)
4345 obj.table_id = reader.read("!H")[0]
4346 obj.key = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
4347 return obj
4348
4349 def __eq__(self, other):
4350 if type(self) != type(other): return False
4351 if self.xid != other.xid: return False
4352 if self.table_id != other.table_id: return False
4353 if self.key != other.key: return False
4354 return True
4355
4356 def pretty_print(self, q):
4357 q.text("bsn_gentable_entry_delete {")
4358 with q.group():
4359 with q.indent(2):
4360 q.breakable()
4361 q.text("xid = ");
4362 if self.xid != None:
4363 q.text("%#x" % self.xid)
4364 else:
4365 q.text('None')
4366 q.text(","); q.breakable()
4367 q.text("table_id = ");
4368 q.text("%#x" % self.table_id)
4369 q.text(","); q.breakable()
4370 q.text("key = ");
4371 q.pp(self.key)
4372 q.breakable()
4373 q.text('}')
4374
4375bsn_header.subtypes[47] = bsn_gentable_entry_delete
4376
4377class bsn_gentable_entry_desc_stats_reply(bsn_stats_reply):
4378 version = 5
4379 type = 19
4380 stats_type = 65535
4381 experimenter = 6035143
4382 subtype = 2
4383
4384 def __init__(self, xid=None, flags=None, entries=None):
4385 if xid != None:
4386 self.xid = xid
4387 else:
4388 self.xid = None
4389 if flags != None:
4390 self.flags = flags
4391 else:
4392 self.flags = 0
4393 if entries != None:
4394 self.entries = entries
4395 else:
4396 self.entries = []
4397 return
4398
4399 def pack(self):
4400 packed = []
4401 packed.append(struct.pack("!B", self.version))
4402 packed.append(struct.pack("!B", self.type))
4403 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4404 packed.append(struct.pack("!L", self.xid))
4405 packed.append(struct.pack("!H", self.stats_type))
4406 packed.append(struct.pack("!H", self.flags))
4407 packed.append('\x00' * 4)
4408 packed.append(struct.pack("!L", self.experimenter))
4409 packed.append(struct.pack("!L", self.subtype))
4410 packed.append(loxi.generic_util.pack_list(self.entries))
4411 length = sum([len(x) for x in packed])
4412 packed[2] = struct.pack("!H", length)
4413 return ''.join(packed)
4414
4415 @staticmethod
4416 def unpack(reader):
4417 obj = bsn_gentable_entry_desc_stats_reply()
4418 _version = reader.read("!B")[0]
4419 assert(_version == 5)
4420 _type = reader.read("!B")[0]
4421 assert(_type == 19)
4422 _length = reader.read("!H")[0]
4423 orig_reader = reader
4424 reader = orig_reader.slice(_length, 4)
4425 obj.xid = reader.read("!L")[0]
4426 _stats_type = reader.read("!H")[0]
4427 assert(_stats_type == 65535)
4428 obj.flags = reader.read("!H")[0]
4429 reader.skip(4)
4430 _experimenter = reader.read("!L")[0]
4431 assert(_experimenter == 6035143)
4432 _subtype = reader.read("!L")[0]
4433 assert(_subtype == 2)
4434 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_entry_desc_stats_entry.unpack)
4435 return obj
4436
4437 def __eq__(self, other):
4438 if type(self) != type(other): return False
4439 if self.xid != other.xid: return False
4440 if self.flags != other.flags: return False
4441 if self.entries != other.entries: return False
4442 return True
4443
4444 def pretty_print(self, q):
4445 q.text("bsn_gentable_entry_desc_stats_reply {")
4446 with q.group():
4447 with q.indent(2):
4448 q.breakable()
4449 q.text("xid = ");
4450 if self.xid != None:
4451 q.text("%#x" % self.xid)
4452 else:
4453 q.text('None')
4454 q.text(","); q.breakable()
4455 q.text("flags = ");
4456 q.text("%#x" % self.flags)
4457 q.text(","); q.breakable()
4458 q.text("entries = ");
4459 q.pp(self.entries)
4460 q.breakable()
4461 q.text('}')
4462
4463bsn_stats_reply.subtypes[2] = bsn_gentable_entry_desc_stats_reply
4464
4465class bsn_gentable_entry_desc_stats_request(bsn_stats_request):
4466 version = 5
4467 type = 18
4468 stats_type = 65535
4469 experimenter = 6035143
4470 subtype = 2
4471
4472 def __init__(self, xid=None, flags=None, table_id=None, checksum=None, checksum_mask=None):
4473 if xid != None:
4474 self.xid = xid
4475 else:
4476 self.xid = None
4477 if flags != None:
4478 self.flags = flags
4479 else:
4480 self.flags = 0
4481 if table_id != None:
4482 self.table_id = table_id
4483 else:
4484 self.table_id = 0
4485 if checksum != None:
4486 self.checksum = checksum
4487 else:
4488 self.checksum = 0
4489 if checksum_mask != None:
4490 self.checksum_mask = checksum_mask
4491 else:
4492 self.checksum_mask = 0
4493 return
4494
4495 def pack(self):
4496 packed = []
4497 packed.append(struct.pack("!B", self.version))
4498 packed.append(struct.pack("!B", self.type))
4499 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4500 packed.append(struct.pack("!L", self.xid))
4501 packed.append(struct.pack("!H", self.stats_type))
4502 packed.append(struct.pack("!H", self.flags))
4503 packed.append('\x00' * 4)
4504 packed.append(struct.pack("!L", self.experimenter))
4505 packed.append(struct.pack("!L", self.subtype))
4506 packed.append(struct.pack("!H", self.table_id))
4507 packed.append('\x00' * 2)
4508 packed.append(util.pack_checksum_128(self.checksum))
4509 packed.append(util.pack_checksum_128(self.checksum_mask))
4510 length = sum([len(x) for x in packed])
4511 packed[2] = struct.pack("!H", length)
4512 return ''.join(packed)
4513
4514 @staticmethod
4515 def unpack(reader):
4516 obj = bsn_gentable_entry_desc_stats_request()
4517 _version = reader.read("!B")[0]
4518 assert(_version == 5)
4519 _type = reader.read("!B")[0]
4520 assert(_type == 18)
4521 _length = reader.read("!H")[0]
4522 orig_reader = reader
4523 reader = orig_reader.slice(_length, 4)
4524 obj.xid = reader.read("!L")[0]
4525 _stats_type = reader.read("!H")[0]
4526 assert(_stats_type == 65535)
4527 obj.flags = reader.read("!H")[0]
4528 reader.skip(4)
4529 _experimenter = reader.read("!L")[0]
4530 assert(_experimenter == 6035143)
4531 _subtype = reader.read("!L")[0]
4532 assert(_subtype == 2)
4533 obj.table_id = reader.read("!H")[0]
4534 reader.skip(2)
4535 obj.checksum = util.unpack_checksum_128(reader)
4536 obj.checksum_mask = util.unpack_checksum_128(reader)
4537 return obj
4538
4539 def __eq__(self, other):
4540 if type(self) != type(other): return False
4541 if self.xid != other.xid: return False
4542 if self.flags != other.flags: return False
4543 if self.table_id != other.table_id: return False
4544 if self.checksum != other.checksum: return False
4545 if self.checksum_mask != other.checksum_mask: return False
4546 return True
4547
4548 def pretty_print(self, q):
4549 q.text("bsn_gentable_entry_desc_stats_request {")
4550 with q.group():
4551 with q.indent(2):
4552 q.breakable()
4553 q.text("xid = ");
4554 if self.xid != None:
4555 q.text("%#x" % self.xid)
4556 else:
4557 q.text('None')
4558 q.text(","); q.breakable()
4559 q.text("flags = ");
4560 q.text("%#x" % self.flags)
4561 q.text(","); q.breakable()
4562 q.text("table_id = ");
4563 q.text("%#x" % self.table_id)
4564 q.text(","); q.breakable()
4565 q.text("checksum = ");
4566 q.pp(self.checksum)
4567 q.text(","); q.breakable()
4568 q.text("checksum_mask = ");
4569 q.pp(self.checksum_mask)
4570 q.breakable()
4571 q.text('}')
4572
4573bsn_stats_request.subtypes[2] = bsn_gentable_entry_desc_stats_request
4574
4575class bsn_gentable_entry_stats_reply(bsn_stats_reply):
4576 version = 5
4577 type = 19
4578 stats_type = 65535
4579 experimenter = 6035143
4580 subtype = 3
4581
4582 def __init__(self, xid=None, flags=None, entries=None):
4583 if xid != None:
4584 self.xid = xid
4585 else:
4586 self.xid = None
4587 if flags != None:
4588 self.flags = flags
4589 else:
4590 self.flags = 0
4591 if entries != None:
4592 self.entries = entries
4593 else:
4594 self.entries = []
4595 return
4596
4597 def pack(self):
4598 packed = []
4599 packed.append(struct.pack("!B", self.version))
4600 packed.append(struct.pack("!B", self.type))
4601 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4602 packed.append(struct.pack("!L", self.xid))
4603 packed.append(struct.pack("!H", self.stats_type))
4604 packed.append(struct.pack("!H", self.flags))
4605 packed.append('\x00' * 4)
4606 packed.append(struct.pack("!L", self.experimenter))
4607 packed.append(struct.pack("!L", self.subtype))
4608 packed.append(loxi.generic_util.pack_list(self.entries))
4609 length = sum([len(x) for x in packed])
4610 packed[2] = struct.pack("!H", length)
4611 return ''.join(packed)
4612
4613 @staticmethod
4614 def unpack(reader):
4615 obj = bsn_gentable_entry_stats_reply()
4616 _version = reader.read("!B")[0]
4617 assert(_version == 5)
4618 _type = reader.read("!B")[0]
4619 assert(_type == 19)
4620 _length = reader.read("!H")[0]
4621 orig_reader = reader
4622 reader = orig_reader.slice(_length, 4)
4623 obj.xid = reader.read("!L")[0]
4624 _stats_type = reader.read("!H")[0]
4625 assert(_stats_type == 65535)
4626 obj.flags = reader.read("!H")[0]
4627 reader.skip(4)
4628 _experimenter = reader.read("!L")[0]
4629 assert(_experimenter == 6035143)
4630 _subtype = reader.read("!L")[0]
4631 assert(_subtype == 3)
4632 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_entry_stats_entry.unpack)
4633 return obj
4634
4635 def __eq__(self, other):
4636 if type(self) != type(other): return False
4637 if self.xid != other.xid: return False
4638 if self.flags != other.flags: return False
4639 if self.entries != other.entries: return False
4640 return True
4641
4642 def pretty_print(self, q):
4643 q.text("bsn_gentable_entry_stats_reply {")
4644 with q.group():
4645 with q.indent(2):
4646 q.breakable()
4647 q.text("xid = ");
4648 if self.xid != None:
4649 q.text("%#x" % self.xid)
4650 else:
4651 q.text('None')
4652 q.text(","); q.breakable()
4653 q.text("flags = ");
4654 q.text("%#x" % self.flags)
4655 q.text(","); q.breakable()
4656 q.text("entries = ");
4657 q.pp(self.entries)
4658 q.breakable()
4659 q.text('}')
4660
4661bsn_stats_reply.subtypes[3] = bsn_gentable_entry_stats_reply
4662
4663class bsn_gentable_entry_stats_request(bsn_stats_request):
4664 version = 5
4665 type = 18
4666 stats_type = 65535
4667 experimenter = 6035143
4668 subtype = 3
4669
4670 def __init__(self, xid=None, flags=None, table_id=None, checksum=None, checksum_mask=None):
4671 if xid != None:
4672 self.xid = xid
4673 else:
4674 self.xid = None
4675 if flags != None:
4676 self.flags = flags
4677 else:
4678 self.flags = 0
4679 if table_id != None:
4680 self.table_id = table_id
4681 else:
4682 self.table_id = 0
4683 if checksum != None:
4684 self.checksum = checksum
4685 else:
4686 self.checksum = 0
4687 if checksum_mask != None:
4688 self.checksum_mask = checksum_mask
4689 else:
4690 self.checksum_mask = 0
4691 return
4692
4693 def pack(self):
4694 packed = []
4695 packed.append(struct.pack("!B", self.version))
4696 packed.append(struct.pack("!B", self.type))
4697 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4698 packed.append(struct.pack("!L", self.xid))
4699 packed.append(struct.pack("!H", self.stats_type))
4700 packed.append(struct.pack("!H", self.flags))
4701 packed.append('\x00' * 4)
4702 packed.append(struct.pack("!L", self.experimenter))
4703 packed.append(struct.pack("!L", self.subtype))
4704 packed.append(struct.pack("!H", self.table_id))
4705 packed.append('\x00' * 2)
4706 packed.append(util.pack_checksum_128(self.checksum))
4707 packed.append(util.pack_checksum_128(self.checksum_mask))
4708 length = sum([len(x) for x in packed])
4709 packed[2] = struct.pack("!H", length)
4710 return ''.join(packed)
4711
4712 @staticmethod
4713 def unpack(reader):
4714 obj = bsn_gentable_entry_stats_request()
4715 _version = reader.read("!B")[0]
4716 assert(_version == 5)
4717 _type = reader.read("!B")[0]
4718 assert(_type == 18)
4719 _length = reader.read("!H")[0]
4720 orig_reader = reader
4721 reader = orig_reader.slice(_length, 4)
4722 obj.xid = reader.read("!L")[0]
4723 _stats_type = reader.read("!H")[0]
4724 assert(_stats_type == 65535)
4725 obj.flags = reader.read("!H")[0]
4726 reader.skip(4)
4727 _experimenter = reader.read("!L")[0]
4728 assert(_experimenter == 6035143)
4729 _subtype = reader.read("!L")[0]
4730 assert(_subtype == 3)
4731 obj.table_id = reader.read("!H")[0]
4732 reader.skip(2)
4733 obj.checksum = util.unpack_checksum_128(reader)
4734 obj.checksum_mask = util.unpack_checksum_128(reader)
4735 return obj
4736
4737 def __eq__(self, other):
4738 if type(self) != type(other): return False
4739 if self.xid != other.xid: return False
4740 if self.flags != other.flags: return False
4741 if self.table_id != other.table_id: return False
4742 if self.checksum != other.checksum: return False
4743 if self.checksum_mask != other.checksum_mask: return False
4744 return True
4745
4746 def pretty_print(self, q):
4747 q.text("bsn_gentable_entry_stats_request {")
4748 with q.group():
4749 with q.indent(2):
4750 q.breakable()
4751 q.text("xid = ");
4752 if self.xid != None:
4753 q.text("%#x" % self.xid)
4754 else:
4755 q.text('None')
4756 q.text(","); q.breakable()
4757 q.text("flags = ");
4758 q.text("%#x" % self.flags)
4759 q.text(","); q.breakable()
4760 q.text("table_id = ");
4761 q.text("%#x" % self.table_id)
4762 q.text(","); q.breakable()
4763 q.text("checksum = ");
4764 q.pp(self.checksum)
4765 q.text(","); q.breakable()
4766 q.text("checksum_mask = ");
4767 q.pp(self.checksum_mask)
4768 q.breakable()
4769 q.text('}')
4770
4771bsn_stats_request.subtypes[3] = bsn_gentable_entry_stats_request
4772
4773class bsn_gentable_set_buckets_size(bsn_header):
4774 version = 5
4775 type = 4
4776 experimenter = 6035143
4777 subtype = 50
4778
4779 def __init__(self, xid=None, table_id=None, buckets_size=None):
4780 if xid != None:
4781 self.xid = xid
4782 else:
4783 self.xid = None
4784 if table_id != None:
4785 self.table_id = table_id
4786 else:
4787 self.table_id = 0
4788 if buckets_size != None:
4789 self.buckets_size = buckets_size
4790 else:
4791 self.buckets_size = 0
4792 return
4793
4794 def pack(self):
4795 packed = []
4796 packed.append(struct.pack("!B", self.version))
4797 packed.append(struct.pack("!B", self.type))
4798 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4799 packed.append(struct.pack("!L", self.xid))
4800 packed.append(struct.pack("!L", self.experimenter))
4801 packed.append(struct.pack("!L", self.subtype))
4802 packed.append(struct.pack("!H", self.table_id))
4803 packed.append('\x00' * 2)
4804 packed.append(struct.pack("!L", self.buckets_size))
4805 length = sum([len(x) for x in packed])
4806 packed[2] = struct.pack("!H", length)
4807 return ''.join(packed)
4808
4809 @staticmethod
4810 def unpack(reader):
4811 obj = bsn_gentable_set_buckets_size()
4812 _version = reader.read("!B")[0]
4813 assert(_version == 5)
4814 _type = reader.read("!B")[0]
4815 assert(_type == 4)
4816 _length = reader.read("!H")[0]
4817 orig_reader = reader
4818 reader = orig_reader.slice(_length, 4)
4819 obj.xid = reader.read("!L")[0]
4820 _experimenter = reader.read("!L")[0]
4821 assert(_experimenter == 6035143)
4822 _subtype = reader.read("!L")[0]
4823 assert(_subtype == 50)
4824 obj.table_id = reader.read("!H")[0]
4825 reader.skip(2)
4826 obj.buckets_size = reader.read("!L")[0]
4827 return obj
4828
4829 def __eq__(self, other):
4830 if type(self) != type(other): return False
4831 if self.xid != other.xid: return False
4832 if self.table_id != other.table_id: return False
4833 if self.buckets_size != other.buckets_size: return False
4834 return True
4835
4836 def pretty_print(self, q):
4837 q.text("bsn_gentable_set_buckets_size {")
4838 with q.group():
4839 with q.indent(2):
4840 q.breakable()
4841 q.text("xid = ");
4842 if self.xid != None:
4843 q.text("%#x" % self.xid)
4844 else:
4845 q.text('None')
4846 q.text(","); q.breakable()
4847 q.text("table_id = ");
4848 q.text("%#x" % self.table_id)
4849 q.text(","); q.breakable()
4850 q.text("buckets_size = ");
4851 q.text("%#x" % self.buckets_size)
4852 q.breakable()
4853 q.text('}')
4854
4855bsn_header.subtypes[50] = bsn_gentable_set_buckets_size
4856
4857class bsn_gentable_stats_reply(bsn_stats_reply):
4858 version = 5
4859 type = 19
4860 stats_type = 65535
4861 experimenter = 6035143
4862 subtype = 7
4863
4864 def __init__(self, xid=None, flags=None, entries=None):
4865 if xid != None:
4866 self.xid = xid
4867 else:
4868 self.xid = None
4869 if flags != None:
4870 self.flags = flags
4871 else:
4872 self.flags = 0
4873 if entries != None:
4874 self.entries = entries
4875 else:
4876 self.entries = []
4877 return
4878
4879 def pack(self):
4880 packed = []
4881 packed.append(struct.pack("!B", self.version))
4882 packed.append(struct.pack("!B", self.type))
4883 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4884 packed.append(struct.pack("!L", self.xid))
4885 packed.append(struct.pack("!H", self.stats_type))
4886 packed.append(struct.pack("!H", self.flags))
4887 packed.append('\x00' * 4)
4888 packed.append(struct.pack("!L", self.experimenter))
4889 packed.append(struct.pack("!L", self.subtype))
4890 packed.append(loxi.generic_util.pack_list(self.entries))
4891 length = sum([len(x) for x in packed])
4892 packed[2] = struct.pack("!H", length)
4893 return ''.join(packed)
4894
4895 @staticmethod
4896 def unpack(reader):
4897 obj = bsn_gentable_stats_reply()
4898 _version = reader.read("!B")[0]
4899 assert(_version == 5)
4900 _type = reader.read("!B")[0]
4901 assert(_type == 19)
4902 _length = reader.read("!H")[0]
4903 orig_reader = reader
4904 reader = orig_reader.slice(_length, 4)
4905 obj.xid = reader.read("!L")[0]
4906 _stats_type = reader.read("!H")[0]
4907 assert(_stats_type == 65535)
4908 obj.flags = reader.read("!H")[0]
4909 reader.skip(4)
4910 _experimenter = reader.read("!L")[0]
4911 assert(_experimenter == 6035143)
4912 _subtype = reader.read("!L")[0]
4913 assert(_subtype == 7)
4914 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_stats_entry.unpack)
4915 return obj
4916
4917 def __eq__(self, other):
4918 if type(self) != type(other): return False
4919 if self.xid != other.xid: return False
4920 if self.flags != other.flags: return False
4921 if self.entries != other.entries: return False
4922 return True
4923
4924 def pretty_print(self, q):
4925 q.text("bsn_gentable_stats_reply {")
4926 with q.group():
4927 with q.indent(2):
4928 q.breakable()
4929 q.text("xid = ");
4930 if self.xid != None:
4931 q.text("%#x" % self.xid)
4932 else:
4933 q.text('None')
4934 q.text(","); q.breakable()
4935 q.text("flags = ");
4936 q.text("%#x" % self.flags)
4937 q.text(","); q.breakable()
4938 q.text("entries = ");
4939 q.pp(self.entries)
4940 q.breakable()
4941 q.text('}')
4942
4943bsn_stats_reply.subtypes[7] = bsn_gentable_stats_reply
4944
4945class bsn_gentable_stats_request(bsn_stats_request):
4946 version = 5
4947 type = 18
4948 stats_type = 65535
4949 experimenter = 6035143
4950 subtype = 7
4951
4952 def __init__(self, xid=None, flags=None):
4953 if xid != None:
4954 self.xid = xid
4955 else:
4956 self.xid = None
4957 if flags != None:
4958 self.flags = flags
4959 else:
4960 self.flags = 0
4961 return
4962
4963 def pack(self):
4964 packed = []
4965 packed.append(struct.pack("!B", self.version))
4966 packed.append(struct.pack("!B", self.type))
4967 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4968 packed.append(struct.pack("!L", self.xid))
4969 packed.append(struct.pack("!H", self.stats_type))
4970 packed.append(struct.pack("!H", self.flags))
4971 packed.append('\x00' * 4)
4972 packed.append(struct.pack("!L", self.experimenter))
4973 packed.append(struct.pack("!L", self.subtype))
4974 length = sum([len(x) for x in packed])
4975 packed[2] = struct.pack("!H", length)
4976 return ''.join(packed)
4977
4978 @staticmethod
4979 def unpack(reader):
4980 obj = bsn_gentable_stats_request()
4981 _version = reader.read("!B")[0]
4982 assert(_version == 5)
4983 _type = reader.read("!B")[0]
4984 assert(_type == 18)
4985 _length = reader.read("!H")[0]
4986 orig_reader = reader
4987 reader = orig_reader.slice(_length, 4)
4988 obj.xid = reader.read("!L")[0]
4989 _stats_type = reader.read("!H")[0]
4990 assert(_stats_type == 65535)
4991 obj.flags = reader.read("!H")[0]
4992 reader.skip(4)
4993 _experimenter = reader.read("!L")[0]
4994 assert(_experimenter == 6035143)
4995 _subtype = reader.read("!L")[0]
4996 assert(_subtype == 7)
4997 return obj
4998
4999 def __eq__(self, other):
5000 if type(self) != type(other): return False
5001 if self.xid != other.xid: return False
5002 if self.flags != other.flags: return False
5003 return True
5004
5005 def pretty_print(self, q):
5006 q.text("bsn_gentable_stats_request {")
5007 with q.group():
5008 with q.indent(2):
5009 q.breakable()
5010 q.text("xid = ");
5011 if self.xid != None:
5012 q.text("%#x" % self.xid)
5013 else:
5014 q.text('None')
5015 q.text(","); q.breakable()
5016 q.text("flags = ");
5017 q.text("%#x" % self.flags)
5018 q.breakable()
5019 q.text('}')
5020
5021bsn_stats_request.subtypes[7] = bsn_gentable_stats_request
5022
5023class bsn_get_interfaces_reply(bsn_header):
5024 version = 5
5025 type = 4
5026 experimenter = 6035143
5027 subtype = 10
5028
5029 def __init__(self, xid=None, interfaces=None):
5030 if xid != None:
5031 self.xid = xid
5032 else:
5033 self.xid = None
5034 if interfaces != None:
5035 self.interfaces = interfaces
5036 else:
5037 self.interfaces = []
5038 return
5039
5040 def pack(self):
5041 packed = []
5042 packed.append(struct.pack("!B", self.version))
5043 packed.append(struct.pack("!B", self.type))
5044 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5045 packed.append(struct.pack("!L", self.xid))
5046 packed.append(struct.pack("!L", self.experimenter))
5047 packed.append(struct.pack("!L", self.subtype))
5048 packed.append(loxi.generic_util.pack_list(self.interfaces))
5049 length = sum([len(x) for x in packed])
5050 packed[2] = struct.pack("!H", length)
5051 return ''.join(packed)
5052
5053 @staticmethod
5054 def unpack(reader):
5055 obj = bsn_get_interfaces_reply()
5056 _version = reader.read("!B")[0]
5057 assert(_version == 5)
5058 _type = reader.read("!B")[0]
5059 assert(_type == 4)
5060 _length = reader.read("!H")[0]
5061 orig_reader = reader
5062 reader = orig_reader.slice(_length, 4)
5063 obj.xid = reader.read("!L")[0]
5064 _experimenter = reader.read("!L")[0]
5065 assert(_experimenter == 6035143)
5066 _subtype = reader.read("!L")[0]
5067 assert(_subtype == 10)
5068 obj.interfaces = loxi.generic_util.unpack_list(reader, ofp.common.bsn_interface.unpack)
5069 return obj
5070
5071 def __eq__(self, other):
5072 if type(self) != type(other): return False
5073 if self.xid != other.xid: return False
5074 if self.interfaces != other.interfaces: return False
5075 return True
5076
5077 def pretty_print(self, q):
5078 q.text("bsn_get_interfaces_reply {")
5079 with q.group():
5080 with q.indent(2):
5081 q.breakable()
5082 q.text("xid = ");
5083 if self.xid != None:
5084 q.text("%#x" % self.xid)
5085 else:
5086 q.text('None')
5087 q.text(","); q.breakable()
5088 q.text("interfaces = ");
5089 q.pp(self.interfaces)
5090 q.breakable()
5091 q.text('}')
5092
5093bsn_header.subtypes[10] = bsn_get_interfaces_reply
5094
5095class bsn_get_interfaces_request(bsn_header):
5096 version = 5
5097 type = 4
5098 experimenter = 6035143
5099 subtype = 9
5100
5101 def __init__(self, xid=None):
5102 if xid != None:
5103 self.xid = xid
5104 else:
5105 self.xid = None
5106 return
5107
5108 def pack(self):
5109 packed = []
5110 packed.append(struct.pack("!B", self.version))
5111 packed.append(struct.pack("!B", self.type))
5112 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5113 packed.append(struct.pack("!L", self.xid))
5114 packed.append(struct.pack("!L", self.experimenter))
5115 packed.append(struct.pack("!L", self.subtype))
5116 length = sum([len(x) for x in packed])
5117 packed[2] = struct.pack("!H", length)
5118 return ''.join(packed)
5119
5120 @staticmethod
5121 def unpack(reader):
5122 obj = bsn_get_interfaces_request()
5123 _version = reader.read("!B")[0]
5124 assert(_version == 5)
5125 _type = reader.read("!B")[0]
5126 assert(_type == 4)
5127 _length = reader.read("!H")[0]
5128 orig_reader = reader
5129 reader = orig_reader.slice(_length, 4)
5130 obj.xid = reader.read("!L")[0]
5131 _experimenter = reader.read("!L")[0]
5132 assert(_experimenter == 6035143)
5133 _subtype = reader.read("!L")[0]
5134 assert(_subtype == 9)
5135 return obj
5136
5137 def __eq__(self, other):
5138 if type(self) != type(other): return False
5139 if self.xid != other.xid: return False
5140 return True
5141
5142 def pretty_print(self, q):
5143 q.text("bsn_get_interfaces_request {")
5144 with q.group():
5145 with q.indent(2):
5146 q.breakable()
5147 q.text("xid = ");
5148 if self.xid != None:
5149 q.text("%#x" % self.xid)
5150 else:
5151 q.text('None')
5152 q.breakable()
5153 q.text('}')
5154
5155bsn_header.subtypes[9] = bsn_get_interfaces_request
5156
5157class bsn_get_mirroring_reply(bsn_header):
5158 version = 5
5159 type = 4
5160 experimenter = 6035143
5161 subtype = 5
5162
5163 def __init__(self, xid=None, report_mirror_ports=None):
5164 if xid != None:
5165 self.xid = xid
5166 else:
5167 self.xid = None
5168 if report_mirror_ports != None:
5169 self.report_mirror_ports = report_mirror_ports
5170 else:
5171 self.report_mirror_ports = 0
5172 return
5173
5174 def pack(self):
5175 packed = []
5176 packed.append(struct.pack("!B", self.version))
5177 packed.append(struct.pack("!B", self.type))
5178 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5179 packed.append(struct.pack("!L", self.xid))
5180 packed.append(struct.pack("!L", self.experimenter))
5181 packed.append(struct.pack("!L", self.subtype))
5182 packed.append(struct.pack("!B", self.report_mirror_ports))
5183 packed.append('\x00' * 3)
5184 length = sum([len(x) for x in packed])
5185 packed[2] = struct.pack("!H", length)
5186 return ''.join(packed)
5187
5188 @staticmethod
5189 def unpack(reader):
5190 obj = bsn_get_mirroring_reply()
5191 _version = reader.read("!B")[0]
5192 assert(_version == 5)
5193 _type = reader.read("!B")[0]
5194 assert(_type == 4)
5195 _length = reader.read("!H")[0]
5196 orig_reader = reader
5197 reader = orig_reader.slice(_length, 4)
5198 obj.xid = reader.read("!L")[0]
5199 _experimenter = reader.read("!L")[0]
5200 assert(_experimenter == 6035143)
5201 _subtype = reader.read("!L")[0]
5202 assert(_subtype == 5)
5203 obj.report_mirror_ports = reader.read("!B")[0]
5204 reader.skip(3)
5205 return obj
5206
5207 def __eq__(self, other):
5208 if type(self) != type(other): return False
5209 if self.xid != other.xid: return False
5210 if self.report_mirror_ports != other.report_mirror_ports: return False
5211 return True
5212
5213 def pretty_print(self, q):
5214 q.text("bsn_get_mirroring_reply {")
5215 with q.group():
5216 with q.indent(2):
5217 q.breakable()
5218 q.text("xid = ");
5219 if self.xid != None:
5220 q.text("%#x" % self.xid)
5221 else:
5222 q.text('None')
5223 q.text(","); q.breakable()
5224 q.text("report_mirror_ports = ");
5225 q.text("%#x" % self.report_mirror_ports)
5226 q.breakable()
5227 q.text('}')
5228
5229bsn_header.subtypes[5] = bsn_get_mirroring_reply
5230
5231class bsn_get_mirroring_request(bsn_header):
5232 version = 5
5233 type = 4
5234 experimenter = 6035143
5235 subtype = 4
5236
5237 def __init__(self, xid=None, report_mirror_ports=None):
5238 if xid != None:
5239 self.xid = xid
5240 else:
5241 self.xid = None
5242 if report_mirror_ports != None:
5243 self.report_mirror_ports = report_mirror_ports
5244 else:
5245 self.report_mirror_ports = 0
5246 return
5247
5248 def pack(self):
5249 packed = []
5250 packed.append(struct.pack("!B", self.version))
5251 packed.append(struct.pack("!B", self.type))
5252 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5253 packed.append(struct.pack("!L", self.xid))
5254 packed.append(struct.pack("!L", self.experimenter))
5255 packed.append(struct.pack("!L", self.subtype))
5256 packed.append(struct.pack("!B", self.report_mirror_ports))
5257 packed.append('\x00' * 3)
5258 length = sum([len(x) for x in packed])
5259 packed[2] = struct.pack("!H", length)
5260 return ''.join(packed)
5261
5262 @staticmethod
5263 def unpack(reader):
5264 obj = bsn_get_mirroring_request()
5265 _version = reader.read("!B")[0]
5266 assert(_version == 5)
5267 _type = reader.read("!B")[0]
5268 assert(_type == 4)
5269 _length = reader.read("!H")[0]
5270 orig_reader = reader
5271 reader = orig_reader.slice(_length, 4)
5272 obj.xid = reader.read("!L")[0]
5273 _experimenter = reader.read("!L")[0]
5274 assert(_experimenter == 6035143)
5275 _subtype = reader.read("!L")[0]
5276 assert(_subtype == 4)
5277 obj.report_mirror_ports = reader.read("!B")[0]
5278 reader.skip(3)
5279 return obj
5280
5281 def __eq__(self, other):
5282 if type(self) != type(other): return False
5283 if self.xid != other.xid: return False
5284 if self.report_mirror_ports != other.report_mirror_ports: return False
5285 return True
5286
5287 def pretty_print(self, q):
5288 q.text("bsn_get_mirroring_request {")
5289 with q.group():
5290 with q.indent(2):
5291 q.breakable()
5292 q.text("xid = ");
5293 if self.xid != None:
5294 q.text("%#x" % self.xid)
5295 else:
5296 q.text('None')
5297 q.text(","); q.breakable()
5298 q.text("report_mirror_ports = ");
5299 q.text("%#x" % self.report_mirror_ports)
5300 q.breakable()
5301 q.text('}')
5302
5303bsn_header.subtypes[4] = bsn_get_mirroring_request
5304
5305class bsn_get_switch_pipeline_reply(bsn_header):
5306 version = 5
5307 type = 4
5308 experimenter = 6035143
5309 subtype = 52
5310
5311 def __init__(self, xid=None, pipeline=None):
5312 if xid != None:
5313 self.xid = xid
5314 else:
5315 self.xid = None
5316 if pipeline != None:
5317 self.pipeline = pipeline
5318 else:
5319 self.pipeline = ""
5320 return
5321
5322 def pack(self):
5323 packed = []
5324 packed.append(struct.pack("!B", self.version))
5325 packed.append(struct.pack("!B", self.type))
5326 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5327 packed.append(struct.pack("!L", self.xid))
5328 packed.append(struct.pack("!L", self.experimenter))
5329 packed.append(struct.pack("!L", self.subtype))
5330 packed.append(struct.pack("!256s", self.pipeline))
5331 length = sum([len(x) for x in packed])
5332 packed[2] = struct.pack("!H", length)
5333 return ''.join(packed)
5334
5335 @staticmethod
5336 def unpack(reader):
5337 obj = bsn_get_switch_pipeline_reply()
5338 _version = reader.read("!B")[0]
5339 assert(_version == 5)
5340 _type = reader.read("!B")[0]
5341 assert(_type == 4)
5342 _length = reader.read("!H")[0]
5343 orig_reader = reader
5344 reader = orig_reader.slice(_length, 4)
5345 obj.xid = reader.read("!L")[0]
5346 _experimenter = reader.read("!L")[0]
5347 assert(_experimenter == 6035143)
5348 _subtype = reader.read("!L")[0]
5349 assert(_subtype == 52)
5350 obj.pipeline = reader.read("!256s")[0].rstrip("\x00")
5351 return obj
5352
5353 def __eq__(self, other):
5354 if type(self) != type(other): return False
5355 if self.xid != other.xid: return False
5356 if self.pipeline != other.pipeline: return False
5357 return True
5358
5359 def pretty_print(self, q):
5360 q.text("bsn_get_switch_pipeline_reply {")
5361 with q.group():
5362 with q.indent(2):
5363 q.breakable()
5364 q.text("xid = ");
5365 if self.xid != None:
5366 q.text("%#x" % self.xid)
5367 else:
5368 q.text('None')
5369 q.text(","); q.breakable()
5370 q.text("pipeline = ");
5371 q.pp(self.pipeline)
5372 q.breakable()
5373 q.text('}')
5374
5375bsn_header.subtypes[52] = bsn_get_switch_pipeline_reply
5376
5377class bsn_get_switch_pipeline_request(bsn_header):
5378 version = 5
5379 type = 4
5380 experimenter = 6035143
5381 subtype = 51
5382
5383 def __init__(self, xid=None):
5384 if xid != None:
5385 self.xid = xid
5386 else:
5387 self.xid = None
5388 return
5389
5390 def pack(self):
5391 packed = []
5392 packed.append(struct.pack("!B", self.version))
5393 packed.append(struct.pack("!B", self.type))
5394 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5395 packed.append(struct.pack("!L", self.xid))
5396 packed.append(struct.pack("!L", self.experimenter))
5397 packed.append(struct.pack("!L", self.subtype))
5398 length = sum([len(x) for x in packed])
5399 packed[2] = struct.pack("!H", length)
5400 return ''.join(packed)
5401
5402 @staticmethod
5403 def unpack(reader):
5404 obj = bsn_get_switch_pipeline_request()
5405 _version = reader.read("!B")[0]
5406 assert(_version == 5)
5407 _type = reader.read("!B")[0]
5408 assert(_type == 4)
5409 _length = reader.read("!H")[0]
5410 orig_reader = reader
5411 reader = orig_reader.slice(_length, 4)
5412 obj.xid = reader.read("!L")[0]
5413 _experimenter = reader.read("!L")[0]
5414 assert(_experimenter == 6035143)
5415 _subtype = reader.read("!L")[0]
5416 assert(_subtype == 51)
5417 return obj
5418
5419 def __eq__(self, other):
5420 if type(self) != type(other): return False
5421 if self.xid != other.xid: return False
5422 return True
5423
5424 def pretty_print(self, q):
5425 q.text("bsn_get_switch_pipeline_request {")
5426 with q.group():
5427 with q.indent(2):
5428 q.breakable()
5429 q.text("xid = ");
5430 if self.xid != None:
5431 q.text("%#x" % self.xid)
5432 else:
5433 q.text('None')
5434 q.breakable()
5435 q.text('}')
5436
5437bsn_header.subtypes[51] = bsn_get_switch_pipeline_request
5438
5439class bsn_image_desc_stats_reply(bsn_stats_reply):
5440 version = 5
5441 type = 19
5442 stats_type = 65535
5443 experimenter = 6035143
5444 subtype = 14
5445
5446 def __init__(self, xid=None, flags=None, image_checksum=None, startup_config_checksum=None):
5447 if xid != None:
5448 self.xid = xid
5449 else:
5450 self.xid = None
5451 if flags != None:
5452 self.flags = flags
5453 else:
5454 self.flags = 0
5455 if image_checksum != None:
5456 self.image_checksum = image_checksum
5457 else:
5458 self.image_checksum = ""
5459 if startup_config_checksum != None:
5460 self.startup_config_checksum = startup_config_checksum
5461 else:
5462 self.startup_config_checksum = ""
5463 return
5464
5465 def pack(self):
5466 packed = []
5467 packed.append(struct.pack("!B", self.version))
5468 packed.append(struct.pack("!B", self.type))
5469 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5470 packed.append(struct.pack("!L", self.xid))
5471 packed.append(struct.pack("!H", self.stats_type))
5472 packed.append(struct.pack("!H", self.flags))
5473 packed.append('\x00' * 4)
5474 packed.append(struct.pack("!L", self.experimenter))
5475 packed.append(struct.pack("!L", self.subtype))
5476 packed.append(struct.pack("!256s", self.image_checksum))
5477 packed.append(struct.pack("!256s", self.startup_config_checksum))
5478 length = sum([len(x) for x in packed])
5479 packed[2] = struct.pack("!H", length)
5480 return ''.join(packed)
5481
5482 @staticmethod
5483 def unpack(reader):
5484 obj = bsn_image_desc_stats_reply()
5485 _version = reader.read("!B")[0]
5486 assert(_version == 5)
5487 _type = reader.read("!B")[0]
5488 assert(_type == 19)
5489 _length = reader.read("!H")[0]
5490 orig_reader = reader
5491 reader = orig_reader.slice(_length, 4)
5492 obj.xid = reader.read("!L")[0]
5493 _stats_type = reader.read("!H")[0]
5494 assert(_stats_type == 65535)
5495 obj.flags = reader.read("!H")[0]
5496 reader.skip(4)
5497 _experimenter = reader.read("!L")[0]
5498 assert(_experimenter == 6035143)
5499 _subtype = reader.read("!L")[0]
5500 assert(_subtype == 14)
5501 obj.image_checksum = reader.read("!256s")[0].rstrip("\x00")
5502 obj.startup_config_checksum = reader.read("!256s")[0].rstrip("\x00")
5503 return obj
5504
5505 def __eq__(self, other):
5506 if type(self) != type(other): return False
5507 if self.xid != other.xid: return False
5508 if self.flags != other.flags: return False
5509 if self.image_checksum != other.image_checksum: return False
5510 if self.startup_config_checksum != other.startup_config_checksum: return False
5511 return True
5512
5513 def pretty_print(self, q):
5514 q.text("bsn_image_desc_stats_reply {")
5515 with q.group():
5516 with q.indent(2):
5517 q.breakable()
5518 q.text("xid = ");
5519 if self.xid != None:
5520 q.text("%#x" % self.xid)
5521 else:
5522 q.text('None')
5523 q.text(","); q.breakable()
5524 q.text("flags = ");
5525 q.text("%#x" % self.flags)
5526 q.text(","); q.breakable()
5527 q.text("image_checksum = ");
5528 q.pp(self.image_checksum)
5529 q.text(","); q.breakable()
5530 q.text("startup_config_checksum = ");
5531 q.pp(self.startup_config_checksum)
5532 q.breakable()
5533 q.text('}')
5534
5535bsn_stats_reply.subtypes[14] = bsn_image_desc_stats_reply
5536
5537class bsn_image_desc_stats_request(bsn_stats_request):
5538 version = 5
5539 type = 18
5540 stats_type = 65535
5541 experimenter = 6035143
5542 subtype = 14
5543
5544 def __init__(self, xid=None, flags=None):
5545 if xid != None:
5546 self.xid = xid
5547 else:
5548 self.xid = None
5549 if flags != None:
5550 self.flags = flags
5551 else:
5552 self.flags = 0
5553 return
5554
5555 def pack(self):
5556 packed = []
5557 packed.append(struct.pack("!B", self.version))
5558 packed.append(struct.pack("!B", self.type))
5559 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5560 packed.append(struct.pack("!L", self.xid))
5561 packed.append(struct.pack("!H", self.stats_type))
5562 packed.append(struct.pack("!H", self.flags))
5563 packed.append('\x00' * 4)
5564 packed.append(struct.pack("!L", self.experimenter))
5565 packed.append(struct.pack("!L", self.subtype))
5566 length = sum([len(x) for x in packed])
5567 packed[2] = struct.pack("!H", length)
5568 return ''.join(packed)
5569
5570 @staticmethod
5571 def unpack(reader):
5572 obj = bsn_image_desc_stats_request()
5573 _version = reader.read("!B")[0]
5574 assert(_version == 5)
5575 _type = reader.read("!B")[0]
5576 assert(_type == 18)
5577 _length = reader.read("!H")[0]
5578 orig_reader = reader
5579 reader = orig_reader.slice(_length, 4)
5580 obj.xid = reader.read("!L")[0]
5581 _stats_type = reader.read("!H")[0]
5582 assert(_stats_type == 65535)
5583 obj.flags = reader.read("!H")[0]
5584 reader.skip(4)
5585 _experimenter = reader.read("!L")[0]
5586 assert(_experimenter == 6035143)
5587 _subtype = reader.read("!L")[0]
5588 assert(_subtype == 14)
5589 return obj
5590
5591 def __eq__(self, other):
5592 if type(self) != type(other): return False
5593 if self.xid != other.xid: return False
5594 if self.flags != other.flags: return False
5595 return True
5596
5597 def pretty_print(self, q):
5598 q.text("bsn_image_desc_stats_request {")
5599 with q.group():
5600 with q.indent(2):
5601 q.breakable()
5602 q.text("xid = ");
5603 if self.xid != None:
5604 q.text("%#x" % self.xid)
5605 else:
5606 q.text('None')
5607 q.text(","); q.breakable()
5608 q.text("flags = ");
5609 q.text("%#x" % self.flags)
5610 q.breakable()
5611 q.text('}')
5612
5613bsn_stats_request.subtypes[14] = bsn_image_desc_stats_request
5614
5615class bsn_lacp_convergence_notif(bsn_header):
5616 version = 5
5617 type = 4
5618 experimenter = 6035143
5619 subtype = 43
5620
5621 def __init__(self, xid=None, convergence_status=None, port_no=None, actor_sys_priority=None, actor_sys_mac=None, actor_port_priority=None, actor_port_num=None, actor_key=None, partner_sys_priority=None, partner_sys_mac=None, partner_port_priority=None, partner_port_num=None, partner_key=None):
5622 if xid != None:
5623 self.xid = xid
5624 else:
5625 self.xid = None
5626 if convergence_status != None:
5627 self.convergence_status = convergence_status
5628 else:
5629 self.convergence_status = 0
5630 if port_no != None:
5631 self.port_no = port_no
5632 else:
5633 self.port_no = 0
5634 if actor_sys_priority != None:
5635 self.actor_sys_priority = actor_sys_priority
5636 else:
5637 self.actor_sys_priority = 0
5638 if actor_sys_mac != None:
5639 self.actor_sys_mac = actor_sys_mac
5640 else:
5641 self.actor_sys_mac = [0,0,0,0,0,0]
5642 if actor_port_priority != None:
5643 self.actor_port_priority = actor_port_priority
5644 else:
5645 self.actor_port_priority = 0
5646 if actor_port_num != None:
5647 self.actor_port_num = actor_port_num
5648 else:
5649 self.actor_port_num = 0
5650 if actor_key != None:
5651 self.actor_key = actor_key
5652 else:
5653 self.actor_key = 0
5654 if partner_sys_priority != None:
5655 self.partner_sys_priority = partner_sys_priority
5656 else:
5657 self.partner_sys_priority = 0
5658 if partner_sys_mac != None:
5659 self.partner_sys_mac = partner_sys_mac
5660 else:
5661 self.partner_sys_mac = [0,0,0,0,0,0]
5662 if partner_port_priority != None:
5663 self.partner_port_priority = partner_port_priority
5664 else:
5665 self.partner_port_priority = 0
5666 if partner_port_num != None:
5667 self.partner_port_num = partner_port_num
5668 else:
5669 self.partner_port_num = 0
5670 if partner_key != None:
5671 self.partner_key = partner_key
5672 else:
5673 self.partner_key = 0
5674 return
5675
5676 def pack(self):
5677 packed = []
5678 packed.append(struct.pack("!B", self.version))
5679 packed.append(struct.pack("!B", self.type))
5680 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5681 packed.append(struct.pack("!L", self.xid))
5682 packed.append(struct.pack("!L", self.experimenter))
5683 packed.append(struct.pack("!L", self.subtype))
5684 packed.append(struct.pack("!B", self.convergence_status))
5685 packed.append('\x00' * 3)
5686 packed.append(util.pack_port_no(self.port_no))
5687 packed.append(struct.pack("!H", self.actor_sys_priority))
5688 packed.append(struct.pack("!6B", *self.actor_sys_mac))
5689 packed.append(struct.pack("!H", self.actor_port_priority))
5690 packed.append(struct.pack("!H", self.actor_port_num))
5691 packed.append(struct.pack("!H", self.actor_key))
5692 packed.append(struct.pack("!H", self.partner_sys_priority))
5693 packed.append(struct.pack("!6B", *self.partner_sys_mac))
5694 packed.append(struct.pack("!H", self.partner_port_priority))
5695 packed.append(struct.pack("!H", self.partner_port_num))
5696 packed.append(struct.pack("!H", self.partner_key))
5697 length = sum([len(x) for x in packed])
5698 packed[2] = struct.pack("!H", length)
5699 return ''.join(packed)
5700
5701 @staticmethod
5702 def unpack(reader):
5703 obj = bsn_lacp_convergence_notif()
5704 _version = reader.read("!B")[0]
5705 assert(_version == 5)
5706 _type = reader.read("!B")[0]
5707 assert(_type == 4)
5708 _length = reader.read("!H")[0]
5709 orig_reader = reader
5710 reader = orig_reader.slice(_length, 4)
5711 obj.xid = reader.read("!L")[0]
5712 _experimenter = reader.read("!L")[0]
5713 assert(_experimenter == 6035143)
5714 _subtype = reader.read("!L")[0]
5715 assert(_subtype == 43)
5716 obj.convergence_status = reader.read("!B")[0]
5717 reader.skip(3)
5718 obj.port_no = util.unpack_port_no(reader)
5719 obj.actor_sys_priority = reader.read("!H")[0]
5720 obj.actor_sys_mac = list(reader.read('!6B'))
5721 obj.actor_port_priority = reader.read("!H")[0]
5722 obj.actor_port_num = reader.read("!H")[0]
5723 obj.actor_key = reader.read("!H")[0]
5724 obj.partner_sys_priority = reader.read("!H")[0]
5725 obj.partner_sys_mac = list(reader.read('!6B'))
5726 obj.partner_port_priority = reader.read("!H")[0]
5727 obj.partner_port_num = reader.read("!H")[0]
5728 obj.partner_key = reader.read("!H")[0]
5729 return obj
5730
5731 def __eq__(self, other):
5732 if type(self) != type(other): return False
5733 if self.xid != other.xid: return False
5734 if self.convergence_status != other.convergence_status: return False
5735 if self.port_no != other.port_no: return False
5736 if self.actor_sys_priority != other.actor_sys_priority: return False
5737 if self.actor_sys_mac != other.actor_sys_mac: return False
5738 if self.actor_port_priority != other.actor_port_priority: return False
5739 if self.actor_port_num != other.actor_port_num: return False
5740 if self.actor_key != other.actor_key: return False
5741 if self.partner_sys_priority != other.partner_sys_priority: return False
5742 if self.partner_sys_mac != other.partner_sys_mac: return False
5743 if self.partner_port_priority != other.partner_port_priority: return False
5744 if self.partner_port_num != other.partner_port_num: return False
5745 if self.partner_key != other.partner_key: return False
5746 return True
5747
5748 def pretty_print(self, q):
5749 q.text("bsn_lacp_convergence_notif {")
5750 with q.group():
5751 with q.indent(2):
5752 q.breakable()
5753 q.text("xid = ");
5754 if self.xid != None:
5755 q.text("%#x" % self.xid)
5756 else:
5757 q.text('None')
5758 q.text(","); q.breakable()
5759 q.text("convergence_status = ");
5760 q.text("%#x" % self.convergence_status)
5761 q.text(","); q.breakable()
5762 q.text("port_no = ");
5763 q.text(util.pretty_port(self.port_no))
5764 q.text(","); q.breakable()
5765 q.text("actor_sys_priority = ");
5766 q.text("%#x" % self.actor_sys_priority)
5767 q.text(","); q.breakable()
5768 q.text("actor_sys_mac = ");
5769 q.text(util.pretty_mac(self.actor_sys_mac))
5770 q.text(","); q.breakable()
5771 q.text("actor_port_priority = ");
5772 q.text("%#x" % self.actor_port_priority)
5773 q.text(","); q.breakable()
5774 q.text("actor_port_num = ");
5775 q.text("%#x" % self.actor_port_num)
5776 q.text(","); q.breakable()
5777 q.text("actor_key = ");
5778 q.text("%#x" % self.actor_key)
5779 q.text(","); q.breakable()
5780 q.text("partner_sys_priority = ");
5781 q.text("%#x" % self.partner_sys_priority)
5782 q.text(","); q.breakable()
5783 q.text("partner_sys_mac = ");
5784 q.text(util.pretty_mac(self.partner_sys_mac))
5785 q.text(","); q.breakable()
5786 q.text("partner_port_priority = ");
5787 q.text("%#x" % self.partner_port_priority)
5788 q.text(","); q.breakable()
5789 q.text("partner_port_num = ");
5790 q.text("%#x" % self.partner_port_num)
5791 q.text(","); q.breakable()
5792 q.text("partner_key = ");
5793 q.text("%#x" % self.partner_key)
5794 q.breakable()
5795 q.text('}')
5796
5797bsn_header.subtypes[43] = bsn_lacp_convergence_notif
5798
5799class bsn_lacp_stats_reply(bsn_stats_reply):
5800 version = 5
5801 type = 19
5802 stats_type = 65535
5803 experimenter = 6035143
5804 subtype = 1
5805
5806 def __init__(self, xid=None, flags=None, entries=None):
5807 if xid != None:
5808 self.xid = xid
5809 else:
5810 self.xid = None
5811 if flags != None:
5812 self.flags = flags
5813 else:
5814 self.flags = 0
5815 if entries != None:
5816 self.entries = entries
5817 else:
5818 self.entries = []
5819 return
5820
5821 def pack(self):
5822 packed = []
5823 packed.append(struct.pack("!B", self.version))
5824 packed.append(struct.pack("!B", self.type))
5825 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5826 packed.append(struct.pack("!L", self.xid))
5827 packed.append(struct.pack("!H", self.stats_type))
5828 packed.append(struct.pack("!H", self.flags))
5829 packed.append('\x00' * 4)
5830 packed.append(struct.pack("!L", self.experimenter))
5831 packed.append(struct.pack("!L", self.subtype))
5832 packed.append(loxi.generic_util.pack_list(self.entries))
5833 length = sum([len(x) for x in packed])
5834 packed[2] = struct.pack("!H", length)
5835 return ''.join(packed)
5836
5837 @staticmethod
5838 def unpack(reader):
5839 obj = bsn_lacp_stats_reply()
5840 _version = reader.read("!B")[0]
5841 assert(_version == 5)
5842 _type = reader.read("!B")[0]
5843 assert(_type == 19)
5844 _length = reader.read("!H")[0]
5845 orig_reader = reader
5846 reader = orig_reader.slice(_length, 4)
5847 obj.xid = reader.read("!L")[0]
5848 _stats_type = reader.read("!H")[0]
5849 assert(_stats_type == 65535)
5850 obj.flags = reader.read("!H")[0]
5851 reader.skip(4)
5852 _experimenter = reader.read("!L")[0]
5853 assert(_experimenter == 6035143)
5854 _subtype = reader.read("!L")[0]
5855 assert(_subtype == 1)
5856 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_lacp_stats_entry.unpack)
5857 return obj
5858
5859 def __eq__(self, other):
5860 if type(self) != type(other): return False
5861 if self.xid != other.xid: return False
5862 if self.flags != other.flags: return False
5863 if self.entries != other.entries: return False
5864 return True
5865
5866 def pretty_print(self, q):
5867 q.text("bsn_lacp_stats_reply {")
5868 with q.group():
5869 with q.indent(2):
5870 q.breakable()
5871 q.text("xid = ");
5872 if self.xid != None:
5873 q.text("%#x" % self.xid)
5874 else:
5875 q.text('None')
5876 q.text(","); q.breakable()
5877 q.text("flags = ");
5878 q.text("%#x" % self.flags)
5879 q.text(","); q.breakable()
5880 q.text("entries = ");
5881 q.pp(self.entries)
5882 q.breakable()
5883 q.text('}')
5884
5885bsn_stats_reply.subtypes[1] = bsn_lacp_stats_reply
5886
5887class bsn_lacp_stats_request(bsn_stats_request):
5888 version = 5
5889 type = 18
5890 stats_type = 65535
5891 experimenter = 6035143
5892 subtype = 1
5893
5894 def __init__(self, xid=None, flags=None):
5895 if xid != None:
5896 self.xid = xid
5897 else:
5898 self.xid = None
5899 if flags != None:
5900 self.flags = flags
5901 else:
5902 self.flags = 0
5903 return
5904
5905 def pack(self):
5906 packed = []
5907 packed.append(struct.pack("!B", self.version))
5908 packed.append(struct.pack("!B", self.type))
5909 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5910 packed.append(struct.pack("!L", self.xid))
5911 packed.append(struct.pack("!H", self.stats_type))
5912 packed.append(struct.pack("!H", self.flags))
5913 packed.append('\x00' * 4)
5914 packed.append(struct.pack("!L", self.experimenter))
5915 packed.append(struct.pack("!L", self.subtype))
5916 length = sum([len(x) for x in packed])
5917 packed[2] = struct.pack("!H", length)
5918 return ''.join(packed)
5919
5920 @staticmethod
5921 def unpack(reader):
5922 obj = bsn_lacp_stats_request()
5923 _version = reader.read("!B")[0]
5924 assert(_version == 5)
5925 _type = reader.read("!B")[0]
5926 assert(_type == 18)
5927 _length = reader.read("!H")[0]
5928 orig_reader = reader
5929 reader = orig_reader.slice(_length, 4)
5930 obj.xid = reader.read("!L")[0]
5931 _stats_type = reader.read("!H")[0]
5932 assert(_stats_type == 65535)
5933 obj.flags = reader.read("!H")[0]
5934 reader.skip(4)
5935 _experimenter = reader.read("!L")[0]
5936 assert(_experimenter == 6035143)
5937 _subtype = reader.read("!L")[0]
5938 assert(_subtype == 1)
5939 return obj
5940
5941 def __eq__(self, other):
5942 if type(self) != type(other): return False
5943 if self.xid != other.xid: return False
5944 if self.flags != other.flags: return False
5945 return True
5946
5947 def pretty_print(self, q):
5948 q.text("bsn_lacp_stats_request {")
5949 with q.group():
5950 with q.indent(2):
5951 q.breakable()
5952 q.text("xid = ");
5953 if self.xid != None:
5954 q.text("%#x" % self.xid)
5955 else:
5956 q.text('None')
5957 q.text(","); q.breakable()
5958 q.text("flags = ");
5959 q.text("%#x" % self.flags)
5960 q.breakable()
5961 q.text('}')
5962
5963bsn_stats_request.subtypes[1] = bsn_lacp_stats_request
5964
5965class bsn_log(bsn_header):
5966 version = 5
5967 type = 4
5968 experimenter = 6035143
5969 subtype = 63
5970
5971 def __init__(self, xid=None, loglevel=None, data=None):
5972 if xid != None:
5973 self.xid = xid
5974 else:
5975 self.xid = None
5976 if loglevel != None:
5977 self.loglevel = loglevel
5978 else:
5979 self.loglevel = 0
5980 if data != None:
5981 self.data = data
5982 else:
5983 self.data = ''
5984 return
5985
5986 def pack(self):
5987 packed = []
5988 packed.append(struct.pack("!B", self.version))
5989 packed.append(struct.pack("!B", self.type))
5990 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5991 packed.append(struct.pack("!L", self.xid))
5992 packed.append(struct.pack("!L", self.experimenter))
5993 packed.append(struct.pack("!L", self.subtype))
5994 packed.append(struct.pack("!B", self.loglevel))
5995 packed.append(self.data)
5996 length = sum([len(x) for x in packed])
5997 packed[2] = struct.pack("!H", length)
5998 return ''.join(packed)
5999
6000 @staticmethod
6001 def unpack(reader):
6002 obj = bsn_log()
6003 _version = reader.read("!B")[0]
6004 assert(_version == 5)
6005 _type = reader.read("!B")[0]
6006 assert(_type == 4)
6007 _length = reader.read("!H")[0]
6008 orig_reader = reader
6009 reader = orig_reader.slice(_length, 4)
6010 obj.xid = reader.read("!L")[0]
6011 _experimenter = reader.read("!L")[0]
6012 assert(_experimenter == 6035143)
6013 _subtype = reader.read("!L")[0]
6014 assert(_subtype == 63)
6015 obj.loglevel = reader.read("!B")[0]
6016 obj.data = str(reader.read_all())
6017 return obj
6018
6019 def __eq__(self, other):
6020 if type(self) != type(other): return False
6021 if self.xid != other.xid: return False
6022 if self.loglevel != other.loglevel: return False
6023 if self.data != other.data: return False
6024 return True
6025
6026 def pretty_print(self, q):
6027 q.text("bsn_log {")
6028 with q.group():
6029 with q.indent(2):
6030 q.breakable()
6031 q.text("xid = ");
6032 if self.xid != None:
6033 q.text("%#x" % self.xid)
6034 else:
6035 q.text('None')
6036 q.text(","); q.breakable()
6037 q.text("loglevel = ");
6038 q.text("%#x" % self.loglevel)
6039 q.text(","); q.breakable()
6040 q.text("data = ");
6041 q.pp(self.data)
6042 q.breakable()
6043 q.text('}')
6044
6045bsn_header.subtypes[63] = bsn_log
6046
6047class bsn_lua_command_reply(bsn_header):
6048 version = 5
6049 type = 4
6050 experimenter = 6035143
6051 subtype = 66
6052
6053 def __init__(self, xid=None, data=None):
6054 if xid != None:
6055 self.xid = xid
6056 else:
6057 self.xid = None
6058 if data != None:
6059 self.data = data
6060 else:
6061 self.data = ''
6062 return
6063
6064 def pack(self):
6065 packed = []
6066 packed.append(struct.pack("!B", self.version))
6067 packed.append(struct.pack("!B", self.type))
6068 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6069 packed.append(struct.pack("!L", self.xid))
6070 packed.append(struct.pack("!L", self.experimenter))
6071 packed.append(struct.pack("!L", self.subtype))
6072 packed.append(self.data)
6073 length = sum([len(x) for x in packed])
6074 packed[2] = struct.pack("!H", length)
6075 return ''.join(packed)
6076
6077 @staticmethod
6078 def unpack(reader):
6079 obj = bsn_lua_command_reply()
6080 _version = reader.read("!B")[0]
6081 assert(_version == 5)
6082 _type = reader.read("!B")[0]
6083 assert(_type == 4)
6084 _length = reader.read("!H")[0]
6085 orig_reader = reader
6086 reader = orig_reader.slice(_length, 4)
6087 obj.xid = reader.read("!L")[0]
6088 _experimenter = reader.read("!L")[0]
6089 assert(_experimenter == 6035143)
6090 _subtype = reader.read("!L")[0]
6091 assert(_subtype == 66)
6092 obj.data = str(reader.read_all())
6093 return obj
6094
6095 def __eq__(self, other):
6096 if type(self) != type(other): return False
6097 if self.xid != other.xid: return False
6098 if self.data != other.data: return False
6099 return True
6100
6101 def pretty_print(self, q):
6102 q.text("bsn_lua_command_reply {")
6103 with q.group():
6104 with q.indent(2):
6105 q.breakable()
6106 q.text("xid = ");
6107 if self.xid != None:
6108 q.text("%#x" % self.xid)
6109 else:
6110 q.text('None')
6111 q.text(","); q.breakable()
6112 q.text("data = ");
6113 q.pp(self.data)
6114 q.breakable()
6115 q.text('}')
6116
6117bsn_header.subtypes[66] = bsn_lua_command_reply
6118
6119class bsn_lua_command_request(bsn_header):
6120 version = 5
6121 type = 4
6122 experimenter = 6035143
6123 subtype = 65
6124
6125 def __init__(self, xid=None, data=None):
6126 if xid != None:
6127 self.xid = xid
6128 else:
6129 self.xid = None
6130 if data != None:
6131 self.data = data
6132 else:
6133 self.data = ''
6134 return
6135
6136 def pack(self):
6137 packed = []
6138 packed.append(struct.pack("!B", self.version))
6139 packed.append(struct.pack("!B", self.type))
6140 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6141 packed.append(struct.pack("!L", self.xid))
6142 packed.append(struct.pack("!L", self.experimenter))
6143 packed.append(struct.pack("!L", self.subtype))
6144 packed.append(self.data)
6145 length = sum([len(x) for x in packed])
6146 packed[2] = struct.pack("!H", length)
6147 return ''.join(packed)
6148
6149 @staticmethod
6150 def unpack(reader):
6151 obj = bsn_lua_command_request()
6152 _version = reader.read("!B")[0]
6153 assert(_version == 5)
6154 _type = reader.read("!B")[0]
6155 assert(_type == 4)
6156 _length = reader.read("!H")[0]
6157 orig_reader = reader
6158 reader = orig_reader.slice(_length, 4)
6159 obj.xid = reader.read("!L")[0]
6160 _experimenter = reader.read("!L")[0]
6161 assert(_experimenter == 6035143)
6162 _subtype = reader.read("!L")[0]
6163 assert(_subtype == 65)
6164 obj.data = str(reader.read_all())
6165 return obj
6166
6167 def __eq__(self, other):
6168 if type(self) != type(other): return False
6169 if self.xid != other.xid: return False
6170 if self.data != other.data: return False
6171 return True
6172
6173 def pretty_print(self, q):
6174 q.text("bsn_lua_command_request {")
6175 with q.group():
6176 with q.indent(2):
6177 q.breakable()
6178 q.text("xid = ");
6179 if self.xid != None:
6180 q.text("%#x" % self.xid)
6181 else:
6182 q.text('None')
6183 q.text(","); q.breakable()
6184 q.text("data = ");
6185 q.pp(self.data)
6186 q.breakable()
6187 q.text('}')
6188
6189bsn_header.subtypes[65] = bsn_lua_command_request
6190
6191class bsn_lua_notification(bsn_header):
6192 version = 5
6193 type = 4
6194 experimenter = 6035143
6195 subtype = 67
6196
6197 def __init__(self, xid=None, data=None):
6198 if xid != None:
6199 self.xid = xid
6200 else:
6201 self.xid = None
6202 if data != None:
6203 self.data = data
6204 else:
6205 self.data = ''
6206 return
6207
6208 def pack(self):
6209 packed = []
6210 packed.append(struct.pack("!B", self.version))
6211 packed.append(struct.pack("!B", self.type))
6212 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6213 packed.append(struct.pack("!L", self.xid))
6214 packed.append(struct.pack("!L", self.experimenter))
6215 packed.append(struct.pack("!L", self.subtype))
6216 packed.append(self.data)
6217 length = sum([len(x) for x in packed])
6218 packed[2] = struct.pack("!H", length)
6219 return ''.join(packed)
6220
6221 @staticmethod
6222 def unpack(reader):
6223 obj = bsn_lua_notification()
6224 _version = reader.read("!B")[0]
6225 assert(_version == 5)
6226 _type = reader.read("!B")[0]
6227 assert(_type == 4)
6228 _length = reader.read("!H")[0]
6229 orig_reader = reader
6230 reader = orig_reader.slice(_length, 4)
6231 obj.xid = reader.read("!L")[0]
6232 _experimenter = reader.read("!L")[0]
6233 assert(_experimenter == 6035143)
6234 _subtype = reader.read("!L")[0]
6235 assert(_subtype == 67)
6236 obj.data = str(reader.read_all())
6237 return obj
6238
6239 def __eq__(self, other):
6240 if type(self) != type(other): return False
6241 if self.xid != other.xid: return False
6242 if self.data != other.data: return False
6243 return True
6244
6245 def pretty_print(self, q):
6246 q.text("bsn_lua_notification {")
6247 with q.group():
6248 with q.indent(2):
6249 q.breakable()
6250 q.text("xid = ");
6251 if self.xid != None:
6252 q.text("%#x" % self.xid)
6253 else:
6254 q.text('None')
6255 q.text(","); q.breakable()
6256 q.text("data = ");
6257 q.pp(self.data)
6258 q.breakable()
6259 q.text('}')
6260
6261bsn_header.subtypes[67] = bsn_lua_notification
6262
6263class bsn_lua_upload(bsn_header):
6264 version = 5
6265 type = 4
6266 experimenter = 6035143
6267 subtype = 64
6268
6269 def __init__(self, xid=None, flags=None, filename=None, data=None):
6270 if xid != None:
6271 self.xid = xid
6272 else:
6273 self.xid = None
6274 if flags != None:
6275 self.flags = flags
6276 else:
6277 self.flags = 0
6278 if filename != None:
6279 self.filename = filename
6280 else:
6281 self.filename = ""
6282 if data != None:
6283 self.data = data
6284 else:
6285 self.data = ''
6286 return
6287
6288 def pack(self):
6289 packed = []
6290 packed.append(struct.pack("!B", self.version))
6291 packed.append(struct.pack("!B", self.type))
6292 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6293 packed.append(struct.pack("!L", self.xid))
6294 packed.append(struct.pack("!L", self.experimenter))
6295 packed.append(struct.pack("!L", self.subtype))
6296 packed.append(struct.pack("!H", self.flags))
6297 packed.append(struct.pack("!64s", self.filename))
6298 packed.append(self.data)
6299 length = sum([len(x) for x in packed])
6300 packed[2] = struct.pack("!H", length)
6301 return ''.join(packed)
6302
6303 @staticmethod
6304 def unpack(reader):
6305 obj = bsn_lua_upload()
6306 _version = reader.read("!B")[0]
6307 assert(_version == 5)
6308 _type = reader.read("!B")[0]
6309 assert(_type == 4)
6310 _length = reader.read("!H")[0]
6311 orig_reader = reader
6312 reader = orig_reader.slice(_length, 4)
6313 obj.xid = reader.read("!L")[0]
6314 _experimenter = reader.read("!L")[0]
6315 assert(_experimenter == 6035143)
6316 _subtype = reader.read("!L")[0]
6317 assert(_subtype == 64)
6318 obj.flags = reader.read("!H")[0]
6319 obj.filename = reader.read("!64s")[0].rstrip("\x00")
6320 obj.data = str(reader.read_all())
6321 return obj
6322
6323 def __eq__(self, other):
6324 if type(self) != type(other): return False
6325 if self.xid != other.xid: return False
6326 if self.flags != other.flags: return False
6327 if self.filename != other.filename: return False
6328 if self.data != other.data: return False
6329 return True
6330
6331 def pretty_print(self, q):
6332 q.text("bsn_lua_upload {")
6333 with q.group():
6334 with q.indent(2):
6335 q.breakable()
6336 q.text("xid = ");
6337 if self.xid != None:
6338 q.text("%#x" % self.xid)
6339 else:
6340 q.text('None')
6341 q.text(","); q.breakable()
6342 q.text("flags = ");
6343 q.text("%#x" % self.flags)
6344 q.text(","); q.breakable()
6345 q.text("filename = ");
6346 q.pp(self.filename)
6347 q.text(","); q.breakable()
6348 q.text("data = ");
6349 q.pp(self.data)
6350 q.breakable()
6351 q.text('}')
6352
6353bsn_header.subtypes[64] = bsn_lua_upload
6354
6355class bsn_pdu_rx_reply(bsn_header):
6356 version = 5
6357 type = 4
6358 experimenter = 6035143
6359 subtype = 34
6360
6361 def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
6362 if xid != None:
6363 self.xid = xid
6364 else:
6365 self.xid = None
6366 if status != None:
6367 self.status = status
6368 else:
6369 self.status = 0
6370 if port_no != None:
6371 self.port_no = port_no
6372 else:
6373 self.port_no = 0
6374 if slot_num != None:
6375 self.slot_num = slot_num
6376 else:
6377 self.slot_num = 0
6378 return
6379
6380 def pack(self):
6381 packed = []
6382 packed.append(struct.pack("!B", self.version))
6383 packed.append(struct.pack("!B", self.type))
6384 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6385 packed.append(struct.pack("!L", self.xid))
6386 packed.append(struct.pack("!L", self.experimenter))
6387 packed.append(struct.pack("!L", self.subtype))
6388 packed.append(struct.pack("!L", self.status))
6389 packed.append(util.pack_port_no(self.port_no))
6390 packed.append(struct.pack("!B", self.slot_num))
6391 length = sum([len(x) for x in packed])
6392 packed[2] = struct.pack("!H", length)
6393 return ''.join(packed)
6394
6395 @staticmethod
6396 def unpack(reader):
6397 obj = bsn_pdu_rx_reply()
6398 _version = reader.read("!B")[0]
6399 assert(_version == 5)
6400 _type = reader.read("!B")[0]
6401 assert(_type == 4)
6402 _length = reader.read("!H")[0]
6403 orig_reader = reader
6404 reader = orig_reader.slice(_length, 4)
6405 obj.xid = reader.read("!L")[0]
6406 _experimenter = reader.read("!L")[0]
6407 assert(_experimenter == 6035143)
6408 _subtype = reader.read("!L")[0]
6409 assert(_subtype == 34)
6410 obj.status = reader.read("!L")[0]
6411 obj.port_no = util.unpack_port_no(reader)
6412 obj.slot_num = reader.read("!B")[0]
6413 return obj
6414
6415 def __eq__(self, other):
6416 if type(self) != type(other): return False
6417 if self.xid != other.xid: return False
6418 if self.status != other.status: return False
6419 if self.port_no != other.port_no: return False
6420 if self.slot_num != other.slot_num: return False
6421 return True
6422
6423 def pretty_print(self, q):
6424 q.text("bsn_pdu_rx_reply {")
6425 with q.group():
6426 with q.indent(2):
6427 q.breakable()
6428 q.text("xid = ");
6429 if self.xid != None:
6430 q.text("%#x" % self.xid)
6431 else:
6432 q.text('None')
6433 q.text(","); q.breakable()
6434 q.text("status = ");
6435 q.text("%#x" % self.status)
6436 q.text(","); q.breakable()
6437 q.text("port_no = ");
6438 q.text(util.pretty_port(self.port_no))
6439 q.text(","); q.breakable()
6440 q.text("slot_num = ");
6441 q.text("%#x" % self.slot_num)
6442 q.breakable()
6443 q.text('}')
6444
6445bsn_header.subtypes[34] = bsn_pdu_rx_reply
6446
6447class bsn_pdu_rx_request(bsn_header):
6448 version = 5
6449 type = 4
6450 experimenter = 6035143
6451 subtype = 33
6452
6453 def __init__(self, xid=None, timeout_ms=None, port_no=None, slot_num=None, data=None):
6454 if xid != None:
6455 self.xid = xid
6456 else:
6457 self.xid = None
6458 if timeout_ms != None:
6459 self.timeout_ms = timeout_ms
6460 else:
6461 self.timeout_ms = 0
6462 if port_no != None:
6463 self.port_no = port_no
6464 else:
6465 self.port_no = 0
6466 if slot_num != None:
6467 self.slot_num = slot_num
6468 else:
6469 self.slot_num = 0
6470 if data != None:
6471 self.data = data
6472 else:
6473 self.data = ''
6474 return
6475
6476 def pack(self):
6477 packed = []
6478 packed.append(struct.pack("!B", self.version))
6479 packed.append(struct.pack("!B", self.type))
6480 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6481 packed.append(struct.pack("!L", self.xid))
6482 packed.append(struct.pack("!L", self.experimenter))
6483 packed.append(struct.pack("!L", self.subtype))
6484 packed.append(struct.pack("!L", self.timeout_ms))
6485 packed.append(util.pack_port_no(self.port_no))
6486 packed.append(struct.pack("!B", self.slot_num))
6487 packed.append('\x00' * 3)
6488 packed.append(self.data)
6489 length = sum([len(x) for x in packed])
6490 packed[2] = struct.pack("!H", length)
6491 return ''.join(packed)
6492
6493 @staticmethod
6494 def unpack(reader):
6495 obj = bsn_pdu_rx_request()
6496 _version = reader.read("!B")[0]
6497 assert(_version == 5)
6498 _type = reader.read("!B")[0]
6499 assert(_type == 4)
6500 _length = reader.read("!H")[0]
6501 orig_reader = reader
6502 reader = orig_reader.slice(_length, 4)
6503 obj.xid = reader.read("!L")[0]
6504 _experimenter = reader.read("!L")[0]
6505 assert(_experimenter == 6035143)
6506 _subtype = reader.read("!L")[0]
6507 assert(_subtype == 33)
6508 obj.timeout_ms = reader.read("!L")[0]
6509 obj.port_no = util.unpack_port_no(reader)
6510 obj.slot_num = reader.read("!B")[0]
6511 reader.skip(3)
6512 obj.data = str(reader.read_all())
6513 return obj
6514
6515 def __eq__(self, other):
6516 if type(self) != type(other): return False
6517 if self.xid != other.xid: return False
6518 if self.timeout_ms != other.timeout_ms: return False
6519 if self.port_no != other.port_no: return False
6520 if self.slot_num != other.slot_num: return False
6521 if self.data != other.data: return False
6522 return True
6523
6524 def pretty_print(self, q):
6525 q.text("bsn_pdu_rx_request {")
6526 with q.group():
6527 with q.indent(2):
6528 q.breakable()
6529 q.text("xid = ");
6530 if self.xid != None:
6531 q.text("%#x" % self.xid)
6532 else:
6533 q.text('None')
6534 q.text(","); q.breakable()
6535 q.text("timeout_ms = ");
6536 q.text("%#x" % self.timeout_ms)
6537 q.text(","); q.breakable()
6538 q.text("port_no = ");
6539 q.text(util.pretty_port(self.port_no))
6540 q.text(","); q.breakable()
6541 q.text("slot_num = ");
6542 q.text("%#x" % self.slot_num)
6543 q.text(","); q.breakable()
6544 q.text("data = ");
6545 q.pp(self.data)
6546 q.breakable()
6547 q.text('}')
6548
6549bsn_header.subtypes[33] = bsn_pdu_rx_request
6550
6551class bsn_pdu_rx_timeout(bsn_header):
6552 version = 5
6553 type = 4
6554 experimenter = 6035143
6555 subtype = 35
6556
6557 def __init__(self, xid=None, port_no=None, slot_num=None):
6558 if xid != None:
6559 self.xid = xid
6560 else:
6561 self.xid = None
6562 if port_no != None:
6563 self.port_no = port_no
6564 else:
6565 self.port_no = 0
6566 if slot_num != None:
6567 self.slot_num = slot_num
6568 else:
6569 self.slot_num = 0
6570 return
6571
6572 def pack(self):
6573 packed = []
6574 packed.append(struct.pack("!B", self.version))
6575 packed.append(struct.pack("!B", self.type))
6576 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6577 packed.append(struct.pack("!L", self.xid))
6578 packed.append(struct.pack("!L", self.experimenter))
6579 packed.append(struct.pack("!L", self.subtype))
6580 packed.append(util.pack_port_no(self.port_no))
6581 packed.append(struct.pack("!B", self.slot_num))
6582 length = sum([len(x) for x in packed])
6583 packed[2] = struct.pack("!H", length)
6584 return ''.join(packed)
6585
6586 @staticmethod
6587 def unpack(reader):
6588 obj = bsn_pdu_rx_timeout()
6589 _version = reader.read("!B")[0]
6590 assert(_version == 5)
6591 _type = reader.read("!B")[0]
6592 assert(_type == 4)
6593 _length = reader.read("!H")[0]
6594 orig_reader = reader
6595 reader = orig_reader.slice(_length, 4)
6596 obj.xid = reader.read("!L")[0]
6597 _experimenter = reader.read("!L")[0]
6598 assert(_experimenter == 6035143)
6599 _subtype = reader.read("!L")[0]
6600 assert(_subtype == 35)
6601 obj.port_no = util.unpack_port_no(reader)
6602 obj.slot_num = reader.read("!B")[0]
6603 return obj
6604
6605 def __eq__(self, other):
6606 if type(self) != type(other): return False
6607 if self.xid != other.xid: return False
6608 if self.port_no != other.port_no: return False
6609 if self.slot_num != other.slot_num: return False
6610 return True
6611
6612 def pretty_print(self, q):
6613 q.text("bsn_pdu_rx_timeout {")
6614 with q.group():
6615 with q.indent(2):
6616 q.breakable()
6617 q.text("xid = ");
6618 if self.xid != None:
6619 q.text("%#x" % self.xid)
6620 else:
6621 q.text('None')
6622 q.text(","); q.breakable()
6623 q.text("port_no = ");
6624 q.text(util.pretty_port(self.port_no))
6625 q.text(","); q.breakable()
6626 q.text("slot_num = ");
6627 q.text("%#x" % self.slot_num)
6628 q.breakable()
6629 q.text('}')
6630
6631bsn_header.subtypes[35] = bsn_pdu_rx_timeout
6632
6633class bsn_pdu_tx_reply(bsn_header):
6634 version = 5
6635 type = 4
6636 experimenter = 6035143
6637 subtype = 32
6638
6639 def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
6640 if xid != None:
6641 self.xid = xid
6642 else:
6643 self.xid = None
6644 if status != None:
6645 self.status = status
6646 else:
6647 self.status = 0
6648 if port_no != None:
6649 self.port_no = port_no
6650 else:
6651 self.port_no = 0
6652 if slot_num != None:
6653 self.slot_num = slot_num
6654 else:
6655 self.slot_num = 0
6656 return
6657
6658 def pack(self):
6659 packed = []
6660 packed.append(struct.pack("!B", self.version))
6661 packed.append(struct.pack("!B", self.type))
6662 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6663 packed.append(struct.pack("!L", self.xid))
6664 packed.append(struct.pack("!L", self.experimenter))
6665 packed.append(struct.pack("!L", self.subtype))
6666 packed.append(struct.pack("!L", self.status))
6667 packed.append(util.pack_port_no(self.port_no))
6668 packed.append(struct.pack("!B", self.slot_num))
6669 length = sum([len(x) for x in packed])
6670 packed[2] = struct.pack("!H", length)
6671 return ''.join(packed)
6672
6673 @staticmethod
6674 def unpack(reader):
6675 obj = bsn_pdu_tx_reply()
6676 _version = reader.read("!B")[0]
6677 assert(_version == 5)
6678 _type = reader.read("!B")[0]
6679 assert(_type == 4)
6680 _length = reader.read("!H")[0]
6681 orig_reader = reader
6682 reader = orig_reader.slice(_length, 4)
6683 obj.xid = reader.read("!L")[0]
6684 _experimenter = reader.read("!L")[0]
6685 assert(_experimenter == 6035143)
6686 _subtype = reader.read("!L")[0]
6687 assert(_subtype == 32)
6688 obj.status = reader.read("!L")[0]
6689 obj.port_no = util.unpack_port_no(reader)
6690 obj.slot_num = reader.read("!B")[0]
6691 return obj
6692
6693 def __eq__(self, other):
6694 if type(self) != type(other): return False
6695 if self.xid != other.xid: return False
6696 if self.status != other.status: return False
6697 if self.port_no != other.port_no: return False
6698 if self.slot_num != other.slot_num: return False
6699 return True
6700
6701 def pretty_print(self, q):
6702 q.text("bsn_pdu_tx_reply {")
6703 with q.group():
6704 with q.indent(2):
6705 q.breakable()
6706 q.text("xid = ");
6707 if self.xid != None:
6708 q.text("%#x" % self.xid)
6709 else:
6710 q.text('None')
6711 q.text(","); q.breakable()
6712 q.text("status = ");
6713 q.text("%#x" % self.status)
6714 q.text(","); q.breakable()
6715 q.text("port_no = ");
6716 q.text(util.pretty_port(self.port_no))
6717 q.text(","); q.breakable()
6718 q.text("slot_num = ");
6719 q.text("%#x" % self.slot_num)
6720 q.breakable()
6721 q.text('}')
6722
6723bsn_header.subtypes[32] = bsn_pdu_tx_reply
6724
6725class bsn_pdu_tx_request(bsn_header):
6726 version = 5
6727 type = 4
6728 experimenter = 6035143
6729 subtype = 31
6730
6731 def __init__(self, xid=None, tx_interval_ms=None, port_no=None, slot_num=None, data=None):
6732 if xid != None:
6733 self.xid = xid
6734 else:
6735 self.xid = None
6736 if tx_interval_ms != None:
6737 self.tx_interval_ms = tx_interval_ms
6738 else:
6739 self.tx_interval_ms = 0
6740 if port_no != None:
6741 self.port_no = port_no
6742 else:
6743 self.port_no = 0
6744 if slot_num != None:
6745 self.slot_num = slot_num
6746 else:
6747 self.slot_num = 0
6748 if data != None:
6749 self.data = data
6750 else:
6751 self.data = ''
6752 return
6753
6754 def pack(self):
6755 packed = []
6756 packed.append(struct.pack("!B", self.version))
6757 packed.append(struct.pack("!B", self.type))
6758 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6759 packed.append(struct.pack("!L", self.xid))
6760 packed.append(struct.pack("!L", self.experimenter))
6761 packed.append(struct.pack("!L", self.subtype))
6762 packed.append(struct.pack("!L", self.tx_interval_ms))
6763 packed.append(util.pack_port_no(self.port_no))
6764 packed.append(struct.pack("!B", self.slot_num))
6765 packed.append('\x00' * 3)
6766 packed.append(self.data)
6767 length = sum([len(x) for x in packed])
6768 packed[2] = struct.pack("!H", length)
6769 return ''.join(packed)
6770
6771 @staticmethod
6772 def unpack(reader):
6773 obj = bsn_pdu_tx_request()
6774 _version = reader.read("!B")[0]
6775 assert(_version == 5)
6776 _type = reader.read("!B")[0]
6777 assert(_type == 4)
6778 _length = reader.read("!H")[0]
6779 orig_reader = reader
6780 reader = orig_reader.slice(_length, 4)
6781 obj.xid = reader.read("!L")[0]
6782 _experimenter = reader.read("!L")[0]
6783 assert(_experimenter == 6035143)
6784 _subtype = reader.read("!L")[0]
6785 assert(_subtype == 31)
6786 obj.tx_interval_ms = reader.read("!L")[0]
6787 obj.port_no = util.unpack_port_no(reader)
6788 obj.slot_num = reader.read("!B")[0]
6789 reader.skip(3)
6790 obj.data = str(reader.read_all())
6791 return obj
6792
6793 def __eq__(self, other):
6794 if type(self) != type(other): return False
6795 if self.xid != other.xid: return False
6796 if self.tx_interval_ms != other.tx_interval_ms: return False
6797 if self.port_no != other.port_no: return False
6798 if self.slot_num != other.slot_num: return False
6799 if self.data != other.data: return False
6800 return True
6801
6802 def pretty_print(self, q):
6803 q.text("bsn_pdu_tx_request {")
6804 with q.group():
6805 with q.indent(2):
6806 q.breakable()
6807 q.text("xid = ");
6808 if self.xid != None:
6809 q.text("%#x" % self.xid)
6810 else:
6811 q.text('None')
6812 q.text(","); q.breakable()
6813 q.text("tx_interval_ms = ");
6814 q.text("%#x" % self.tx_interval_ms)
6815 q.text(","); q.breakable()
6816 q.text("port_no = ");
6817 q.text(util.pretty_port(self.port_no))
6818 q.text(","); q.breakable()
6819 q.text("slot_num = ");
6820 q.text("%#x" % self.slot_num)
6821 q.text(","); q.breakable()
6822 q.text("data = ");
6823 q.pp(self.data)
6824 q.breakable()
6825 q.text('}')
6826
6827bsn_header.subtypes[31] = bsn_pdu_tx_request
6828
6829class bsn_port_counter_stats_reply(bsn_stats_reply):
6830 version = 5
6831 type = 19
6832 stats_type = 65535
6833 experimenter = 6035143
6834 subtype = 8
6835
6836 def __init__(self, xid=None, flags=None, entries=None):
6837 if xid != None:
6838 self.xid = xid
6839 else:
6840 self.xid = None
6841 if flags != None:
6842 self.flags = flags
6843 else:
6844 self.flags = 0
6845 if entries != None:
6846 self.entries = entries
6847 else:
6848 self.entries = []
6849 return
6850
6851 def pack(self):
6852 packed = []
6853 packed.append(struct.pack("!B", self.version))
6854 packed.append(struct.pack("!B", self.type))
6855 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6856 packed.append(struct.pack("!L", self.xid))
6857 packed.append(struct.pack("!H", self.stats_type))
6858 packed.append(struct.pack("!H", self.flags))
6859 packed.append('\x00' * 4)
6860 packed.append(struct.pack("!L", self.experimenter))
6861 packed.append(struct.pack("!L", self.subtype))
6862 packed.append(loxi.generic_util.pack_list(self.entries))
6863 length = sum([len(x) for x in packed])
6864 packed[2] = struct.pack("!H", length)
6865 return ''.join(packed)
6866
6867 @staticmethod
6868 def unpack(reader):
6869 obj = bsn_port_counter_stats_reply()
6870 _version = reader.read("!B")[0]
6871 assert(_version == 5)
6872 _type = reader.read("!B")[0]
6873 assert(_type == 19)
6874 _length = reader.read("!H")[0]
6875 orig_reader = reader
6876 reader = orig_reader.slice(_length, 4)
6877 obj.xid = reader.read("!L")[0]
6878 _stats_type = reader.read("!H")[0]
6879 assert(_stats_type == 65535)
6880 obj.flags = reader.read("!H")[0]
6881 reader.skip(4)
6882 _experimenter = reader.read("!L")[0]
6883 assert(_experimenter == 6035143)
6884 _subtype = reader.read("!L")[0]
6885 assert(_subtype == 8)
6886 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_port_counter_stats_entry.unpack)
6887 return obj
6888
6889 def __eq__(self, other):
6890 if type(self) != type(other): return False
6891 if self.xid != other.xid: return False
6892 if self.flags != other.flags: return False
6893 if self.entries != other.entries: return False
6894 return True
6895
6896 def pretty_print(self, q):
6897 q.text("bsn_port_counter_stats_reply {")
6898 with q.group():
6899 with q.indent(2):
6900 q.breakable()
6901 q.text("xid = ");
6902 if self.xid != None:
6903 q.text("%#x" % self.xid)
6904 else:
6905 q.text('None')
6906 q.text(","); q.breakable()
6907 q.text("flags = ");
6908 q.text("%#x" % self.flags)
6909 q.text(","); q.breakable()
6910 q.text("entries = ");
6911 q.pp(self.entries)
6912 q.breakable()
6913 q.text('}')
6914
6915bsn_stats_reply.subtypes[8] = bsn_port_counter_stats_reply
6916
6917class bsn_port_counter_stats_request(bsn_stats_request):
6918 version = 5
6919 type = 18
6920 stats_type = 65535
6921 experimenter = 6035143
6922 subtype = 8
6923
6924 def __init__(self, xid=None, flags=None, port_no=None):
6925 if xid != None:
6926 self.xid = xid
6927 else:
6928 self.xid = None
6929 if flags != None:
6930 self.flags = flags
6931 else:
6932 self.flags = 0
6933 if port_no != None:
6934 self.port_no = port_no
6935 else:
6936 self.port_no = 0
6937 return
6938
6939 def pack(self):
6940 packed = []
6941 packed.append(struct.pack("!B", self.version))
6942 packed.append(struct.pack("!B", self.type))
6943 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6944 packed.append(struct.pack("!L", self.xid))
6945 packed.append(struct.pack("!H", self.stats_type))
6946 packed.append(struct.pack("!H", self.flags))
6947 packed.append('\x00' * 4)
6948 packed.append(struct.pack("!L", self.experimenter))
6949 packed.append(struct.pack("!L", self.subtype))
6950 packed.append(util.pack_port_no(self.port_no))
6951 length = sum([len(x) for x in packed])
6952 packed[2] = struct.pack("!H", length)
6953 return ''.join(packed)
6954
6955 @staticmethod
6956 def unpack(reader):
6957 obj = bsn_port_counter_stats_request()
6958 _version = reader.read("!B")[0]
6959 assert(_version == 5)
6960 _type = reader.read("!B")[0]
6961 assert(_type == 18)
6962 _length = reader.read("!H")[0]
6963 orig_reader = reader
6964 reader = orig_reader.slice(_length, 4)
6965 obj.xid = reader.read("!L")[0]
6966 _stats_type = reader.read("!H")[0]
6967 assert(_stats_type == 65535)
6968 obj.flags = reader.read("!H")[0]
6969 reader.skip(4)
6970 _experimenter = reader.read("!L")[0]
6971 assert(_experimenter == 6035143)
6972 _subtype = reader.read("!L")[0]
6973 assert(_subtype == 8)
6974 obj.port_no = util.unpack_port_no(reader)
6975 return obj
6976
6977 def __eq__(self, other):
6978 if type(self) != type(other): return False
6979 if self.xid != other.xid: return False
6980 if self.flags != other.flags: return False
6981 if self.port_no != other.port_no: return False
6982 return True
6983
6984 def pretty_print(self, q):
6985 q.text("bsn_port_counter_stats_request {")
6986 with q.group():
6987 with q.indent(2):
6988 q.breakable()
6989 q.text("xid = ");
6990 if self.xid != None:
6991 q.text("%#x" % self.xid)
6992 else:
6993 q.text('None')
6994 q.text(","); q.breakable()
6995 q.text("flags = ");
6996 q.text("%#x" % self.flags)
6997 q.text(","); q.breakable()
6998 q.text("port_no = ");
6999 q.text(util.pretty_port(self.port_no))
7000 q.breakable()
7001 q.text('}')
7002
7003bsn_stats_request.subtypes[8] = bsn_port_counter_stats_request
7004
7005class bsn_set_aux_cxns_reply(bsn_header):
7006 version = 5
7007 type = 4
7008 experimenter = 6035143
7009 subtype = 59
7010
7011 def __init__(self, xid=None, num_aux=None, status=None):
7012 if xid != None:
7013 self.xid = xid
7014 else:
7015 self.xid = None
7016 if num_aux != None:
7017 self.num_aux = num_aux
7018 else:
7019 self.num_aux = 0
7020 if status != None:
7021 self.status = status
7022 else:
7023 self.status = 0
7024 return
7025
7026 def pack(self):
7027 packed = []
7028 packed.append(struct.pack("!B", self.version))
7029 packed.append(struct.pack("!B", self.type))
7030 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7031 packed.append(struct.pack("!L", self.xid))
7032 packed.append(struct.pack("!L", self.experimenter))
7033 packed.append(struct.pack("!L", self.subtype))
7034 packed.append(struct.pack("!L", self.num_aux))
7035 packed.append(struct.pack("!L", self.status))
7036 length = sum([len(x) for x in packed])
7037 packed[2] = struct.pack("!H", length)
7038 return ''.join(packed)
7039
7040 @staticmethod
7041 def unpack(reader):
7042 obj = bsn_set_aux_cxns_reply()
7043 _version = reader.read("!B")[0]
7044 assert(_version == 5)
7045 _type = reader.read("!B")[0]
7046 assert(_type == 4)
7047 _length = reader.read("!H")[0]
7048 orig_reader = reader
7049 reader = orig_reader.slice(_length, 4)
7050 obj.xid = reader.read("!L")[0]
7051 _experimenter = reader.read("!L")[0]
7052 assert(_experimenter == 6035143)
7053 _subtype = reader.read("!L")[0]
7054 assert(_subtype == 59)
7055 obj.num_aux = reader.read("!L")[0]
7056 obj.status = reader.read("!L")[0]
7057 return obj
7058
7059 def __eq__(self, other):
7060 if type(self) != type(other): return False
7061 if self.xid != other.xid: return False
7062 if self.num_aux != other.num_aux: return False
7063 if self.status != other.status: return False
7064 return True
7065
7066 def pretty_print(self, q):
7067 q.text("bsn_set_aux_cxns_reply {")
7068 with q.group():
7069 with q.indent(2):
7070 q.breakable()
7071 q.text("xid = ");
7072 if self.xid != None:
7073 q.text("%#x" % self.xid)
7074 else:
7075 q.text('None')
7076 q.text(","); q.breakable()
7077 q.text("num_aux = ");
7078 q.text("%#x" % self.num_aux)
7079 q.text(","); q.breakable()
7080 q.text("status = ");
7081 q.text("%#x" % self.status)
7082 q.breakable()
7083 q.text('}')
7084
7085bsn_header.subtypes[59] = bsn_set_aux_cxns_reply
7086
7087class bsn_set_aux_cxns_request(bsn_header):
7088 version = 5
7089 type = 4
7090 experimenter = 6035143
7091 subtype = 58
7092
7093 def __init__(self, xid=None, num_aux=None):
7094 if xid != None:
7095 self.xid = xid
7096 else:
7097 self.xid = None
7098 if num_aux != None:
7099 self.num_aux = num_aux
7100 else:
7101 self.num_aux = 0
7102 return
7103
7104 def pack(self):
7105 packed = []
7106 packed.append(struct.pack("!B", self.version))
7107 packed.append(struct.pack("!B", self.type))
7108 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7109 packed.append(struct.pack("!L", self.xid))
7110 packed.append(struct.pack("!L", self.experimenter))
7111 packed.append(struct.pack("!L", self.subtype))
7112 packed.append(struct.pack("!L", self.num_aux))
7113 length = sum([len(x) for x in packed])
7114 packed[2] = struct.pack("!H", length)
7115 return ''.join(packed)
7116
7117 @staticmethod
7118 def unpack(reader):
7119 obj = bsn_set_aux_cxns_request()
7120 _version = reader.read("!B")[0]
7121 assert(_version == 5)
7122 _type = reader.read("!B")[0]
7123 assert(_type == 4)
7124 _length = reader.read("!H")[0]
7125 orig_reader = reader
7126 reader = orig_reader.slice(_length, 4)
7127 obj.xid = reader.read("!L")[0]
7128 _experimenter = reader.read("!L")[0]
7129 assert(_experimenter == 6035143)
7130 _subtype = reader.read("!L")[0]
7131 assert(_subtype == 58)
7132 obj.num_aux = reader.read("!L")[0]
7133 return obj
7134
7135 def __eq__(self, other):
7136 if type(self) != type(other): return False
7137 if self.xid != other.xid: return False
7138 if self.num_aux != other.num_aux: return False
7139 return True
7140
7141 def pretty_print(self, q):
7142 q.text("bsn_set_aux_cxns_request {")
7143 with q.group():
7144 with q.indent(2):
7145 q.breakable()
7146 q.text("xid = ");
7147 if self.xid != None:
7148 q.text("%#x" % self.xid)
7149 else:
7150 q.text('None')
7151 q.text(","); q.breakable()
7152 q.text("num_aux = ");
7153 q.text("%#x" % self.num_aux)
7154 q.breakable()
7155 q.text('}')
7156
7157bsn_header.subtypes[58] = bsn_set_aux_cxns_request
7158
7159class bsn_set_lacp_reply(bsn_header):
7160 version = 5
7161 type = 4
7162 experimenter = 6035143
7163 subtype = 42
7164
7165 def __init__(self, xid=None, status=None, port_no=None):
7166 if xid != None:
7167 self.xid = xid
7168 else:
7169 self.xid = None
7170 if status != None:
7171 self.status = status
7172 else:
7173 self.status = 0
7174 if port_no != None:
7175 self.port_no = port_no
7176 else:
7177 self.port_no = 0
7178 return
7179
7180 def pack(self):
7181 packed = []
7182 packed.append(struct.pack("!B", self.version))
7183 packed.append(struct.pack("!B", self.type))
7184 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7185 packed.append(struct.pack("!L", self.xid))
7186 packed.append(struct.pack("!L", self.experimenter))
7187 packed.append(struct.pack("!L", self.subtype))
7188 packed.append(struct.pack("!L", self.status))
7189 packed.append(util.pack_port_no(self.port_no))
7190 length = sum([len(x) for x in packed])
7191 packed[2] = struct.pack("!H", length)
7192 return ''.join(packed)
7193
7194 @staticmethod
7195 def unpack(reader):
7196 obj = bsn_set_lacp_reply()
7197 _version = reader.read("!B")[0]
7198 assert(_version == 5)
7199 _type = reader.read("!B")[0]
7200 assert(_type == 4)
7201 _length = reader.read("!H")[0]
7202 orig_reader = reader
7203 reader = orig_reader.slice(_length, 4)
7204 obj.xid = reader.read("!L")[0]
7205 _experimenter = reader.read("!L")[0]
7206 assert(_experimenter == 6035143)
7207 _subtype = reader.read("!L")[0]
7208 assert(_subtype == 42)
7209 obj.status = reader.read("!L")[0]
7210 obj.port_no = util.unpack_port_no(reader)
7211 return obj
7212
7213 def __eq__(self, other):
7214 if type(self) != type(other): return False
7215 if self.xid != other.xid: return False
7216 if self.status != other.status: return False
7217 if self.port_no != other.port_no: return False
7218 return True
7219
7220 def pretty_print(self, q):
7221 q.text("bsn_set_lacp_reply {")
7222 with q.group():
7223 with q.indent(2):
7224 q.breakable()
7225 q.text("xid = ");
7226 if self.xid != None:
7227 q.text("%#x" % self.xid)
7228 else:
7229 q.text('None')
7230 q.text(","); q.breakable()
7231 q.text("status = ");
7232 q.text("%#x" % self.status)
7233 q.text(","); q.breakable()
7234 q.text("port_no = ");
7235 q.text(util.pretty_port(self.port_no))
7236 q.breakable()
7237 q.text('}')
7238
7239bsn_header.subtypes[42] = bsn_set_lacp_reply
7240
7241class bsn_set_lacp_request(bsn_header):
7242 version = 5
7243 type = 4
7244 experimenter = 6035143
7245 subtype = 41
7246
7247 def __init__(self, xid=None, enabled=None, port_no=None, actor_sys_priority=None, actor_sys_mac=None, actor_port_priority=None, actor_port_num=None, actor_key=None):
7248 if xid != None:
7249 self.xid = xid
7250 else:
7251 self.xid = None
7252 if enabled != None:
7253 self.enabled = enabled
7254 else:
7255 self.enabled = 0
7256 if port_no != None:
7257 self.port_no = port_no
7258 else:
7259 self.port_no = 0
7260 if actor_sys_priority != None:
7261 self.actor_sys_priority = actor_sys_priority
7262 else:
7263 self.actor_sys_priority = 0
7264 if actor_sys_mac != None:
7265 self.actor_sys_mac = actor_sys_mac
7266 else:
7267 self.actor_sys_mac = [0,0,0,0,0,0]
7268 if actor_port_priority != None:
7269 self.actor_port_priority = actor_port_priority
7270 else:
7271 self.actor_port_priority = 0
7272 if actor_port_num != None:
7273 self.actor_port_num = actor_port_num
7274 else:
7275 self.actor_port_num = 0
7276 if actor_key != None:
7277 self.actor_key = actor_key
7278 else:
7279 self.actor_key = 0
7280 return
7281
7282 def pack(self):
7283 packed = []
7284 packed.append(struct.pack("!B", self.version))
7285 packed.append(struct.pack("!B", self.type))
7286 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7287 packed.append(struct.pack("!L", self.xid))
7288 packed.append(struct.pack("!L", self.experimenter))
7289 packed.append(struct.pack("!L", self.subtype))
7290 packed.append(struct.pack("!B", self.enabled))
7291 packed.append('\x00' * 3)
7292 packed.append(util.pack_port_no(self.port_no))
7293 packed.append(struct.pack("!H", self.actor_sys_priority))
7294 packed.append(struct.pack("!6B", *self.actor_sys_mac))
7295 packed.append(struct.pack("!H", self.actor_port_priority))
7296 packed.append(struct.pack("!H", self.actor_port_num))
7297 packed.append(struct.pack("!H", self.actor_key))
7298 length = sum([len(x) for x in packed])
7299 packed[2] = struct.pack("!H", length)
7300 return ''.join(packed)
7301
7302 @staticmethod
7303 def unpack(reader):
7304 obj = bsn_set_lacp_request()
7305 _version = reader.read("!B")[0]
7306 assert(_version == 5)
7307 _type = reader.read("!B")[0]
7308 assert(_type == 4)
7309 _length = reader.read("!H")[0]
7310 orig_reader = reader
7311 reader = orig_reader.slice(_length, 4)
7312 obj.xid = reader.read("!L")[0]
7313 _experimenter = reader.read("!L")[0]
7314 assert(_experimenter == 6035143)
7315 _subtype = reader.read("!L")[0]
7316 assert(_subtype == 41)
7317 obj.enabled = reader.read("!B")[0]
7318 reader.skip(3)
7319 obj.port_no = util.unpack_port_no(reader)
7320 obj.actor_sys_priority = reader.read("!H")[0]
7321 obj.actor_sys_mac = list(reader.read('!6B'))
7322 obj.actor_port_priority = reader.read("!H")[0]
7323 obj.actor_port_num = reader.read("!H")[0]
7324 obj.actor_key = reader.read("!H")[0]
7325 return obj
7326
7327 def __eq__(self, other):
7328 if type(self) != type(other): return False
7329 if self.xid != other.xid: return False
7330 if self.enabled != other.enabled: return False
7331 if self.port_no != other.port_no: return False
7332 if self.actor_sys_priority != other.actor_sys_priority: return False
7333 if self.actor_sys_mac != other.actor_sys_mac: return False
7334 if self.actor_port_priority != other.actor_port_priority: return False
7335 if self.actor_port_num != other.actor_port_num: return False
7336 if self.actor_key != other.actor_key: return False
7337 return True
7338
7339 def pretty_print(self, q):
7340 q.text("bsn_set_lacp_request {")
7341 with q.group():
7342 with q.indent(2):
7343 q.breakable()
7344 q.text("xid = ");
7345 if self.xid != None:
7346 q.text("%#x" % self.xid)
7347 else:
7348 q.text('None')
7349 q.text(","); q.breakable()
7350 q.text("enabled = ");
7351 q.text("%#x" % self.enabled)
7352 q.text(","); q.breakable()
7353 q.text("port_no = ");
7354 q.text(util.pretty_port(self.port_no))
7355 q.text(","); q.breakable()
7356 q.text("actor_sys_priority = ");
7357 q.text("%#x" % self.actor_sys_priority)
7358 q.text(","); q.breakable()
7359 q.text("actor_sys_mac = ");
7360 q.text(util.pretty_mac(self.actor_sys_mac))
7361 q.text(","); q.breakable()
7362 q.text("actor_port_priority = ");
7363 q.text("%#x" % self.actor_port_priority)
7364 q.text(","); q.breakable()
7365 q.text("actor_port_num = ");
7366 q.text("%#x" % self.actor_port_num)
7367 q.text(","); q.breakable()
7368 q.text("actor_key = ");
7369 q.text("%#x" % self.actor_key)
7370 q.breakable()
7371 q.text('}')
7372
7373bsn_header.subtypes[41] = bsn_set_lacp_request
7374
7375class bsn_set_mirroring(bsn_header):
7376 version = 5
7377 type = 4
7378 experimenter = 6035143
7379 subtype = 3
7380
7381 def __init__(self, xid=None, report_mirror_ports=None):
7382 if xid != None:
7383 self.xid = xid
7384 else:
7385 self.xid = None
7386 if report_mirror_ports != None:
7387 self.report_mirror_ports = report_mirror_ports
7388 else:
7389 self.report_mirror_ports = 0
7390 return
7391
7392 def pack(self):
7393 packed = []
7394 packed.append(struct.pack("!B", self.version))
7395 packed.append(struct.pack("!B", self.type))
7396 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7397 packed.append(struct.pack("!L", self.xid))
7398 packed.append(struct.pack("!L", self.experimenter))
7399 packed.append(struct.pack("!L", self.subtype))
7400 packed.append(struct.pack("!B", self.report_mirror_ports))
7401 packed.append('\x00' * 3)
7402 length = sum([len(x) for x in packed])
7403 packed[2] = struct.pack("!H", length)
7404 return ''.join(packed)
7405
7406 @staticmethod
7407 def unpack(reader):
7408 obj = bsn_set_mirroring()
7409 _version = reader.read("!B")[0]
7410 assert(_version == 5)
7411 _type = reader.read("!B")[0]
7412 assert(_type == 4)
7413 _length = reader.read("!H")[0]
7414 orig_reader = reader
7415 reader = orig_reader.slice(_length, 4)
7416 obj.xid = reader.read("!L")[0]
7417 _experimenter = reader.read("!L")[0]
7418 assert(_experimenter == 6035143)
7419 _subtype = reader.read("!L")[0]
7420 assert(_subtype == 3)
7421 obj.report_mirror_ports = reader.read("!B")[0]
7422 reader.skip(3)
7423 return obj
7424
7425 def __eq__(self, other):
7426 if type(self) != type(other): return False
7427 if self.xid != other.xid: return False
7428 if self.report_mirror_ports != other.report_mirror_ports: return False
7429 return True
7430
7431 def pretty_print(self, q):
7432 q.text("bsn_set_mirroring {")
7433 with q.group():
7434 with q.indent(2):
7435 q.breakable()
7436 q.text("xid = ");
7437 if self.xid != None:
7438 q.text("%#x" % self.xid)
7439 else:
7440 q.text('None')
7441 q.text(","); q.breakable()
7442 q.text("report_mirror_ports = ");
7443 q.text("%#x" % self.report_mirror_ports)
7444 q.breakable()
7445 q.text('}')
7446
7447bsn_header.subtypes[3] = bsn_set_mirroring
7448
7449class bsn_set_pktin_suppression_reply(bsn_header):
7450 version = 5
7451 type = 4
7452 experimenter = 6035143
7453 subtype = 25
7454
7455 def __init__(self, xid=None, status=None):
7456 if xid != None:
7457 self.xid = xid
7458 else:
7459 self.xid = None
7460 if status != None:
7461 self.status = status
7462 else:
7463 self.status = 0
7464 return
7465
7466 def pack(self):
7467 packed = []
7468 packed.append(struct.pack("!B", self.version))
7469 packed.append(struct.pack("!B", self.type))
7470 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7471 packed.append(struct.pack("!L", self.xid))
7472 packed.append(struct.pack("!L", self.experimenter))
7473 packed.append(struct.pack("!L", self.subtype))
7474 packed.append(struct.pack("!L", self.status))
7475 length = sum([len(x) for x in packed])
7476 packed[2] = struct.pack("!H", length)
7477 return ''.join(packed)
7478
7479 @staticmethod
7480 def unpack(reader):
7481 obj = bsn_set_pktin_suppression_reply()
7482 _version = reader.read("!B")[0]
7483 assert(_version == 5)
7484 _type = reader.read("!B")[0]
7485 assert(_type == 4)
7486 _length = reader.read("!H")[0]
7487 orig_reader = reader
7488 reader = orig_reader.slice(_length, 4)
7489 obj.xid = reader.read("!L")[0]
7490 _experimenter = reader.read("!L")[0]
7491 assert(_experimenter == 6035143)
7492 _subtype = reader.read("!L")[0]
7493 assert(_subtype == 25)
7494 obj.status = reader.read("!L")[0]
7495 return obj
7496
7497 def __eq__(self, other):
7498 if type(self) != type(other): return False
7499 if self.xid != other.xid: return False
7500 if self.status != other.status: return False
7501 return True
7502
7503 def pretty_print(self, q):
7504 q.text("bsn_set_pktin_suppression_reply {")
7505 with q.group():
7506 with q.indent(2):
7507 q.breakable()
7508 q.text("xid = ");
7509 if self.xid != None:
7510 q.text("%#x" % self.xid)
7511 else:
7512 q.text('None')
7513 q.text(","); q.breakable()
7514 q.text("status = ");
7515 q.text("%#x" % self.status)
7516 q.breakable()
7517 q.text('}')
7518
7519bsn_header.subtypes[25] = bsn_set_pktin_suppression_reply
7520
7521class bsn_set_pktin_suppression_request(bsn_header):
7522 version = 5
7523 type = 4
7524 experimenter = 6035143
7525 subtype = 11
7526
7527 def __init__(self, xid=None, enabled=None, idle_timeout=None, hard_timeout=None, priority=None, cookie=None):
7528 if xid != None:
7529 self.xid = xid
7530 else:
7531 self.xid = None
7532 if enabled != None:
7533 self.enabled = enabled
7534 else:
7535 self.enabled = 0
7536 if idle_timeout != None:
7537 self.idle_timeout = idle_timeout
7538 else:
7539 self.idle_timeout = 0
7540 if hard_timeout != None:
7541 self.hard_timeout = hard_timeout
7542 else:
7543 self.hard_timeout = 0
7544 if priority != None:
7545 self.priority = priority
7546 else:
7547 self.priority = 0
7548 if cookie != None:
7549 self.cookie = cookie
7550 else:
7551 self.cookie = 0
7552 return
7553
7554 def pack(self):
7555 packed = []
7556 packed.append(struct.pack("!B", self.version))
7557 packed.append(struct.pack("!B", self.type))
7558 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7559 packed.append(struct.pack("!L", self.xid))
7560 packed.append(struct.pack("!L", self.experimenter))
7561 packed.append(struct.pack("!L", self.subtype))
7562 packed.append(struct.pack("!B", self.enabled))
7563 packed.append('\x00' * 1)
7564 packed.append(struct.pack("!H", self.idle_timeout))
7565 packed.append(struct.pack("!H", self.hard_timeout))
7566 packed.append(struct.pack("!H", self.priority))
7567 packed.append(struct.pack("!Q", self.cookie))
7568 length = sum([len(x) for x in packed])
7569 packed[2] = struct.pack("!H", length)
7570 return ''.join(packed)
7571
7572 @staticmethod
7573 def unpack(reader):
7574 obj = bsn_set_pktin_suppression_request()
7575 _version = reader.read("!B")[0]
7576 assert(_version == 5)
7577 _type = reader.read("!B")[0]
7578 assert(_type == 4)
7579 _length = reader.read("!H")[0]
7580 orig_reader = reader
7581 reader = orig_reader.slice(_length, 4)
7582 obj.xid = reader.read("!L")[0]
7583 _experimenter = reader.read("!L")[0]
7584 assert(_experimenter == 6035143)
7585 _subtype = reader.read("!L")[0]
7586 assert(_subtype == 11)
7587 obj.enabled = reader.read("!B")[0]
7588 reader.skip(1)
7589 obj.idle_timeout = reader.read("!H")[0]
7590 obj.hard_timeout = reader.read("!H")[0]
7591 obj.priority = reader.read("!H")[0]
7592 obj.cookie = reader.read("!Q")[0]
7593 return obj
7594
7595 def __eq__(self, other):
7596 if type(self) != type(other): return False
7597 if self.xid != other.xid: return False
7598 if self.enabled != other.enabled: return False
7599 if self.idle_timeout != other.idle_timeout: return False
7600 if self.hard_timeout != other.hard_timeout: return False
7601 if self.priority != other.priority: return False
7602 if self.cookie != other.cookie: return False
7603 return True
7604
7605 def pretty_print(self, q):
7606 q.text("bsn_set_pktin_suppression_request {")
7607 with q.group():
7608 with q.indent(2):
7609 q.breakable()
7610 q.text("xid = ");
7611 if self.xid != None:
7612 q.text("%#x" % self.xid)
7613 else:
7614 q.text('None')
7615 q.text(","); q.breakable()
7616 q.text("enabled = ");
7617 q.text("%#x" % self.enabled)
7618 q.text(","); q.breakable()
7619 q.text("idle_timeout = ");
7620 q.text("%#x" % self.idle_timeout)
7621 q.text(","); q.breakable()
7622 q.text("hard_timeout = ");
7623 q.text("%#x" % self.hard_timeout)
7624 q.text(","); q.breakable()
7625 q.text("priority = ");
7626 q.text("%#x" % self.priority)
7627 q.text(","); q.breakable()
7628 q.text("cookie = ");
7629 q.text("%#x" % self.cookie)
7630 q.breakable()
7631 q.text('}')
7632
7633bsn_header.subtypes[11] = bsn_set_pktin_suppression_request
7634
7635class bsn_set_switch_pipeline_reply(bsn_header):
7636 version = 5
7637 type = 4
7638 experimenter = 6035143
7639 subtype = 54
7640
7641 def __init__(self, xid=None, status=None):
7642 if xid != None:
7643 self.xid = xid
7644 else:
7645 self.xid = None
7646 if status != None:
7647 self.status = status
7648 else:
7649 self.status = 0
7650 return
7651
7652 def pack(self):
7653 packed = []
7654 packed.append(struct.pack("!B", self.version))
7655 packed.append(struct.pack("!B", self.type))
7656 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7657 packed.append(struct.pack("!L", self.xid))
7658 packed.append(struct.pack("!L", self.experimenter))
7659 packed.append(struct.pack("!L", self.subtype))
7660 packed.append(struct.pack("!L", self.status))
7661 length = sum([len(x) for x in packed])
7662 packed[2] = struct.pack("!H", length)
7663 return ''.join(packed)
7664
7665 @staticmethod
7666 def unpack(reader):
7667 obj = bsn_set_switch_pipeline_reply()
7668 _version = reader.read("!B")[0]
7669 assert(_version == 5)
7670 _type = reader.read("!B")[0]
7671 assert(_type == 4)
7672 _length = reader.read("!H")[0]
7673 orig_reader = reader
7674 reader = orig_reader.slice(_length, 4)
7675 obj.xid = reader.read("!L")[0]
7676 _experimenter = reader.read("!L")[0]
7677 assert(_experimenter == 6035143)
7678 _subtype = reader.read("!L")[0]
7679 assert(_subtype == 54)
7680 obj.status = reader.read("!L")[0]
7681 return obj
7682
7683 def __eq__(self, other):
7684 if type(self) != type(other): return False
7685 if self.xid != other.xid: return False
7686 if self.status != other.status: return False
7687 return True
7688
7689 def pretty_print(self, q):
7690 q.text("bsn_set_switch_pipeline_reply {")
7691 with q.group():
7692 with q.indent(2):
7693 q.breakable()
7694 q.text("xid = ");
7695 if self.xid != None:
7696 q.text("%#x" % self.xid)
7697 else:
7698 q.text('None')
7699 q.text(","); q.breakable()
7700 q.text("status = ");
7701 q.text("%#x" % self.status)
7702 q.breakable()
7703 q.text('}')
7704
7705bsn_header.subtypes[54] = bsn_set_switch_pipeline_reply
7706
7707class bsn_set_switch_pipeline_request(bsn_header):
7708 version = 5
7709 type = 4
7710 experimenter = 6035143
7711 subtype = 53
7712
7713 def __init__(self, xid=None, pipeline=None):
7714 if xid != None:
7715 self.xid = xid
7716 else:
7717 self.xid = None
7718 if pipeline != None:
7719 self.pipeline = pipeline
7720 else:
7721 self.pipeline = ""
7722 return
7723
7724 def pack(self):
7725 packed = []
7726 packed.append(struct.pack("!B", self.version))
7727 packed.append(struct.pack("!B", self.type))
7728 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7729 packed.append(struct.pack("!L", self.xid))
7730 packed.append(struct.pack("!L", self.experimenter))
7731 packed.append(struct.pack("!L", self.subtype))
7732 packed.append(struct.pack("!256s", self.pipeline))
7733 length = sum([len(x) for x in packed])
7734 packed[2] = struct.pack("!H", length)
7735 return ''.join(packed)
7736
7737 @staticmethod
7738 def unpack(reader):
7739 obj = bsn_set_switch_pipeline_request()
7740 _version = reader.read("!B")[0]
7741 assert(_version == 5)
7742 _type = reader.read("!B")[0]
7743 assert(_type == 4)
7744 _length = reader.read("!H")[0]
7745 orig_reader = reader
7746 reader = orig_reader.slice(_length, 4)
7747 obj.xid = reader.read("!L")[0]
7748 _experimenter = reader.read("!L")[0]
7749 assert(_experimenter == 6035143)
7750 _subtype = reader.read("!L")[0]
7751 assert(_subtype == 53)
7752 obj.pipeline = reader.read("!256s")[0].rstrip("\x00")
7753 return obj
7754
7755 def __eq__(self, other):
7756 if type(self) != type(other): return False
7757 if self.xid != other.xid: return False
7758 if self.pipeline != other.pipeline: return False
7759 return True
7760
7761 def pretty_print(self, q):
7762 q.text("bsn_set_switch_pipeline_request {")
7763 with q.group():
7764 with q.indent(2):
7765 q.breakable()
7766 q.text("xid = ");
7767 if self.xid != None:
7768 q.text("%#x" % self.xid)
7769 else:
7770 q.text('None')
7771 q.text(","); q.breakable()
7772 q.text("pipeline = ");
7773 q.pp(self.pipeline)
7774 q.breakable()
7775 q.text('}')
7776
7777bsn_header.subtypes[53] = bsn_set_switch_pipeline_request
7778
7779class bsn_switch_pipeline_stats_reply(bsn_stats_reply):
7780 version = 5
7781 type = 19
7782 stats_type = 65535
7783 experimenter = 6035143
7784 subtype = 6
7785
7786 def __init__(self, xid=None, flags=None, entries=None):
7787 if xid != None:
7788 self.xid = xid
7789 else:
7790 self.xid = None
7791 if flags != None:
7792 self.flags = flags
7793 else:
7794 self.flags = 0
7795 if entries != None:
7796 self.entries = entries
7797 else:
7798 self.entries = []
7799 return
7800
7801 def pack(self):
7802 packed = []
7803 packed.append(struct.pack("!B", self.version))
7804 packed.append(struct.pack("!B", self.type))
7805 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7806 packed.append(struct.pack("!L", self.xid))
7807 packed.append(struct.pack("!H", self.stats_type))
7808 packed.append(struct.pack("!H", self.flags))
7809 packed.append('\x00' * 4)
7810 packed.append(struct.pack("!L", self.experimenter))
7811 packed.append(struct.pack("!L", self.subtype))
7812 packed.append(loxi.generic_util.pack_list(self.entries))
7813 length = sum([len(x) for x in packed])
7814 packed[2] = struct.pack("!H", length)
7815 return ''.join(packed)
7816
7817 @staticmethod
7818 def unpack(reader):
7819 obj = bsn_switch_pipeline_stats_reply()
7820 _version = reader.read("!B")[0]
7821 assert(_version == 5)
7822 _type = reader.read("!B")[0]
7823 assert(_type == 19)
7824 _length = reader.read("!H")[0]
7825 orig_reader = reader
7826 reader = orig_reader.slice(_length, 4)
7827 obj.xid = reader.read("!L")[0]
7828 _stats_type = reader.read("!H")[0]
7829 assert(_stats_type == 65535)
7830 obj.flags = reader.read("!H")[0]
7831 reader.skip(4)
7832 _experimenter = reader.read("!L")[0]
7833 assert(_experimenter == 6035143)
7834 _subtype = reader.read("!L")[0]
7835 assert(_subtype == 6)
7836 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_switch_pipeline_stats_entry.unpack)
7837 return obj
7838
7839 def __eq__(self, other):
7840 if type(self) != type(other): return False
7841 if self.xid != other.xid: return False
7842 if self.flags != other.flags: return False
7843 if self.entries != other.entries: return False
7844 return True
7845
7846 def pretty_print(self, q):
7847 q.text("bsn_switch_pipeline_stats_reply {")
7848 with q.group():
7849 with q.indent(2):
7850 q.breakable()
7851 q.text("xid = ");
7852 if self.xid != None:
7853 q.text("%#x" % self.xid)
7854 else:
7855 q.text('None')
7856 q.text(","); q.breakable()
7857 q.text("flags = ");
7858 q.text("%#x" % self.flags)
7859 q.text(","); q.breakable()
7860 q.text("entries = ");
7861 q.pp(self.entries)
7862 q.breakable()
7863 q.text('}')
7864
7865bsn_stats_reply.subtypes[6] = bsn_switch_pipeline_stats_reply
7866
7867class bsn_switch_pipeline_stats_request(bsn_stats_request):
7868 version = 5
7869 type = 18
7870 stats_type = 65535
7871 experimenter = 6035143
7872 subtype = 6
7873
7874 def __init__(self, xid=None, flags=None):
7875 if xid != None:
7876 self.xid = xid
7877 else:
7878 self.xid = None
7879 if flags != None:
7880 self.flags = flags
7881 else:
7882 self.flags = 0
7883 return
7884
7885 def pack(self):
7886 packed = []
7887 packed.append(struct.pack("!B", self.version))
7888 packed.append(struct.pack("!B", self.type))
7889 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7890 packed.append(struct.pack("!L", self.xid))
7891 packed.append(struct.pack("!H", self.stats_type))
7892 packed.append(struct.pack("!H", self.flags))
7893 packed.append('\x00' * 4)
7894 packed.append(struct.pack("!L", self.experimenter))
7895 packed.append(struct.pack("!L", self.subtype))
7896 length = sum([len(x) for x in packed])
7897 packed[2] = struct.pack("!H", length)
7898 return ''.join(packed)
7899
7900 @staticmethod
7901 def unpack(reader):
7902 obj = bsn_switch_pipeline_stats_request()
7903 _version = reader.read("!B")[0]
7904 assert(_version == 5)
7905 _type = reader.read("!B")[0]
7906 assert(_type == 18)
7907 _length = reader.read("!H")[0]
7908 orig_reader = reader
7909 reader = orig_reader.slice(_length, 4)
7910 obj.xid = reader.read("!L")[0]
7911 _stats_type = reader.read("!H")[0]
7912 assert(_stats_type == 65535)
7913 obj.flags = reader.read("!H")[0]
7914 reader.skip(4)
7915 _experimenter = reader.read("!L")[0]
7916 assert(_experimenter == 6035143)
7917 _subtype = reader.read("!L")[0]
7918 assert(_subtype == 6)
7919 return obj
7920
7921 def __eq__(self, other):
7922 if type(self) != type(other): return False
7923 if self.xid != other.xid: return False
7924 if self.flags != other.flags: return False
7925 return True
7926
7927 def pretty_print(self, q):
7928 q.text("bsn_switch_pipeline_stats_request {")
7929 with q.group():
7930 with q.indent(2):
7931 q.breakable()
7932 q.text("xid = ");
7933 if self.xid != None:
7934 q.text("%#x" % self.xid)
7935 else:
7936 q.text('None')
7937 q.text(","); q.breakable()
7938 q.text("flags = ");
7939 q.text("%#x" % self.flags)
7940 q.breakable()
7941 q.text('}')
7942
7943bsn_stats_request.subtypes[6] = bsn_switch_pipeline_stats_request
7944
7945class bsn_table_checksum_stats_reply(bsn_stats_reply):
7946 version = 5
7947 type = 19
7948 stats_type = 65535
7949 experimenter = 6035143
7950 subtype = 11
7951
7952 def __init__(self, xid=None, flags=None, entries=None):
7953 if xid != None:
7954 self.xid = xid
7955 else:
7956 self.xid = None
7957 if flags != None:
7958 self.flags = flags
7959 else:
7960 self.flags = 0
7961 if entries != None:
7962 self.entries = entries
7963 else:
7964 self.entries = []
7965 return
7966
7967 def pack(self):
7968 packed = []
7969 packed.append(struct.pack("!B", self.version))
7970 packed.append(struct.pack("!B", self.type))
7971 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7972 packed.append(struct.pack("!L", self.xid))
7973 packed.append(struct.pack("!H", self.stats_type))
7974 packed.append(struct.pack("!H", self.flags))
7975 packed.append('\x00' * 4)
7976 packed.append(struct.pack("!L", self.experimenter))
7977 packed.append(struct.pack("!L", self.subtype))
7978 packed.append(loxi.generic_util.pack_list(self.entries))
7979 length = sum([len(x) for x in packed])
7980 packed[2] = struct.pack("!H", length)
7981 return ''.join(packed)
7982
7983 @staticmethod
7984 def unpack(reader):
7985 obj = bsn_table_checksum_stats_reply()
7986 _version = reader.read("!B")[0]
7987 assert(_version == 5)
7988 _type = reader.read("!B")[0]
7989 assert(_type == 19)
7990 _length = reader.read("!H")[0]
7991 orig_reader = reader
7992 reader = orig_reader.slice(_length, 4)
7993 obj.xid = reader.read("!L")[0]
7994 _stats_type = reader.read("!H")[0]
7995 assert(_stats_type == 65535)
7996 obj.flags = reader.read("!H")[0]
7997 reader.skip(4)
7998 _experimenter = reader.read("!L")[0]
7999 assert(_experimenter == 6035143)
8000 _subtype = reader.read("!L")[0]
8001 assert(_subtype == 11)
8002 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_table_checksum_stats_entry.unpack)
8003 return obj
8004
8005 def __eq__(self, other):
8006 if type(self) != type(other): return False
8007 if self.xid != other.xid: return False
8008 if self.flags != other.flags: return False
8009 if self.entries != other.entries: return False
8010 return True
8011
8012 def pretty_print(self, q):
8013 q.text("bsn_table_checksum_stats_reply {")
8014 with q.group():
8015 with q.indent(2):
8016 q.breakable()
8017 q.text("xid = ");
8018 if self.xid != None:
8019 q.text("%#x" % self.xid)
8020 else:
8021 q.text('None')
8022 q.text(","); q.breakable()
8023 q.text("flags = ");
8024 q.text("%#x" % self.flags)
8025 q.text(","); q.breakable()
8026 q.text("entries = ");
8027 q.pp(self.entries)
8028 q.breakable()
8029 q.text('}')
8030
8031bsn_stats_reply.subtypes[11] = bsn_table_checksum_stats_reply
8032
8033class bsn_table_checksum_stats_request(bsn_stats_request):
8034 version = 5
8035 type = 18
8036 stats_type = 65535
8037 experimenter = 6035143
8038 subtype = 11
8039
8040 def __init__(self, xid=None, flags=None):
8041 if xid != None:
8042 self.xid = xid
8043 else:
8044 self.xid = None
8045 if flags != None:
8046 self.flags = flags
8047 else:
8048 self.flags = 0
8049 return
8050
8051 def pack(self):
8052 packed = []
8053 packed.append(struct.pack("!B", self.version))
8054 packed.append(struct.pack("!B", self.type))
8055 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8056 packed.append(struct.pack("!L", self.xid))
8057 packed.append(struct.pack("!H", self.stats_type))
8058 packed.append(struct.pack("!H", self.flags))
8059 packed.append('\x00' * 4)
8060 packed.append(struct.pack("!L", self.experimenter))
8061 packed.append(struct.pack("!L", self.subtype))
8062 length = sum([len(x) for x in packed])
8063 packed[2] = struct.pack("!H", length)
8064 return ''.join(packed)
8065
8066 @staticmethod
8067 def unpack(reader):
8068 obj = bsn_table_checksum_stats_request()
8069 _version = reader.read("!B")[0]
8070 assert(_version == 5)
8071 _type = reader.read("!B")[0]
8072 assert(_type == 18)
8073 _length = reader.read("!H")[0]
8074 orig_reader = reader
8075 reader = orig_reader.slice(_length, 4)
8076 obj.xid = reader.read("!L")[0]
8077 _stats_type = reader.read("!H")[0]
8078 assert(_stats_type == 65535)
8079 obj.flags = reader.read("!H")[0]
8080 reader.skip(4)
8081 _experimenter = reader.read("!L")[0]
8082 assert(_experimenter == 6035143)
8083 _subtype = reader.read("!L")[0]
8084 assert(_subtype == 11)
8085 return obj
8086
8087 def __eq__(self, other):
8088 if type(self) != type(other): return False
8089 if self.xid != other.xid: return False
8090 if self.flags != other.flags: return False
8091 return True
8092
8093 def pretty_print(self, q):
8094 q.text("bsn_table_checksum_stats_request {")
8095 with q.group():
8096 with q.indent(2):
8097 q.breakable()
8098 q.text("xid = ");
8099 if self.xid != None:
8100 q.text("%#x" % self.xid)
8101 else:
8102 q.text('None')
8103 q.text(","); q.breakable()
8104 q.text("flags = ");
8105 q.text("%#x" % self.flags)
8106 q.breakable()
8107 q.text('}')
8108
8109bsn_stats_request.subtypes[11] = bsn_table_checksum_stats_request
8110
8111class bsn_table_set_buckets_size(bsn_header):
8112 version = 5
8113 type = 4
8114 experimenter = 6035143
8115 subtype = 61
8116
8117 def __init__(self, xid=None, table_id=None, buckets_size=None):
8118 if xid != None:
8119 self.xid = xid
8120 else:
8121 self.xid = None
8122 if table_id != None:
8123 self.table_id = table_id
8124 else:
8125 self.table_id = 0
8126 if buckets_size != None:
8127 self.buckets_size = buckets_size
8128 else:
8129 self.buckets_size = 0
8130 return
8131
8132 def pack(self):
8133 packed = []
8134 packed.append(struct.pack("!B", self.version))
8135 packed.append(struct.pack("!B", self.type))
8136 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8137 packed.append(struct.pack("!L", self.xid))
8138 packed.append(struct.pack("!L", self.experimenter))
8139 packed.append(struct.pack("!L", self.subtype))
8140 packed.append('\x00' * 1)
8141 packed.append(struct.pack("!B", self.table_id))
8142 packed.append('\x00' * 2)
8143 packed.append(struct.pack("!L", self.buckets_size))
8144 length = sum([len(x) for x in packed])
8145 packed[2] = struct.pack("!H", length)
8146 return ''.join(packed)
8147
8148 @staticmethod
8149 def unpack(reader):
8150 obj = bsn_table_set_buckets_size()
8151 _version = reader.read("!B")[0]
8152 assert(_version == 5)
8153 _type = reader.read("!B")[0]
8154 assert(_type == 4)
8155 _length = reader.read("!H")[0]
8156 orig_reader = reader
8157 reader = orig_reader.slice(_length, 4)
8158 obj.xid = reader.read("!L")[0]
8159 _experimenter = reader.read("!L")[0]
8160 assert(_experimenter == 6035143)
8161 _subtype = reader.read("!L")[0]
8162 assert(_subtype == 61)
8163 reader.skip(1)
8164 obj.table_id = reader.read("!B")[0]
8165 reader.skip(2)
8166 obj.buckets_size = reader.read("!L")[0]
8167 return obj
8168
8169 def __eq__(self, other):
8170 if type(self) != type(other): return False
8171 if self.xid != other.xid: return False
8172 if self.table_id != other.table_id: return False
8173 if self.buckets_size != other.buckets_size: return False
8174 return True
8175
8176 def pretty_print(self, q):
8177 q.text("bsn_table_set_buckets_size {")
8178 with q.group():
8179 with q.indent(2):
8180 q.breakable()
8181 q.text("xid = ");
8182 if self.xid != None:
8183 q.text("%#x" % self.xid)
8184 else:
8185 q.text('None')
8186 q.text(","); q.breakable()
8187 q.text("table_id = ");
8188 q.text("%#x" % self.table_id)
8189 q.text(","); q.breakable()
8190 q.text("buckets_size = ");
8191 q.text("%#x" % self.buckets_size)
8192 q.breakable()
8193 q.text('}')
8194
8195bsn_header.subtypes[61] = bsn_table_set_buckets_size
8196
8197class bsn_takeover(bsn_header):
8198 version = 5
8199 type = 4
8200 experimenter = 6035143
8201 subtype = 69
8202
8203 def __init__(self, xid=None):
8204 if xid != None:
8205 self.xid = xid
8206 else:
8207 self.xid = None
8208 return
8209
8210 def pack(self):
8211 packed = []
8212 packed.append(struct.pack("!B", self.version))
8213 packed.append(struct.pack("!B", self.type))
8214 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8215 packed.append(struct.pack("!L", self.xid))
8216 packed.append(struct.pack("!L", self.experimenter))
8217 packed.append(struct.pack("!L", self.subtype))
8218 length = sum([len(x) for x in packed])
8219 packed[2] = struct.pack("!H", length)
8220 return ''.join(packed)
8221
8222 @staticmethod
8223 def unpack(reader):
8224 obj = bsn_takeover()
8225 _version = reader.read("!B")[0]
8226 assert(_version == 5)
8227 _type = reader.read("!B")[0]
8228 assert(_type == 4)
8229 _length = reader.read("!H")[0]
8230 orig_reader = reader
8231 reader = orig_reader.slice(_length, 4)
8232 obj.xid = reader.read("!L")[0]
8233 _experimenter = reader.read("!L")[0]
8234 assert(_experimenter == 6035143)
8235 _subtype = reader.read("!L")[0]
8236 assert(_subtype == 69)
8237 return obj
8238
8239 def __eq__(self, other):
8240 if type(self) != type(other): return False
8241 if self.xid != other.xid: return False
8242 return True
8243
8244 def pretty_print(self, q):
8245 q.text("bsn_takeover {")
8246 with q.group():
8247 with q.indent(2):
8248 q.breakable()
8249 q.text("xid = ");
8250 if self.xid != None:
8251 q.text("%#x" % self.xid)
8252 else:
8253 q.text('None')
8254 q.breakable()
8255 q.text('}')
8256
8257bsn_header.subtypes[69] = bsn_takeover
8258
8259class bsn_time_reply(bsn_header):
8260 version = 5
8261 type = 4
8262 experimenter = 6035143
8263 subtype = 45
8264
8265 def __init__(self, xid=None, time_ms=None):
8266 if xid != None:
8267 self.xid = xid
8268 else:
8269 self.xid = None
8270 if time_ms != None:
8271 self.time_ms = time_ms
8272 else:
8273 self.time_ms = 0
8274 return
8275
8276 def pack(self):
8277 packed = []
8278 packed.append(struct.pack("!B", self.version))
8279 packed.append(struct.pack("!B", self.type))
8280 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8281 packed.append(struct.pack("!L", self.xid))
8282 packed.append(struct.pack("!L", self.experimenter))
8283 packed.append(struct.pack("!L", self.subtype))
8284 packed.append(struct.pack("!Q", self.time_ms))
8285 length = sum([len(x) for x in packed])
8286 packed[2] = struct.pack("!H", length)
8287 return ''.join(packed)
8288
8289 @staticmethod
8290 def unpack(reader):
8291 obj = bsn_time_reply()
8292 _version = reader.read("!B")[0]
8293 assert(_version == 5)
8294 _type = reader.read("!B")[0]
8295 assert(_type == 4)
8296 _length = reader.read("!H")[0]
8297 orig_reader = reader
8298 reader = orig_reader.slice(_length, 4)
8299 obj.xid = reader.read("!L")[0]
8300 _experimenter = reader.read("!L")[0]
8301 assert(_experimenter == 6035143)
8302 _subtype = reader.read("!L")[0]
8303 assert(_subtype == 45)
8304 obj.time_ms = reader.read("!Q")[0]
8305 return obj
8306
8307 def __eq__(self, other):
8308 if type(self) != type(other): return False
8309 if self.xid != other.xid: return False
8310 if self.time_ms != other.time_ms: return False
8311 return True
8312
8313 def pretty_print(self, q):
8314 q.text("bsn_time_reply {")
8315 with q.group():
8316 with q.indent(2):
8317 q.breakable()
8318 q.text("xid = ");
8319 if self.xid != None:
8320 q.text("%#x" % self.xid)
8321 else:
8322 q.text('None')
8323 q.text(","); q.breakable()
8324 q.text("time_ms = ");
8325 q.text("%#x" % self.time_ms)
8326 q.breakable()
8327 q.text('}')
8328
8329bsn_header.subtypes[45] = bsn_time_reply
8330
8331class bsn_time_request(bsn_header):
8332 version = 5
8333 type = 4
8334 experimenter = 6035143
8335 subtype = 44
8336
8337 def __init__(self, xid=None):
8338 if xid != None:
8339 self.xid = xid
8340 else:
8341 self.xid = None
8342 return
8343
8344 def pack(self):
8345 packed = []
8346 packed.append(struct.pack("!B", self.version))
8347 packed.append(struct.pack("!B", self.type))
8348 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8349 packed.append(struct.pack("!L", self.xid))
8350 packed.append(struct.pack("!L", self.experimenter))
8351 packed.append(struct.pack("!L", self.subtype))
8352 length = sum([len(x) for x in packed])
8353 packed[2] = struct.pack("!H", length)
8354 return ''.join(packed)
8355
8356 @staticmethod
8357 def unpack(reader):
8358 obj = bsn_time_request()
8359 _version = reader.read("!B")[0]
8360 assert(_version == 5)
8361 _type = reader.read("!B")[0]
8362 assert(_type == 4)
8363 _length = reader.read("!H")[0]
8364 orig_reader = reader
8365 reader = orig_reader.slice(_length, 4)
8366 obj.xid = reader.read("!L")[0]
8367 _experimenter = reader.read("!L")[0]
8368 assert(_experimenter == 6035143)
8369 _subtype = reader.read("!L")[0]
8370 assert(_subtype == 44)
8371 return obj
8372
8373 def __eq__(self, other):
8374 if type(self) != type(other): return False
8375 if self.xid != other.xid: return False
8376 return True
8377
8378 def pretty_print(self, q):
8379 q.text("bsn_time_request {")
8380 with q.group():
8381 with q.indent(2):
8382 q.breakable()
8383 q.text("xid = ");
8384 if self.xid != None:
8385 q.text("%#x" % self.xid)
8386 else:
8387 q.text('None')
8388 q.breakable()
8389 q.text('}')
8390
8391bsn_header.subtypes[44] = bsn_time_request
8392
8393class bsn_virtual_port_create_reply(bsn_header):
8394 version = 5
8395 type = 4
8396 experimenter = 6035143
8397 subtype = 16
8398
8399 def __init__(self, xid=None, status=None, vport_no=None):
8400 if xid != None:
8401 self.xid = xid
8402 else:
8403 self.xid = None
8404 if status != None:
8405 self.status = status
8406 else:
8407 self.status = 0
8408 if vport_no != None:
8409 self.vport_no = vport_no
8410 else:
8411 self.vport_no = 0
8412 return
8413
8414 def pack(self):
8415 packed = []
8416 packed.append(struct.pack("!B", self.version))
8417 packed.append(struct.pack("!B", self.type))
8418 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8419 packed.append(struct.pack("!L", self.xid))
8420 packed.append(struct.pack("!L", self.experimenter))
8421 packed.append(struct.pack("!L", self.subtype))
8422 packed.append(struct.pack("!L", self.status))
8423 packed.append(struct.pack("!L", self.vport_no))
8424 length = sum([len(x) for x in packed])
8425 packed[2] = struct.pack("!H", length)
8426 return ''.join(packed)
8427
8428 @staticmethod
8429 def unpack(reader):
8430 obj = bsn_virtual_port_create_reply()
8431 _version = reader.read("!B")[0]
8432 assert(_version == 5)
8433 _type = reader.read("!B")[0]
8434 assert(_type == 4)
8435 _length = reader.read("!H")[0]
8436 orig_reader = reader
8437 reader = orig_reader.slice(_length, 4)
8438 obj.xid = reader.read("!L")[0]
8439 _experimenter = reader.read("!L")[0]
8440 assert(_experimenter == 6035143)
8441 _subtype = reader.read("!L")[0]
8442 assert(_subtype == 16)
8443 obj.status = reader.read("!L")[0]
8444 obj.vport_no = reader.read("!L")[0]
8445 return obj
8446
8447 def __eq__(self, other):
8448 if type(self) != type(other): return False
8449 if self.xid != other.xid: return False
8450 if self.status != other.status: return False
8451 if self.vport_no != other.vport_no: return False
8452 return True
8453
8454 def pretty_print(self, q):
8455 q.text("bsn_virtual_port_create_reply {")
8456 with q.group():
8457 with q.indent(2):
8458 q.breakable()
8459 q.text("xid = ");
8460 if self.xid != None:
8461 q.text("%#x" % self.xid)
8462 else:
8463 q.text('None')
8464 q.text(","); q.breakable()
8465 q.text("status = ");
8466 q.text("%#x" % self.status)
8467 q.text(","); q.breakable()
8468 q.text("vport_no = ");
8469 q.text("%#x" % self.vport_no)
8470 q.breakable()
8471 q.text('}')
8472
8473bsn_header.subtypes[16] = bsn_virtual_port_create_reply
8474
8475class bsn_virtual_port_create_request(bsn_header):
8476 version = 5
8477 type = 4
8478 experimenter = 6035143
8479 subtype = 15
8480
8481 def __init__(self, xid=None, vport=None):
8482 if xid != None:
8483 self.xid = xid
8484 else:
8485 self.xid = None
8486 if vport != None:
8487 self.vport = vport
8488 else:
8489 self.vport = ofp.bsn_vport()
8490 return
8491
8492 def pack(self):
8493 packed = []
8494 packed.append(struct.pack("!B", self.version))
8495 packed.append(struct.pack("!B", self.type))
8496 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8497 packed.append(struct.pack("!L", self.xid))
8498 packed.append(struct.pack("!L", self.experimenter))
8499 packed.append(struct.pack("!L", self.subtype))
8500 packed.append(self.vport.pack())
8501 length = sum([len(x) for x in packed])
8502 packed[2] = struct.pack("!H", length)
8503 return ''.join(packed)
8504
8505 @staticmethod
8506 def unpack(reader):
8507 obj = bsn_virtual_port_create_request()
8508 _version = reader.read("!B")[0]
8509 assert(_version == 5)
8510 _type = reader.read("!B")[0]
8511 assert(_type == 4)
8512 _length = reader.read("!H")[0]
8513 orig_reader = reader
8514 reader = orig_reader.slice(_length, 4)
8515 obj.xid = reader.read("!L")[0]
8516 _experimenter = reader.read("!L")[0]
8517 assert(_experimenter == 6035143)
8518 _subtype = reader.read("!L")[0]
8519 assert(_subtype == 15)
8520 obj.vport = ofp.bsn_vport.unpack(reader)
8521 return obj
8522
8523 def __eq__(self, other):
8524 if type(self) != type(other): return False
8525 if self.xid != other.xid: return False
8526 if self.vport != other.vport: return False
8527 return True
8528
8529 def pretty_print(self, q):
8530 q.text("bsn_virtual_port_create_request {")
8531 with q.group():
8532 with q.indent(2):
8533 q.breakable()
8534 q.text("xid = ");
8535 if self.xid != None:
8536 q.text("%#x" % self.xid)
8537 else:
8538 q.text('None')
8539 q.text(","); q.breakable()
8540 q.text("vport = ");
8541 q.pp(self.vport)
8542 q.breakable()
8543 q.text('}')
8544
8545bsn_header.subtypes[15] = bsn_virtual_port_create_request
8546
8547class bsn_virtual_port_remove_reply(bsn_header):
8548 version = 5
8549 type = 4
8550 experimenter = 6035143
8551 subtype = 26
8552
8553 def __init__(self, xid=None, status=None):
8554 if xid != None:
8555 self.xid = xid
8556 else:
8557 self.xid = None
8558 if status != None:
8559 self.status = status
8560 else:
8561 self.status = 0
8562 return
8563
8564 def pack(self):
8565 packed = []
8566 packed.append(struct.pack("!B", self.version))
8567 packed.append(struct.pack("!B", self.type))
8568 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8569 packed.append(struct.pack("!L", self.xid))
8570 packed.append(struct.pack("!L", self.experimenter))
8571 packed.append(struct.pack("!L", self.subtype))
8572 packed.append(struct.pack("!L", self.status))
8573 length = sum([len(x) for x in packed])
8574 packed[2] = struct.pack("!H", length)
8575 return ''.join(packed)
8576
8577 @staticmethod
8578 def unpack(reader):
8579 obj = bsn_virtual_port_remove_reply()
8580 _version = reader.read("!B")[0]
8581 assert(_version == 5)
8582 _type = reader.read("!B")[0]
8583 assert(_type == 4)
8584 _length = reader.read("!H")[0]
8585 orig_reader = reader
8586 reader = orig_reader.slice(_length, 4)
8587 obj.xid = reader.read("!L")[0]
8588 _experimenter = reader.read("!L")[0]
8589 assert(_experimenter == 6035143)
8590 _subtype = reader.read("!L")[0]
8591 assert(_subtype == 26)
8592 obj.status = reader.read("!L")[0]
8593 return obj
8594
8595 def __eq__(self, other):
8596 if type(self) != type(other): return False
8597 if self.xid != other.xid: return False
8598 if self.status != other.status: return False
8599 return True
8600
8601 def pretty_print(self, q):
8602 q.text("bsn_virtual_port_remove_reply {")
8603 with q.group():
8604 with q.indent(2):
8605 q.breakable()
8606 q.text("xid = ");
8607 if self.xid != None:
8608 q.text("%#x" % self.xid)
8609 else:
8610 q.text('None')
8611 q.text(","); q.breakable()
8612 q.text("status = ");
8613 q.text("%#x" % self.status)
8614 q.breakable()
8615 q.text('}')
8616
8617bsn_header.subtypes[26] = bsn_virtual_port_remove_reply
8618
8619class bsn_virtual_port_remove_request(bsn_header):
8620 version = 5
8621 type = 4
8622 experimenter = 6035143
8623 subtype = 17
8624
8625 def __init__(self, xid=None, vport_no=None):
8626 if xid != None:
8627 self.xid = xid
8628 else:
8629 self.xid = None
8630 if vport_no != None:
8631 self.vport_no = vport_no
8632 else:
8633 self.vport_no = 0
8634 return
8635
8636 def pack(self):
8637 packed = []
8638 packed.append(struct.pack("!B", self.version))
8639 packed.append(struct.pack("!B", self.type))
8640 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8641 packed.append(struct.pack("!L", self.xid))
8642 packed.append(struct.pack("!L", self.experimenter))
8643 packed.append(struct.pack("!L", self.subtype))
8644 packed.append(struct.pack("!L", self.vport_no))
8645 length = sum([len(x) for x in packed])
8646 packed[2] = struct.pack("!H", length)
8647 return ''.join(packed)
8648
8649 @staticmethod
8650 def unpack(reader):
8651 obj = bsn_virtual_port_remove_request()
8652 _version = reader.read("!B")[0]
8653 assert(_version == 5)
8654 _type = reader.read("!B")[0]
8655 assert(_type == 4)
8656 _length = reader.read("!H")[0]
8657 orig_reader = reader
8658 reader = orig_reader.slice(_length, 4)
8659 obj.xid = reader.read("!L")[0]
8660 _experimenter = reader.read("!L")[0]
8661 assert(_experimenter == 6035143)
8662 _subtype = reader.read("!L")[0]
8663 assert(_subtype == 17)
8664 obj.vport_no = reader.read("!L")[0]
8665 return obj
8666
8667 def __eq__(self, other):
8668 if type(self) != type(other): return False
8669 if self.xid != other.xid: return False
8670 if self.vport_no != other.vport_no: return False
8671 return True
8672
8673 def pretty_print(self, q):
8674 q.text("bsn_virtual_port_remove_request {")
8675 with q.group():
8676 with q.indent(2):
8677 q.breakable()
8678 q.text("xid = ");
8679 if self.xid != None:
8680 q.text("%#x" % self.xid)
8681 else:
8682 q.text('None')
8683 q.text(","); q.breakable()
8684 q.text("vport_no = ");
8685 q.text("%#x" % self.vport_no)
8686 q.breakable()
8687 q.text('}')
8688
8689bsn_header.subtypes[17] = bsn_virtual_port_remove_request
8690
8691class bsn_vlan_counter_stats_reply(bsn_stats_reply):
8692 version = 5
8693 type = 19
8694 stats_type = 65535
8695 experimenter = 6035143
8696 subtype = 9
8697
8698 def __init__(self, xid=None, flags=None, entries=None):
8699 if xid != None:
8700 self.xid = xid
8701 else:
8702 self.xid = None
8703 if flags != None:
8704 self.flags = flags
8705 else:
8706 self.flags = 0
8707 if entries != None:
8708 self.entries = entries
8709 else:
8710 self.entries = []
8711 return
8712
8713 def pack(self):
8714 packed = []
8715 packed.append(struct.pack("!B", self.version))
8716 packed.append(struct.pack("!B", self.type))
8717 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8718 packed.append(struct.pack("!L", self.xid))
8719 packed.append(struct.pack("!H", self.stats_type))
8720 packed.append(struct.pack("!H", self.flags))
8721 packed.append('\x00' * 4)
8722 packed.append(struct.pack("!L", self.experimenter))
8723 packed.append(struct.pack("!L", self.subtype))
8724 packed.append(loxi.generic_util.pack_list(self.entries))
8725 length = sum([len(x) for x in packed])
8726 packed[2] = struct.pack("!H", length)
8727 return ''.join(packed)
8728
8729 @staticmethod
8730 def unpack(reader):
8731 obj = bsn_vlan_counter_stats_reply()
8732 _version = reader.read("!B")[0]
8733 assert(_version == 5)
8734 _type = reader.read("!B")[0]
8735 assert(_type == 19)
8736 _length = reader.read("!H")[0]
8737 orig_reader = reader
8738 reader = orig_reader.slice(_length, 4)
8739 obj.xid = reader.read("!L")[0]
8740 _stats_type = reader.read("!H")[0]
8741 assert(_stats_type == 65535)
8742 obj.flags = reader.read("!H")[0]
8743 reader.skip(4)
8744 _experimenter = reader.read("!L")[0]
8745 assert(_experimenter == 6035143)
8746 _subtype = reader.read("!L")[0]
8747 assert(_subtype == 9)
8748 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_vlan_counter_stats_entry.unpack)
8749 return obj
8750
8751 def __eq__(self, other):
8752 if type(self) != type(other): return False
8753 if self.xid != other.xid: return False
8754 if self.flags != other.flags: return False
8755 if self.entries != other.entries: return False
8756 return True
8757
8758 def pretty_print(self, q):
8759 q.text("bsn_vlan_counter_stats_reply {")
8760 with q.group():
8761 with q.indent(2):
8762 q.breakable()
8763 q.text("xid = ");
8764 if self.xid != None:
8765 q.text("%#x" % self.xid)
8766 else:
8767 q.text('None')
8768 q.text(","); q.breakable()
8769 q.text("flags = ");
8770 q.text("%#x" % self.flags)
8771 q.text(","); q.breakable()
8772 q.text("entries = ");
8773 q.pp(self.entries)
8774 q.breakable()
8775 q.text('}')
8776
8777bsn_stats_reply.subtypes[9] = bsn_vlan_counter_stats_reply
8778
8779class bsn_vlan_counter_stats_request(bsn_stats_request):
8780 version = 5
8781 type = 18
8782 stats_type = 65535
8783 experimenter = 6035143
8784 subtype = 9
8785
8786 def __init__(self, xid=None, flags=None, vlan_vid=None):
8787 if xid != None:
8788 self.xid = xid
8789 else:
8790 self.xid = None
8791 if flags != None:
8792 self.flags = flags
8793 else:
8794 self.flags = 0
8795 if vlan_vid != None:
8796 self.vlan_vid = vlan_vid
8797 else:
8798 self.vlan_vid = 0
8799 return
8800
8801 def pack(self):
8802 packed = []
8803 packed.append(struct.pack("!B", self.version))
8804 packed.append(struct.pack("!B", self.type))
8805 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8806 packed.append(struct.pack("!L", self.xid))
8807 packed.append(struct.pack("!H", self.stats_type))
8808 packed.append(struct.pack("!H", self.flags))
8809 packed.append('\x00' * 4)
8810 packed.append(struct.pack("!L", self.experimenter))
8811 packed.append(struct.pack("!L", self.subtype))
8812 packed.append(struct.pack("!H", self.vlan_vid))
8813 length = sum([len(x) for x in packed])
8814 packed[2] = struct.pack("!H", length)
8815 return ''.join(packed)
8816
8817 @staticmethod
8818 def unpack(reader):
8819 obj = bsn_vlan_counter_stats_request()
8820 _version = reader.read("!B")[0]
8821 assert(_version == 5)
8822 _type = reader.read("!B")[0]
8823 assert(_type == 18)
8824 _length = reader.read("!H")[0]
8825 orig_reader = reader
8826 reader = orig_reader.slice(_length, 4)
8827 obj.xid = reader.read("!L")[0]
8828 _stats_type = reader.read("!H")[0]
8829 assert(_stats_type == 65535)
8830 obj.flags = reader.read("!H")[0]
8831 reader.skip(4)
8832 _experimenter = reader.read("!L")[0]
8833 assert(_experimenter == 6035143)
8834 _subtype = reader.read("!L")[0]
8835 assert(_subtype == 9)
8836 obj.vlan_vid = reader.read("!H")[0]
8837 return obj
8838
8839 def __eq__(self, other):
8840 if type(self) != type(other): return False
8841 if self.xid != other.xid: return False
8842 if self.flags != other.flags: return False
8843 if self.vlan_vid != other.vlan_vid: return False
8844 return True
8845
8846 def pretty_print(self, q):
8847 q.text("bsn_vlan_counter_stats_request {")
8848 with q.group():
8849 with q.indent(2):
8850 q.breakable()
8851 q.text("xid = ");
8852 if self.xid != None:
8853 q.text("%#x" % self.xid)
8854 else:
8855 q.text('None')
8856 q.text(","); q.breakable()
8857 q.text("flags = ");
8858 q.text("%#x" % self.flags)
8859 q.text(","); q.breakable()
8860 q.text("vlan_vid = ");
8861 q.text("%#x" % self.vlan_vid)
8862 q.breakable()
8863 q.text('}')
8864
8865bsn_stats_request.subtypes[9] = bsn_vlan_counter_stats_request
8866
8867class bsn_vrf_counter_stats_reply(bsn_stats_reply):
8868 version = 5
8869 type = 19
8870 stats_type = 65535
8871 experimenter = 6035143
8872 subtype = 15
8873
8874 def __init__(self, xid=None, flags=None, entries=None):
8875 if xid != None:
8876 self.xid = xid
8877 else:
8878 self.xid = None
8879 if flags != None:
8880 self.flags = flags
8881 else:
8882 self.flags = 0
8883 if entries != None:
8884 self.entries = entries
8885 else:
8886 self.entries = []
8887 return
8888
8889 def pack(self):
8890 packed = []
8891 packed.append(struct.pack("!B", self.version))
8892 packed.append(struct.pack("!B", self.type))
8893 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8894 packed.append(struct.pack("!L", self.xid))
8895 packed.append(struct.pack("!H", self.stats_type))
8896 packed.append(struct.pack("!H", self.flags))
8897 packed.append('\x00' * 4)
8898 packed.append(struct.pack("!L", self.experimenter))
8899 packed.append(struct.pack("!L", self.subtype))
8900 packed.append(loxi.generic_util.pack_list(self.entries))
8901 length = sum([len(x) for x in packed])
8902 packed[2] = struct.pack("!H", length)
8903 return ''.join(packed)
8904
8905 @staticmethod
8906 def unpack(reader):
8907 obj = bsn_vrf_counter_stats_reply()
8908 _version = reader.read("!B")[0]
8909 assert(_version == 5)
8910 _type = reader.read("!B")[0]
8911 assert(_type == 19)
8912 _length = reader.read("!H")[0]
8913 orig_reader = reader
8914 reader = orig_reader.slice(_length, 4)
8915 obj.xid = reader.read("!L")[0]
8916 _stats_type = reader.read("!H")[0]
8917 assert(_stats_type == 65535)
8918 obj.flags = reader.read("!H")[0]
8919 reader.skip(4)
8920 _experimenter = reader.read("!L")[0]
8921 assert(_experimenter == 6035143)
8922 _subtype = reader.read("!L")[0]
8923 assert(_subtype == 15)
8924 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_vrf_counter_stats_entry.unpack)
8925 return obj
8926
8927 def __eq__(self, other):
8928 if type(self) != type(other): return False
8929 if self.xid != other.xid: return False
8930 if self.flags != other.flags: return False
8931 if self.entries != other.entries: return False
8932 return True
8933
8934 def pretty_print(self, q):
8935 q.text("bsn_vrf_counter_stats_reply {")
8936 with q.group():
8937 with q.indent(2):
8938 q.breakable()
8939 q.text("xid = ");
8940 if self.xid != None:
8941 q.text("%#x" % self.xid)
8942 else:
8943 q.text('None')
8944 q.text(","); q.breakable()
8945 q.text("flags = ");
8946 q.text("%#x" % self.flags)
8947 q.text(","); q.breakable()
8948 q.text("entries = ");
8949 q.pp(self.entries)
8950 q.breakable()
8951 q.text('}')
8952
8953bsn_stats_reply.subtypes[15] = bsn_vrf_counter_stats_reply
8954
8955class bsn_vrf_counter_stats_request(bsn_stats_request):
8956 version = 5
8957 type = 18
8958 stats_type = 65535
8959 experimenter = 6035143
8960 subtype = 15
8961
8962 def __init__(self, xid=None, flags=None, vrf=None):
8963 if xid != None:
8964 self.xid = xid
8965 else:
8966 self.xid = None
8967 if flags != None:
8968 self.flags = flags
8969 else:
8970 self.flags = 0
8971 if vrf != None:
8972 self.vrf = vrf
8973 else:
8974 self.vrf = 0
8975 return
8976
8977 def pack(self):
8978 packed = []
8979 packed.append(struct.pack("!B", self.version))
8980 packed.append(struct.pack("!B", self.type))
8981 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
8982 packed.append(struct.pack("!L", self.xid))
8983 packed.append(struct.pack("!H", self.stats_type))
8984 packed.append(struct.pack("!H", self.flags))
8985 packed.append('\x00' * 4)
8986 packed.append(struct.pack("!L", self.experimenter))
8987 packed.append(struct.pack("!L", self.subtype))
8988 packed.append(struct.pack("!L", self.vrf))
8989 length = sum([len(x) for x in packed])
8990 packed[2] = struct.pack("!H", length)
8991 return ''.join(packed)
8992
8993 @staticmethod
8994 def unpack(reader):
8995 obj = bsn_vrf_counter_stats_request()
8996 _version = reader.read("!B")[0]
8997 assert(_version == 5)
8998 _type = reader.read("!B")[0]
8999 assert(_type == 18)
9000 _length = reader.read("!H")[0]
9001 orig_reader = reader
9002 reader = orig_reader.slice(_length, 4)
9003 obj.xid = reader.read("!L")[0]
9004 _stats_type = reader.read("!H")[0]
9005 assert(_stats_type == 65535)
9006 obj.flags = reader.read("!H")[0]
9007 reader.skip(4)
9008 _experimenter = reader.read("!L")[0]
9009 assert(_experimenter == 6035143)
9010 _subtype = reader.read("!L")[0]
9011 assert(_subtype == 15)
9012 obj.vrf = reader.read("!L")[0]
9013 return obj
9014
9015 def __eq__(self, other):
9016 if type(self) != type(other): return False
9017 if self.xid != other.xid: return False
9018 if self.flags != other.flags: return False
9019 if self.vrf != other.vrf: return False
9020 return True
9021
9022 def pretty_print(self, q):
9023 q.text("bsn_vrf_counter_stats_request {")
9024 with q.group():
9025 with q.indent(2):
9026 q.breakable()
9027 q.text("xid = ");
9028 if self.xid != None:
9029 q.text("%#x" % self.xid)
9030 else:
9031 q.text('None')
9032 q.text(","); q.breakable()
9033 q.text("flags = ");
9034 q.text("%#x" % self.flags)
9035 q.text(","); q.breakable()
9036 q.text("vrf = ");
9037 q.text("%#x" % self.vrf)
9038 q.breakable()
9039 q.text('}')
9040
9041bsn_stats_request.subtypes[15] = bsn_vrf_counter_stats_request
9042
9043class bundle_add_msg(message):
9044 version = 5
9045 type = 34
9046
9047 def __init__(self, xid=None, bundle_id=None, flags=None, data=None):
9048 if xid != None:
9049 self.xid = xid
9050 else:
9051 self.xid = None
9052 if bundle_id != None:
9053 self.bundle_id = bundle_id
9054 else:
9055 self.bundle_id = 0
9056 if flags != None:
9057 self.flags = flags
9058 else:
9059 self.flags = 0
9060 if data != None:
9061 self.data = data
9062 else:
9063 self.data = ''
9064 return
9065
9066 def pack(self):
9067 packed = []
9068 packed.append(struct.pack("!B", self.version))
9069 packed.append(struct.pack("!B", self.type))
9070 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
9071 packed.append(struct.pack("!L", self.xid))
9072 packed.append(struct.pack("!L", self.bundle_id))
9073 packed.append('\x00' * 2)
9074 packed.append(struct.pack("!H", self.flags))
9075 packed.append(self.data)
9076 length = sum([len(x) for x in packed])
9077 packed[2] = struct.pack("!H", length)
9078 return ''.join(packed)
9079
9080 @staticmethod
9081 def unpack(reader):
9082 obj = bundle_add_msg()
9083 _version = reader.read("!B")[0]
9084 assert(_version == 5)
9085 _type = reader.read("!B")[0]
9086 assert(_type == 34)
9087 _length = reader.read("!H")[0]
9088 orig_reader = reader
9089 reader = orig_reader.slice(_length, 4)
9090 obj.xid = reader.read("!L")[0]
9091 obj.bundle_id = reader.read("!L")[0]
9092 reader.skip(2)
9093 obj.flags = reader.read("!H")[0]
9094 obj.data = str(reader.read_all())
9095 return obj
9096
9097 def __eq__(self, other):
9098 if type(self) != type(other): return False
9099 if self.xid != other.xid: return False
9100 if self.bundle_id != other.bundle_id: return False
9101 if self.flags != other.flags: return False
9102 if self.data != other.data: return False
9103 return True
9104
9105 def pretty_print(self, q):
9106 q.text("bundle_add_msg {")
9107 with q.group():
9108 with q.indent(2):
9109 q.breakable()
9110 q.text("xid = ");
9111 if self.xid != None:
9112 q.text("%#x" % self.xid)
9113 else:
9114 q.text('None')
9115 q.text(","); q.breakable()
9116 q.text("bundle_id = ");
9117 q.text("%#x" % self.bundle_id)
9118 q.text(","); q.breakable()
9119 q.text("flags = ");
9120 q.text("%#x" % self.flags)
9121 q.text(","); q.breakable()
9122 q.text("data = ");
9123 q.pp(self.data)
9124 q.breakable()
9125 q.text('}')
9126
9127message.subtypes[34] = bundle_add_msg
9128
9129class bundle_ctrl_msg(message):
9130 version = 5
9131 type = 33
9132
9133 def __init__(self, xid=None, bundle_id=None, bundle_ctrl_type=None, flags=None, properties=None):
9134 if xid != None:
9135 self.xid = xid
9136 else:
9137 self.xid = None
9138 if bundle_id != None:
9139 self.bundle_id = bundle_id
9140 else:
9141 self.bundle_id = 0
9142 if bundle_ctrl_type != None:
9143 self.bundle_ctrl_type = bundle_ctrl_type
9144 else:
9145 self.bundle_ctrl_type = 0
9146 if flags != None:
9147 self.flags = flags
9148 else:
9149 self.flags = 0
9150 if properties != None:
9151 self.properties = properties
9152 else:
9153 self.properties = []
9154 return
9155
9156 def pack(self):
9157 packed = []
9158 packed.append(struct.pack("!B", self.version))
9159 packed.append(struct.pack("!B", self.type))
9160 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
9161 packed.append(struct.pack("!L", self.xid))
9162 packed.append(struct.pack("!L", self.bundle_id))
9163 packed.append(struct.pack("!H", self.bundle_ctrl_type))
9164 packed.append(struct.pack("!H", self.flags))
9165 packed.append(loxi.generic_util.pack_list(self.properties))
9166 length = sum([len(x) for x in packed])
9167 packed[2] = struct.pack("!H", length)
9168 return ''.join(packed)
9169
9170 @staticmethod
9171 def unpack(reader):
9172 obj = bundle_ctrl_msg()
9173 _version = reader.read("!B")[0]
9174 assert(_version == 5)
9175 _type = reader.read("!B")[0]
9176 assert(_type == 33)
9177 _length = reader.read("!H")[0]
9178 orig_reader = reader
9179 reader = orig_reader.slice(_length, 4)
9180 obj.xid = reader.read("!L")[0]
9181 obj.bundle_id = reader.read("!L")[0]
9182 obj.bundle_ctrl_type = reader.read("!H")[0]
9183 obj.flags = reader.read("!H")[0]
9184 obj.properties = loxi.generic_util.unpack_list(reader, ofp.bundle_prop.bundle_prop.unpack)
9185 return obj
9186
9187 def __eq__(self, other):
9188 if type(self) != type(other): return False
9189 if self.xid != other.xid: return False
9190 if self.bundle_id != other.bundle_id: return False
9191 if self.bundle_ctrl_type != other.bundle_ctrl_type: return False
9192 if self.flags != other.flags: return False
9193 if self.properties != other.properties: return False
9194 return True
9195
9196 def pretty_print(self, q):
9197 q.text("bundle_ctrl_msg {")
9198 with q.group():
9199 with q.indent(2):
9200 q.breakable()
9201 q.text("xid = ");
9202 if self.xid != None:
9203 q.text("%#x" % self.xid)
9204 else:
9205 q.text('None')
9206 q.text(","); q.breakable()
9207 q.text("bundle_id = ");
9208 q.text("%#x" % self.bundle_id)
9209 q.text(","); q.breakable()
9210 q.text("bundle_ctrl_type = ");
9211 q.text("%#x" % self.bundle_ctrl_type)
9212 q.text(","); q.breakable()
9213 q.text("flags = ");
9214 q.text("%#x" % self.flags)
9215 q.text(","); q.breakable()
9216 q.text("properties = ");
9217 q.pp(self.properties)
9218 q.breakable()
9219 q.text('}')
9220
9221message.subtypes[33] = bundle_ctrl_msg
9222
9223class bundle_failed_error_msg(error_msg):
9224 version = 5
9225 type = 1
9226 err_type = 17
9227
9228 def __init__(self, xid=None, code=None, data=None):
9229 if xid != None:
9230 self.xid = xid
9231 else:
9232 self.xid = None
9233 if code != None:
9234 self.code = code
9235 else:
9236 self.code = 0
9237 if data != None:
9238 self.data = data
9239 else:
9240 self.data = ''
9241 return
9242
9243 def pack(self):
9244 packed = []
9245 packed.append(struct.pack("!B", self.version))
9246 packed.append(struct.pack("!B", self.type))
9247 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
9248 packed.append(struct.pack("!L", self.xid))
9249 packed.append(struct.pack("!H", self.err_type))
9250 packed.append(struct.pack("!H", self.code))
9251 packed.append(self.data)
9252 length = sum([len(x) for x in packed])
9253 packed[2] = struct.pack("!H", length)
9254 return ''.join(packed)
9255
9256 @staticmethod
9257 def unpack(reader):
9258 obj = bundle_failed_error_msg()
9259 _version = reader.read("!B")[0]
9260 assert(_version == 5)
9261 _type = reader.read("!B")[0]
9262 assert(_type == 1)
9263 _length = reader.read("!H")[0]
9264 orig_reader = reader
9265 reader = orig_reader.slice(_length, 4)
9266 obj.xid = reader.read("!L")[0]
9267 _err_type = reader.read("!H")[0]
9268 assert(_err_type == 17)
9269 obj.code = reader.read("!H")[0]
9270 obj.data = str(reader.read_all())
9271 return obj
9272
9273 def __eq__(self, other):
9274 if type(self) != type(other): return False
9275 if self.xid != other.xid: return False
9276 if self.code != other.code: return False
9277 if self.data != other.data: return False
9278 return True
9279
9280 def pretty_print(self, q):
9281 q.text("bundle_failed_error_msg {")
9282 with q.group():
9283 with q.indent(2):
9284 q.breakable()
9285 q.text("xid = ");
9286 if self.xid != None:
9287 q.text("%#x" % self.xid)
9288 else:
9289 q.text('None')
9290 q.text(","); q.breakable()
9291 q.text("code = ");
9292 q.text("%#x" % self.code)
9293 q.text(","); q.breakable()
9294 q.text("data = ");
9295 q.pp(self.data)
9296 q.breakable()
9297 q.text('}')
9298
9299error_msg.subtypes[17] = bundle_failed_error_msg
9300
9301class desc_stats_reply(stats_reply):
9302 version = 5
9303 type = 19
9304 stats_type = 0
9305
9306 def __init__(self, xid=None, flags=None, mfr_desc=None, hw_desc=None, sw_desc=None, serial_num=None, dp_desc=None):
9307 if xid != None:
9308 self.xid = xid
9309 else:
9310 self.xid = None
9311 if flags != None:
9312 self.flags = flags
9313 else:
9314 self.flags = 0
9315 if mfr_desc != None:
9316 self.mfr_desc = mfr_desc
9317 else:
9318 self.mfr_desc = ""
9319 if hw_desc != None:
9320 self.hw_desc = hw_desc
9321 else:
9322 self.hw_desc = ""
9323 if sw_desc != None:
9324 self.sw_desc = sw_desc
9325 else:
9326 self.sw_desc = ""
9327 if serial_num != None:
9328 self.serial_num = serial_num
9329 else:
9330 self.serial_num = ""
9331 if dp_desc != None:
9332 self.dp_desc = dp_desc
9333 else:
9334 self.dp_desc = ""
9335 return
9336
9337 def pack(self):
9338 packed = []
9339 packed.append(struct.pack("!B", self.version))
9340 packed.append(struct.pack("!B", self.type))
9341 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
9342 packed.append(struct.pack("!L", self.xid))
9343 packed.append(struct.pack("!H", self.stats_type))
9344 packed.append(struct.pack("!H", self.flags))
9345 packed.append('\x00' * 4)
9346 packed.append(struct.pack("!256s", self.mfr_desc))
9347 packed.append(struct.pack("!256s", self.hw_desc))
9348 packed.append(struct.pack("!256s", self.sw_desc))
9349 packed.append(struct.pack("!32s", self.serial_num))
9350 packed.append(struct.pack("!256s", self.dp_desc))
9351 length = sum([len(x) for x in packed])
9352 packed[2] = struct.pack("!H", length)
9353 return ''.join(packed)
9354
9355 @staticmethod
9356 def unpack(reader):
9357 obj = desc_stats_reply()
9358 _version = reader.read("!B")[0]
9359 assert(_version == 5)
9360 _type = reader.read("!B")[0]
9361 assert(_type == 19)
9362 _length = reader.read("!H")[0]
9363 orig_reader = reader
9364 reader = orig_reader.slice(_length, 4)
9365 obj.xid = reader.read("!L")[0]
9366 _stats_type = reader.read("!H")[0]
9367 assert(_stats_type == 0)
9368 obj.flags = reader.read("!H")[0]
9369 reader.skip(4)
9370 obj.mfr_desc = reader.read("!256s")[0].rstrip("\x00")
9371 obj.hw_desc = reader.read("!256s")[0].rstrip("\x00")
9372 obj.sw_desc = reader.read("!256s")[0].rstrip("\x00")
9373 obj.serial_num = reader.read("!32s")[0].rstrip("\x00")
9374 obj.dp_desc = reader.read("!256s")[0].rstrip("\x00")
9375 return obj
9376
9377 def __eq__(self, other):
9378 if type(self) != type(other): return False
9379 if self.xid != other.xid: return False
9380 if self.flags != other.flags: return False
9381 if self.mfr_desc != other.mfr_desc: return False
9382 if self.hw_desc != other.hw_desc: return False
9383 if self.sw_desc != other.sw_desc: return False
9384 if self.serial_num != other.serial_num: return False
9385 if self.dp_desc != other.dp_desc: return False
9386 return True
9387
9388 def pretty_print(self, q):
9389 q.text("desc_stats_reply {")
9390 with q.group():
9391 with q.indent(2):
9392 q.breakable()
9393 q.text("xid = ");
9394 if self.xid != None:
9395 q.text("%#x" % self.xid)
9396 else:
9397 q.text('None')
9398 q.text(","); q.breakable()
9399 q.text("flags = ");
9400 q.text("%#x" % self.flags)
9401 q.text(","); q.breakable()
9402 q.text("mfr_desc = ");
9403 q.pp(self.mfr_desc)
9404 q.text(","); q.breakable()
9405 q.text("hw_desc = ");
9406 q.pp(self.hw_desc)
9407 q.text(","); q.breakable()
9408 q.text("sw_desc = ");
9409 q.pp(self.sw_desc)
9410 q.text(","); q.breakable()
9411 q.text("serial_num = ");
9412 q.pp(self.serial_num)
9413 q.text(","); q.breakable()
9414 q.text("dp_desc = ");
9415 q.pp(self.dp_desc)
9416 q.breakable()
9417 q.text('}')
9418
9419stats_reply.subtypes[0] = desc_stats_reply
9420
9421class desc_stats_request(stats_request):
9422 version = 5
9423 type = 18
9424 stats_type = 0
9425
9426 def __init__(self, xid=None, flags=None):
9427 if xid != None:
9428 self.xid = xid
9429 else:
9430 self.xid = None
9431 if flags != None:
9432 self.flags = flags
9433 else:
9434 self.flags = 0
9435 return
9436
9437 def pack(self):
9438 packed = []
9439 packed.append(struct.pack("!B", self.version))
9440 packed.append(struct.pack("!B", self.type))
9441 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
9442 packed.append(struct.pack("!L", self.xid))
9443 packed.append(struct.pack("!H", self.stats_type))
9444 packed.append(struct.pack("!H", self.flags))
9445 packed.append('\x00' * 4)
9446 length = sum([len(x) for x in packed])
9447 packed[2] = struct.pack("!H", length)
9448 return ''.join(packed)
9449
9450 @staticmethod
9451 def unpack(reader):
9452 obj = desc_stats_request()
9453 _version = reader.read("!B")[0]
9454 assert(_version == 5)
9455 _type = reader.read("!B")[0]
9456 assert(_type == 18)
9457 _length = reader.read("!H")[0]
9458 orig_reader = reader
9459 reader = orig_reader.slice(_length, 4)
9460 obj.xid = reader.read("!L")[0]
9461 _stats_type = reader.read("!H")[0]
9462 assert(_stats_type == 0)
9463 obj.flags = reader.read("!H")[0]
9464 reader.skip(4)
9465 return obj
9466
9467 def __eq__(self, other):
9468 if type(self) != type(other): return False
9469 if self.xid != other.xid: return False
9470 if self.flags != other.flags: return False
9471 return True
9472
9473 def pretty_print(self, q):
9474 q.text("desc_stats_request {")
9475 with q.group():
9476 with q.indent(2):
9477 q.breakable()
9478 q.text("xid = ");
9479 if self.xid != None:
9480 q.text("%#x" % self.xid)
9481 else:
9482 q.text('None')
9483 q.text(","); q.breakable()
9484 q.text("flags = ");
9485 q.text("%#x" % self.flags)
9486 q.breakable()
9487 q.text('}')
9488
9489stats_request.subtypes[0] = desc_stats_request
9490
9491class echo_reply(message):
9492 version = 5
9493 type = 3
9494
9495 def __init__(self, xid=None, data=None):
9496 if xid != None:
9497 self.xid = xid
9498 else:
9499 self.xid = None
9500 if data != None:
9501 self.data = data
9502 else:
9503 self.data = ''
9504 return
9505
9506 def pack(self):
9507 packed = []
9508 packed.append(struct.pack("!B", self.version))
9509 packed.append(struct.pack("!B", self.type))
9510 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
9511 packed.append(struct.pack("!L", self.xid))
9512 packed.append(self.data)
9513 length = sum([len(x) for x in packed])
9514 packed[2] = struct.pack("!H", length)
9515 return ''.join(packed)
9516
9517 @staticmethod
9518 def unpack(reader):
9519 obj = echo_reply()
9520 _version = reader.read("!B")[0]
9521 assert(_version == 5)
9522 _type = reader.read("!B")[0]
9523 assert(_type == 3)
9524 _length = reader.read("!H")[0]
9525 orig_reader = reader
9526 reader = orig_reader.slice(_length, 4)
9527 obj.xid = reader.read("!L")[0]
9528 obj.data = str(reader.read_all())
9529 return obj
9530
9531 def __eq__(self, other):
9532 if type(self) != type(other): return False
9533 if self.xid != other.xid: return False
9534 if self.data != other.data: return False
9535 return True
9536
9537 def pretty_print(self, q):
9538 q.text("echo_reply {")
9539 with q.group():
9540 with q.indent(2):
9541 q.breakable()
9542 q.text("xid = ");
9543 if self.xid != None:
9544 q.text("%#x" % self.xid)
9545 else:
9546 q.text('None')
9547 q.text(","); q.breakable()
9548 q.text("data = ");
9549 q.pp(self.data)
9550 q.breakable()
9551 q.text('}')
9552
9553message.subtypes[3] = echo_reply
9554
9555class echo_request(message):
9556 version = 5
9557 type = 2
9558
9559 def __init__(self, xid=None, data=None):
9560 if xid != None:
9561 self.xid = xid
9562 else:
9563 self.xid = None
9564 if data != None:
9565 self.data = data
9566 else:
9567 self.data = ''
9568 return
9569
9570 def pack(self):
9571 packed = []
9572 packed.append(struct.pack("!B", self.version))
9573 packed.append(struct.pack("!B", self.type))
9574 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
9575 packed.append(struct.pack("!L", self.xid))
9576 packed.append(self.data)
9577 length = sum([len(x) for x in packed])
9578 packed[2] = struct.pack("!H", length)
9579 return ''.join(packed)
9580
9581 @staticmethod
9582 def unpack(reader):
9583 obj = echo_request()
9584 _version = reader.read("!B")[0]
9585 assert(_version == 5)
9586 _type = reader.read("!B")[0]
9587 assert(_type == 2)
9588 _length = reader.read("!H")[0]
9589 orig_reader = reader
9590 reader = orig_reader.slice(_length, 4)
9591 obj.xid = reader.read("!L")[0]
9592 obj.data = str(reader.read_all())
9593 return obj
9594
9595 def __eq__(self, other):
9596 if type(self) != type(other): return False
9597 if self.xid != other.xid: return False
9598 if self.data != other.data: return False
9599 return True
9600
9601 def pretty_print(self, q):
9602 q.text("echo_request {")
9603 with q.group():
9604 with q.indent(2):
9605 q.breakable()
9606 q.text("xid = ");
9607 if self.xid != None:
9608 q.text("%#x" % self.xid)
9609 else:
9610 q.text('None')
9611 q.text(","); q.breakable()
9612 q.text("data = ");
9613 q.pp(self.data)
9614 q.breakable()
9615 q.text('}')
9616
9617message.subtypes[2] = echo_request
9618
9619class experimenter_error_msg(error_msg):
9620 version = 5
9621 type = 1
9622 err_type = 65535
9623
9624 def __init__(self, xid=None, subtype=None, experimenter=None, data=None):
9625 if xid != None:
9626 self.xid = xid
9627 else:
9628 self.xid = None
9629 if subtype != None:
9630 self.subtype = subtype
9631 else:
9632 self.subtype = 0
9633 if experimenter != None:
9634 self.experimenter = experimenter
9635 else:
9636 self.experimenter = 0
9637 if data != None:
9638 self.data = data
9639 else:
9640 self.data = ''
9641 return
9642
9643 def pack(self):
9644 packed = []
9645 packed.append(struct.pack("!B", self.version))
9646 packed.append(struct.pack("!B", self.type))
9647 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
9648 packed.append(struct.pack("!L", self.xid))
9649 packed.append(struct.pack("!H", self.err_type))
9650 packed.append(struct.pack("!H", self.subtype))
9651 packed.append(struct.pack("!L", self.experimenter))
9652 packed.append(self.data)
9653 length = sum([len(x) for x in packed])
9654 packed[2] = struct.pack("!H", length)
9655 return ''.join(packed)
9656
9657 @staticmethod
9658 def unpack(reader):
9659 obj = experimenter_error_msg()
9660 _version = reader.read("!B")[0]
9661 assert(_version == 5)
9662 _type = reader.read("!B")[0]
9663 assert(_type == 1)
9664 _length = reader.read("!H")[0]
9665 orig_reader = reader
9666 reader = orig_reader.slice(_length, 4)
9667 obj.xid = reader.read("!L")[0]
9668 _err_type = reader.read("!H")[0]
9669 assert(_err_type == 65535)
9670 obj.subtype = reader.read("!H")[0]
9671 obj.experimenter = reader.read("!L")[0]
9672 obj.data = str(reader.read_all())
9673 return obj
9674
9675 def __eq__(self, other):
9676 if type(self) != type(other): return False
9677 if self.xid != other.xid: return False
9678 if self.subtype != other.subtype: return False
9679 if self.experimenter != other.experimenter: return False
9680 if self.data != other.data: return False
9681 return True
9682
9683 def pretty_print(self, q):
9684 q.text("experimenter_error_msg {")
9685 with q.group():
9686 with q.indent(2):
9687 q.breakable()
9688 q.text("xid = ");
9689 if self.xid != None:
9690 q.text("%#x" % self.xid)
9691 else:
9692 q.text('None')
9693 q.text(","); q.breakable()
9694 q.text("subtype = ");
9695 q.text("%#x" % self.subtype)
9696 q.text(","); q.breakable()
9697 q.text("experimenter = ");
9698 q.text("%#x" % self.experimenter)
9699 q.text(","); q.breakable()
9700 q.text("data = ");
9701 q.pp(self.data)
9702 q.breakable()
9703 q.text('}')
9704
9705error_msg.subtypes[65535] = experimenter_error_msg
9706
9707class features_reply(message):
9708 version = 5
9709 type = 6
9710
9711 def __init__(self, xid=None, datapath_id=None, n_buffers=None, n_tables=None, auxiliary_id=None, capabilities=None, reserved=None):
9712 if xid != None:
9713 self.xid = xid
9714 else:
9715 self.xid = None
9716 if datapath_id != None:
9717 self.datapath_id = datapath_id
9718 else:
9719 self.datapath_id = 0
9720 if n_buffers != None:
9721 self.n_buffers = n_buffers
9722 else:
9723 self.n_buffers = 0
9724 if n_tables != None:
9725 self.n_tables = n_tables
9726 else:
9727 self.n_tables = 0
9728 if auxiliary_id != None:
9729 self.auxiliary_id = auxiliary_id
9730 else:
9731 self.auxiliary_id = 0
9732 if capabilities != None:
9733 self.capabilities = capabilities
9734 else:
9735 self.capabilities = 0
9736 if reserved != None:
9737 self.reserved = reserved
9738 else:
9739 self.reserved = 0
9740 return
9741
9742 def pack(self):
9743 packed = []
9744 packed.append(struct.pack("!B", self.version))
9745 packed.append(struct.pack("!B", self.type))
9746 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
9747 packed.append(struct.pack("!L", self.xid))
9748 packed.append(struct.pack("!Q", self.datapath_id))
9749 packed.append(struct.pack("!L", self.n_buffers))
9750 packed.append(struct.pack("!B", self.n_tables))
9751 packed.append(struct.pack("!B", self.auxiliary_id))
9752 packed.append('\x00' * 2)
9753 packed.append(struct.pack("!L", self.capabilities))
9754 packed.append(struct.pack("!L", self.reserved))
9755 length = sum([len(x) for x in packed])
9756 packed[2] = struct.pack("!H", length)
9757 return ''.join(packed)
9758
9759 @staticmethod
9760 def unpack(reader):
9761 obj = features_reply()
9762 _version = reader.read("!B")[0]
9763 assert(_version == 5)
9764 _type = reader.read("!B")[0]
9765 assert(_type == 6)
9766 _length = reader.read("!H")[0]
9767 orig_reader = reader
9768 reader = orig_reader.slice(_length, 4)
9769 obj.xid = reader.read("!L")[0]
9770 obj.datapath_id = reader.read("!Q")[0]
9771 obj.n_buffers = reader.read("!L")[0]
9772 obj.n_tables = reader.read("!B")[0]
9773 obj.auxiliary_id = reader.read("!B")[0]
9774 reader.skip(2)
9775 obj.capabilities = reader.read("!L")[0]
9776 obj.reserved = reader.read("!L")[0]
9777 return obj
9778
9779 def __eq__(self, other):
9780 if type(self) != type(other): return False
9781 if self.xid != other.xid: return False
9782 if self.datapath_id != other.datapath_id: return False
9783 if self.n_buffers != other.n_buffers: return False
9784 if self.n_tables != other.n_tables: return False
9785 if self.auxiliary_id != other.auxiliary_id: return False
9786 if self.capabilities != other.capabilities: return False
9787 if self.reserved != other.reserved: return False
9788 return True
9789
9790 def pretty_print(self, q):
9791 q.text("features_reply {")
9792 with q.group():
9793 with q.indent(2):
9794 q.breakable()
9795 q.text("xid = ");
9796 if self.xid != None:
9797 q.text("%#x" % self.xid)
9798 else:
9799 q.text('None')
9800 q.text(","); q.breakable()
9801 q.text("datapath_id = ");
9802 q.text("%#x" % self.datapath_id)
9803 q.text(","); q.breakable()
9804 q.text("n_buffers = ");
9805 q.text("%#x" % self.n_buffers)
9806 q.text(","); q.breakable()
9807 q.text("n_tables = ");
9808 q.text("%#x" % self.n_tables)
9809 q.text(","); q.breakable()
9810 q.text("auxiliary_id = ");
9811 q.text("%#x" % self.auxiliary_id)
9812 q.text(","); q.breakable()
9813 q.text("capabilities = ");
9814 q.text("%#x" % self.capabilities)
9815 q.text(","); q.breakable()
9816 q.text("reserved = ");
9817 q.text("%#x" % self.reserved)
9818 q.breakable()
9819 q.text('}')
9820
9821message.subtypes[6] = features_reply
9822
9823class features_request(message):
9824 version = 5
9825 type = 5
9826
9827 def __init__(self, xid=None):
9828 if xid != None:
9829 self.xid = xid
9830 else:
9831 self.xid = None
9832 return
9833
9834 def pack(self):
9835 packed = []
9836 packed.append(struct.pack("!B", self.version))
9837 packed.append(struct.pack("!B", self.type))
9838 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
9839 packed.append(struct.pack("!L", self.xid))
9840 length = sum([len(x) for x in packed])
9841 packed[2] = struct.pack("!H", length)
9842 return ''.join(packed)
9843
9844 @staticmethod
9845 def unpack(reader):
9846 obj = features_request()
9847 _version = reader.read("!B")[0]
9848 assert(_version == 5)
9849 _type = reader.read("!B")[0]
9850 assert(_type == 5)
9851 _length = reader.read("!H")[0]
9852 orig_reader = reader
9853 reader = orig_reader.slice(_length, 4)
9854 obj.xid = reader.read("!L")[0]
9855 return obj
9856
9857 def __eq__(self, other):
9858 if type(self) != type(other): return False
9859 if self.xid != other.xid: return False
9860 return True
9861
9862 def pretty_print(self, q):
9863 q.text("features_request {")
9864 with q.group():
9865 with q.indent(2):
9866 q.breakable()
9867 q.text("xid = ");
9868 if self.xid != None:
9869 q.text("%#x" % self.xid)
9870 else:
9871 q.text('None')
9872 q.breakable()
9873 q.text('}')
9874
9875message.subtypes[5] = features_request
9876
9877class flow_mod(message):
9878 subtypes = {}
9879
9880 version = 5
9881 type = 14
9882
9883 def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, _command=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
9884 if xid != None:
9885 self.xid = xid
9886 else:
9887 self.xid = None
9888 if cookie != None:
9889 self.cookie = cookie
9890 else:
9891 self.cookie = 0
9892 if cookie_mask != None:
9893 self.cookie_mask = cookie_mask
9894 else:
9895 self.cookie_mask = 0
9896 if table_id != None:
9897 self.table_id = table_id
9898 else:
9899 self.table_id = 0
9900 if _command != None:
9901 self._command = _command
9902 else:
9903 self._command = 0
9904 if idle_timeout != None:
9905 self.idle_timeout = idle_timeout
9906 else:
9907 self.idle_timeout = 0
9908 if hard_timeout != None:
9909 self.hard_timeout = hard_timeout
9910 else:
9911 self.hard_timeout = 0
9912 if priority != None:
9913 self.priority = priority
9914 else:
9915 self.priority = 0
9916 if buffer_id != None:
9917 self.buffer_id = buffer_id
9918 else:
9919 self.buffer_id = 0
9920 if out_port != None:
9921 self.out_port = out_port
9922 else:
9923 self.out_port = 0
9924 if out_group != None:
9925 self.out_group = out_group
9926 else:
9927 self.out_group = 0
9928 if flags != None:
9929 self.flags = flags
9930 else:
9931 self.flags = 0
9932 if match != None:
9933 self.match = match
9934 else:
9935 self.match = ofp.match()
9936 if instructions != None:
9937 self.instructions = instructions
9938 else:
9939 self.instructions = []
9940 return
9941
9942 def pack(self):
9943 packed = []
9944 packed.append(struct.pack("!B", self.version))
9945 packed.append(struct.pack("!B", self.type))
9946 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
9947 packed.append(struct.pack("!L", self.xid))
9948 packed.append(struct.pack("!Q", self.cookie))
9949 packed.append(struct.pack("!Q", self.cookie_mask))
9950 packed.append(struct.pack("!B", self.table_id))
9951 packed.append(util.pack_fm_cmd(self._command))
9952 packed.append(struct.pack("!H", self.idle_timeout))
9953 packed.append(struct.pack("!H", self.hard_timeout))
9954 packed.append(struct.pack("!H", self.priority))
9955 packed.append(struct.pack("!L", self.buffer_id))
9956 packed.append(util.pack_port_no(self.out_port))
9957 packed.append(struct.pack("!L", self.out_group))
9958 packed.append(struct.pack("!H", self.flags))
9959 packed.append('\x00' * 2)
9960 packed.append(self.match.pack())
9961 packed.append(loxi.generic_util.pack_list(self.instructions))
9962 length = sum([len(x) for x in packed])
9963 packed[2] = struct.pack("!H", length)
9964 return ''.join(packed)
9965
9966 @staticmethod
9967 def unpack(reader):
9968 subtype, = reader.peek('B', 25)
9969 subclass = flow_mod.subtypes.get(subtype)
9970 if subclass:
9971 return subclass.unpack(reader)
9972
9973 obj = flow_mod()
9974 _version = reader.read("!B")[0]
9975 assert(_version == 5)
9976 _type = reader.read("!B")[0]
9977 assert(_type == 14)
9978 _length = reader.read("!H")[0]
9979 orig_reader = reader
9980 reader = orig_reader.slice(_length, 4)
9981 obj.xid = reader.read("!L")[0]
9982 obj.cookie = reader.read("!Q")[0]
9983 obj.cookie_mask = reader.read("!Q")[0]
9984 obj.table_id = reader.read("!B")[0]
9985 obj._command = util.unpack_fm_cmd(reader)
9986 obj.idle_timeout = reader.read("!H")[0]
9987 obj.hard_timeout = reader.read("!H")[0]
9988 obj.priority = reader.read("!H")[0]
9989 obj.buffer_id = reader.read("!L")[0]
9990 obj.out_port = util.unpack_port_no(reader)
9991 obj.out_group = reader.read("!L")[0]
9992 obj.flags = reader.read("!H")[0]
9993 reader.skip(2)
9994 obj.match = ofp.match.unpack(reader)
9995 obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
9996 return obj
9997
9998 def __eq__(self, other):
9999 if type(self) != type(other): return False
10000 if self.xid != other.xid: return False
10001 if self.cookie != other.cookie: return False
10002 if self.cookie_mask != other.cookie_mask: return False
10003 if self.table_id != other.table_id: return False
10004 if self._command != other._command: return False
10005 if self.idle_timeout != other.idle_timeout: return False
10006 if self.hard_timeout != other.hard_timeout: return False
10007 if self.priority != other.priority: return False
10008 if self.buffer_id != other.buffer_id: return False
10009 if self.out_port != other.out_port: return False
10010 if self.out_group != other.out_group: return False
10011 if self.flags != other.flags: return False
10012 if self.match != other.match: return False
10013 if self.instructions != other.instructions: return False
10014 return True
10015
10016 def pretty_print(self, q):
10017 q.text("flow_mod {")
10018 with q.group():
10019 with q.indent(2):
10020 q.breakable()
10021 q.text("xid = ");
10022 if self.xid != None:
10023 q.text("%#x" % self.xid)
10024 else:
10025 q.text('None')
10026 q.text(","); q.breakable()
10027 q.text("cookie = ");
10028 q.text("%#x" % self.cookie)
10029 q.text(","); q.breakable()
10030 q.text("cookie_mask = ");
10031 q.text("%#x" % self.cookie_mask)
10032 q.text(","); q.breakable()
10033 q.text("table_id = ");
10034 q.text("%#x" % self.table_id)
10035 q.text(","); q.breakable()
10036 q.text("idle_timeout = ");
10037 q.text("%#x" % self.idle_timeout)
10038 q.text(","); q.breakable()
10039 q.text("hard_timeout = ");
10040 q.text("%#x" % self.hard_timeout)
10041 q.text(","); q.breakable()
10042 q.text("priority = ");
10043 q.text("%#x" % self.priority)
10044 q.text(","); q.breakable()
10045 q.text("buffer_id = ");
10046 q.text("%#x" % self.buffer_id)
10047 q.text(","); q.breakable()
10048 q.text("out_port = ");
10049 q.text(util.pretty_port(self.out_port))
10050 q.text(","); q.breakable()
10051 q.text("out_group = ");
10052 q.text("%#x" % self.out_group)
10053 q.text(","); q.breakable()
10054 q.text("flags = ");
10055 q.text("%#x" % self.flags)
10056 q.text(","); q.breakable()
10057 q.text("match = ");
10058 q.pp(self.match)
10059 q.text(","); q.breakable()
10060 q.text("instructions = ");
10061 q.pp(self.instructions)
10062 q.breakable()
10063 q.text('}')
10064
10065message.subtypes[14] = flow_mod
10066
10067class flow_add(flow_mod):
10068 version = 5
10069 type = 14
10070 _command = 0
10071
10072 def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, importance=None, match=None, instructions=None):
10073 if xid != None:
10074 self.xid = xid
10075 else:
10076 self.xid = None
10077 if cookie != None:
10078 self.cookie = cookie
10079 else:
10080 self.cookie = 0
10081 if cookie_mask != None:
10082 self.cookie_mask = cookie_mask
10083 else:
10084 self.cookie_mask = 0
10085 if table_id != None:
10086 self.table_id = table_id
10087 else:
10088 self.table_id = 0
10089 if idle_timeout != None:
10090 self.idle_timeout = idle_timeout
10091 else:
10092 self.idle_timeout = 0
10093 if hard_timeout != None:
10094 self.hard_timeout = hard_timeout
10095 else:
10096 self.hard_timeout = 0
10097 if priority != None:
10098 self.priority = priority
10099 else:
10100 self.priority = 0
10101 if buffer_id != None:
10102 self.buffer_id = buffer_id
10103 else:
10104 self.buffer_id = 0
10105 if out_port != None:
10106 self.out_port = out_port
10107 else:
10108 self.out_port = 0
10109 if out_group != None:
10110 self.out_group = out_group
10111 else:
10112 self.out_group = 0
10113 if flags != None:
10114 self.flags = flags
10115 else:
10116 self.flags = 0
10117 if importance != None:
10118 self.importance = importance
10119 else:
10120 self.importance = 0
10121 if match != None:
10122 self.match = match
10123 else:
10124 self.match = ofp.match()
10125 if instructions != None:
10126 self.instructions = instructions
10127 else:
10128 self.instructions = []
10129 return
10130
10131 def pack(self):
10132 packed = []
10133 packed.append(struct.pack("!B", self.version))
10134 packed.append(struct.pack("!B", self.type))
10135 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
10136 packed.append(struct.pack("!L", self.xid))
10137 packed.append(struct.pack("!Q", self.cookie))
10138 packed.append(struct.pack("!Q", self.cookie_mask))
10139 packed.append(struct.pack("!B", self.table_id))
10140 packed.append(util.pack_fm_cmd(self._command))
10141 packed.append(struct.pack("!H", self.idle_timeout))
10142 packed.append(struct.pack("!H", self.hard_timeout))
10143 packed.append(struct.pack("!H", self.priority))
10144 packed.append(struct.pack("!L", self.buffer_id))
10145 packed.append(util.pack_port_no(self.out_port))
10146 packed.append(struct.pack("!L", self.out_group))
10147 packed.append(struct.pack("!H", self.flags))
10148 packed.append(struct.pack("!H", self.importance))
10149 packed.append(self.match.pack())
10150 packed.append(loxi.generic_util.pack_list(self.instructions))
10151 length = sum([len(x) for x in packed])
10152 packed[2] = struct.pack("!H", length)
10153 return ''.join(packed)
10154
10155 @staticmethod
10156 def unpack(reader):
10157 obj = flow_add()
10158 _version = reader.read("!B")[0]
10159 assert(_version == 5)
10160 _type = reader.read("!B")[0]
10161 assert(_type == 14)
10162 _length = reader.read("!H")[0]
10163 orig_reader = reader
10164 reader = orig_reader.slice(_length, 4)
10165 obj.xid = reader.read("!L")[0]
10166 obj.cookie = reader.read("!Q")[0]
10167 obj.cookie_mask = reader.read("!Q")[0]
10168 obj.table_id = reader.read("!B")[0]
10169 __command = util.unpack_fm_cmd(reader)
10170 assert(__command == 0)
10171 obj.idle_timeout = reader.read("!H")[0]
10172 obj.hard_timeout = reader.read("!H")[0]
10173 obj.priority = reader.read("!H")[0]
10174 obj.buffer_id = reader.read("!L")[0]
10175 obj.out_port = util.unpack_port_no(reader)
10176 obj.out_group = reader.read("!L")[0]
10177 obj.flags = reader.read("!H")[0]
10178 obj.importance = reader.read("!H")[0]
10179 obj.match = ofp.match.unpack(reader)
10180 obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
10181 return obj
10182
10183 def __eq__(self, other):
10184 if type(self) != type(other): return False
10185 if self.xid != other.xid: return False
10186 if self.cookie != other.cookie: return False
10187 if self.cookie_mask != other.cookie_mask: return False
10188 if self.table_id != other.table_id: return False
10189 if self.idle_timeout != other.idle_timeout: return False
10190 if self.hard_timeout != other.hard_timeout: return False
10191 if self.priority != other.priority: return False
10192 if self.buffer_id != other.buffer_id: return False
10193 if self.out_port != other.out_port: return False
10194 if self.out_group != other.out_group: return False
10195 if self.flags != other.flags: return False
10196 if self.importance != other.importance: return False
10197 if self.match != other.match: return False
10198 if self.instructions != other.instructions: return False
10199 return True
10200
10201 def pretty_print(self, q):
10202 q.text("flow_add {")
10203 with q.group():
10204 with q.indent(2):
10205 q.breakable()
10206 q.text("xid = ");
10207 if self.xid != None:
10208 q.text("%#x" % self.xid)
10209 else:
10210 q.text('None')
10211 q.text(","); q.breakable()
10212 q.text("cookie = ");
10213 q.text("%#x" % self.cookie)
10214 q.text(","); q.breakable()
10215 q.text("cookie_mask = ");
10216 q.text("%#x" % self.cookie_mask)
10217 q.text(","); q.breakable()
10218 q.text("table_id = ");
10219 q.text("%#x" % self.table_id)
10220 q.text(","); q.breakable()
10221 q.text("idle_timeout = ");
10222 q.text("%#x" % self.idle_timeout)
10223 q.text(","); q.breakable()
10224 q.text("hard_timeout = ");
10225 q.text("%#x" % self.hard_timeout)
10226 q.text(","); q.breakable()
10227 q.text("priority = ");
10228 q.text("%#x" % self.priority)
10229 q.text(","); q.breakable()
10230 q.text("buffer_id = ");
10231 q.text("%#x" % self.buffer_id)
10232 q.text(","); q.breakable()
10233 q.text("out_port = ");
10234 q.text(util.pretty_port(self.out_port))
10235 q.text(","); q.breakable()
10236 q.text("out_group = ");
10237 q.text("%#x" % self.out_group)
10238 q.text(","); q.breakable()
10239 q.text("flags = ");
10240 q.text("%#x" % self.flags)
10241 q.text(","); q.breakable()
10242 q.text("importance = ");
10243 q.text("%#x" % self.importance)
10244 q.text(","); q.breakable()
10245 q.text("match = ");
10246 q.pp(self.match)
10247 q.text(","); q.breakable()
10248 q.text("instructions = ");
10249 q.pp(self.instructions)
10250 q.breakable()
10251 q.text('}')
10252
10253flow_mod.subtypes[0] = flow_add
10254
10255class flow_delete(flow_mod):
10256 version = 5
10257 type = 14
10258 _command = 3
10259
10260 def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, importance=None, match=None, instructions=None):
10261 if xid != None:
10262 self.xid = xid
10263 else:
10264 self.xid = None
10265 if cookie != None:
10266 self.cookie = cookie
10267 else:
10268 self.cookie = 0
10269 if cookie_mask != None:
10270 self.cookie_mask = cookie_mask
10271 else:
10272 self.cookie_mask = 0
10273 if table_id != None:
10274 self.table_id = table_id
10275 else:
10276 self.table_id = 0
10277 if idle_timeout != None:
10278 self.idle_timeout = idle_timeout
10279 else:
10280 self.idle_timeout = 0
10281 if hard_timeout != None:
10282 self.hard_timeout = hard_timeout
10283 else:
10284 self.hard_timeout = 0
10285 if priority != None:
10286 self.priority = priority
10287 else:
10288 self.priority = 0
10289 if buffer_id != None:
10290 self.buffer_id = buffer_id
10291 else:
10292 self.buffer_id = 0
10293 if out_port != None:
10294 self.out_port = out_port
10295 else:
10296 self.out_port = 0
10297 if out_group != None:
10298 self.out_group = out_group
10299 else:
10300 self.out_group = 0
10301 if flags != None:
10302 self.flags = flags
10303 else:
10304 self.flags = 0
10305 if importance != None:
10306 self.importance = importance
10307 else:
10308 self.importance = 0
10309 if match != None:
10310 self.match = match
10311 else:
10312 self.match = ofp.match()
10313 if instructions != None:
10314 self.instructions = instructions
10315 else:
10316 self.instructions = []
10317 return
10318
10319 def pack(self):
10320 packed = []
10321 packed.append(struct.pack("!B", self.version))
10322 packed.append(struct.pack("!B", self.type))
10323 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
10324 packed.append(struct.pack("!L", self.xid))
10325 packed.append(struct.pack("!Q", self.cookie))
10326 packed.append(struct.pack("!Q", self.cookie_mask))
10327 packed.append(struct.pack("!B", self.table_id))
10328 packed.append(util.pack_fm_cmd(self._command))
10329 packed.append(struct.pack("!H", self.idle_timeout))
10330 packed.append(struct.pack("!H", self.hard_timeout))
10331 packed.append(struct.pack("!H", self.priority))
10332 packed.append(struct.pack("!L", self.buffer_id))
10333 packed.append(util.pack_port_no(self.out_port))
10334 packed.append(struct.pack("!L", self.out_group))
10335 packed.append(struct.pack("!H", self.flags))
10336 packed.append(struct.pack("!H", self.importance))
10337 packed.append(self.match.pack())
10338 packed.append(loxi.generic_util.pack_list(self.instructions))
10339 length = sum([len(x) for x in packed])
10340 packed[2] = struct.pack("!H", length)
10341 return ''.join(packed)
10342
10343 @staticmethod
10344 def unpack(reader):
10345 obj = flow_delete()
10346 _version = reader.read("!B")[0]
10347 assert(_version == 5)
10348 _type = reader.read("!B")[0]
10349 assert(_type == 14)
10350 _length = reader.read("!H")[0]
10351 orig_reader = reader
10352 reader = orig_reader.slice(_length, 4)
10353 obj.xid = reader.read("!L")[0]
10354 obj.cookie = reader.read("!Q")[0]
10355 obj.cookie_mask = reader.read("!Q")[0]
10356 obj.table_id = reader.read("!B")[0]
10357 __command = util.unpack_fm_cmd(reader)
10358 assert(__command == 3)
10359 obj.idle_timeout = reader.read("!H")[0]
10360 obj.hard_timeout = reader.read("!H")[0]
10361 obj.priority = reader.read("!H")[0]
10362 obj.buffer_id = reader.read("!L")[0]
10363 obj.out_port = util.unpack_port_no(reader)
10364 obj.out_group = reader.read("!L")[0]
10365 obj.flags = reader.read("!H")[0]
10366 obj.importance = reader.read("!H")[0]
10367 obj.match = ofp.match.unpack(reader)
10368 obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
10369 return obj
10370
10371 def __eq__(self, other):
10372 if type(self) != type(other): return False
10373 if self.xid != other.xid: return False
10374 if self.cookie != other.cookie: return False
10375 if self.cookie_mask != other.cookie_mask: return False
10376 if self.table_id != other.table_id: return False
10377 if self.idle_timeout != other.idle_timeout: return False
10378 if self.hard_timeout != other.hard_timeout: return False
10379 if self.priority != other.priority: return False
10380 if self.buffer_id != other.buffer_id: return False
10381 if self.out_port != other.out_port: return False
10382 if self.out_group != other.out_group: return False
10383 if self.flags != other.flags: return False
10384 if self.importance != other.importance: return False
10385 if self.match != other.match: return False
10386 if self.instructions != other.instructions: return False
10387 return True
10388
10389 def pretty_print(self, q):
10390 q.text("flow_delete {")
10391 with q.group():
10392 with q.indent(2):
10393 q.breakable()
10394 q.text("xid = ");
10395 if self.xid != None:
10396 q.text("%#x" % self.xid)
10397 else:
10398 q.text('None')
10399 q.text(","); q.breakable()
10400 q.text("cookie = ");
10401 q.text("%#x" % self.cookie)
10402 q.text(","); q.breakable()
10403 q.text("cookie_mask = ");
10404 q.text("%#x" % self.cookie_mask)
10405 q.text(","); q.breakable()
10406 q.text("table_id = ");
10407 q.text("%#x" % self.table_id)
10408 q.text(","); q.breakable()
10409 q.text("idle_timeout = ");
10410 q.text("%#x" % self.idle_timeout)
10411 q.text(","); q.breakable()
10412 q.text("hard_timeout = ");
10413 q.text("%#x" % self.hard_timeout)
10414 q.text(","); q.breakable()
10415 q.text("priority = ");
10416 q.text("%#x" % self.priority)
10417 q.text(","); q.breakable()
10418 q.text("buffer_id = ");
10419 q.text("%#x" % self.buffer_id)
10420 q.text(","); q.breakable()
10421 q.text("out_port = ");
10422 q.text(util.pretty_port(self.out_port))
10423 q.text(","); q.breakable()
10424 q.text("out_group = ");
10425 q.text("%#x" % self.out_group)
10426 q.text(","); q.breakable()
10427 q.text("flags = ");
10428 q.text("%#x" % self.flags)
10429 q.text(","); q.breakable()
10430 q.text("importance = ");
10431 q.text("%#x" % self.importance)
10432 q.text(","); q.breakable()
10433 q.text("match = ");
10434 q.pp(self.match)
10435 q.text(","); q.breakable()
10436 q.text("instructions = ");
10437 q.pp(self.instructions)
10438 q.breakable()
10439 q.text('}')
10440
10441flow_mod.subtypes[3] = flow_delete
10442
10443class flow_delete_strict(flow_mod):
10444 version = 5
10445 type = 14
10446 _command = 4
10447
10448 def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, importance=None, match=None, instructions=None):
10449 if xid != None:
10450 self.xid = xid
10451 else:
10452 self.xid = None
10453 if cookie != None:
10454 self.cookie = cookie
10455 else:
10456 self.cookie = 0
10457 if cookie_mask != None:
10458 self.cookie_mask = cookie_mask
10459 else:
10460 self.cookie_mask = 0
10461 if table_id != None:
10462 self.table_id = table_id
10463 else:
10464 self.table_id = 0
10465 if idle_timeout != None:
10466 self.idle_timeout = idle_timeout
10467 else:
10468 self.idle_timeout = 0
10469 if hard_timeout != None:
10470 self.hard_timeout = hard_timeout
10471 else:
10472 self.hard_timeout = 0
10473 if priority != None:
10474 self.priority = priority
10475 else:
10476 self.priority = 0
10477 if buffer_id != None:
10478 self.buffer_id = buffer_id
10479 else:
10480 self.buffer_id = 0
10481 if out_port != None:
10482 self.out_port = out_port
10483 else:
10484 self.out_port = 0
10485 if out_group != None:
10486 self.out_group = out_group
10487 else:
10488 self.out_group = 0
10489 if flags != None:
10490 self.flags = flags
10491 else:
10492 self.flags = 0
10493 if importance != None:
10494 self.importance = importance
10495 else:
10496 self.importance = 0
10497 if match != None:
10498 self.match = match
10499 else:
10500 self.match = ofp.match()
10501 if instructions != None:
10502 self.instructions = instructions
10503 else:
10504 self.instructions = []
10505 return
10506
10507 def pack(self):
10508 packed = []
10509 packed.append(struct.pack("!B", self.version))
10510 packed.append(struct.pack("!B", self.type))
10511 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
10512 packed.append(struct.pack("!L", self.xid))
10513 packed.append(struct.pack("!Q", self.cookie))
10514 packed.append(struct.pack("!Q", self.cookie_mask))
10515 packed.append(struct.pack("!B", self.table_id))
10516 packed.append(util.pack_fm_cmd(self._command))
10517 packed.append(struct.pack("!H", self.idle_timeout))
10518 packed.append(struct.pack("!H", self.hard_timeout))
10519 packed.append(struct.pack("!H", self.priority))
10520 packed.append(struct.pack("!L", self.buffer_id))
10521 packed.append(util.pack_port_no(self.out_port))
10522 packed.append(struct.pack("!L", self.out_group))
10523 packed.append(struct.pack("!H", self.flags))
10524 packed.append(struct.pack("!H", self.importance))
10525 packed.append(self.match.pack())
10526 packed.append(loxi.generic_util.pack_list(self.instructions))
10527 length = sum([len(x) for x in packed])
10528 packed[2] = struct.pack("!H", length)
10529 return ''.join(packed)
10530
10531 @staticmethod
10532 def unpack(reader):
10533 obj = flow_delete_strict()
10534 _version = reader.read("!B")[0]
10535 assert(_version == 5)
10536 _type = reader.read("!B")[0]
10537 assert(_type == 14)
10538 _length = reader.read("!H")[0]
10539 orig_reader = reader
10540 reader = orig_reader.slice(_length, 4)
10541 obj.xid = reader.read("!L")[0]
10542 obj.cookie = reader.read("!Q")[0]
10543 obj.cookie_mask = reader.read("!Q")[0]
10544 obj.table_id = reader.read("!B")[0]
10545 __command = util.unpack_fm_cmd(reader)
10546 assert(__command == 4)
10547 obj.idle_timeout = reader.read("!H")[0]
10548 obj.hard_timeout = reader.read("!H")[0]
10549 obj.priority = reader.read("!H")[0]
10550 obj.buffer_id = reader.read("!L")[0]
10551 obj.out_port = util.unpack_port_no(reader)
10552 obj.out_group = reader.read("!L")[0]
10553 obj.flags = reader.read("!H")[0]
10554 obj.importance = reader.read("!H")[0]
10555 obj.match = ofp.match.unpack(reader)
10556 obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
10557 return obj
10558
10559 def __eq__(self, other):
10560 if type(self) != type(other): return False
10561 if self.xid != other.xid: return False
10562 if self.cookie != other.cookie: return False
10563 if self.cookie_mask != other.cookie_mask: return False
10564 if self.table_id != other.table_id: return False
10565 if self.idle_timeout != other.idle_timeout: return False
10566 if self.hard_timeout != other.hard_timeout: return False
10567 if self.priority != other.priority: return False
10568 if self.buffer_id != other.buffer_id: return False
10569 if self.out_port != other.out_port: return False
10570 if self.out_group != other.out_group: return False
10571 if self.flags != other.flags: return False
10572 if self.importance != other.importance: return False
10573 if self.match != other.match: return False
10574 if self.instructions != other.instructions: return False
10575 return True
10576
10577 def pretty_print(self, q):
10578 q.text("flow_delete_strict {")
10579 with q.group():
10580 with q.indent(2):
10581 q.breakable()
10582 q.text("xid = ");
10583 if self.xid != None:
10584 q.text("%#x" % self.xid)
10585 else:
10586 q.text('None')
10587 q.text(","); q.breakable()
10588 q.text("cookie = ");
10589 q.text("%#x" % self.cookie)
10590 q.text(","); q.breakable()
10591 q.text("cookie_mask = ");
10592 q.text("%#x" % self.cookie_mask)
10593 q.text(","); q.breakable()
10594 q.text("table_id = ");
10595 q.text("%#x" % self.table_id)
10596 q.text(","); q.breakable()
10597 q.text("idle_timeout = ");
10598 q.text("%#x" % self.idle_timeout)
10599 q.text(","); q.breakable()
10600 q.text("hard_timeout = ");
10601 q.text("%#x" % self.hard_timeout)
10602 q.text(","); q.breakable()
10603 q.text("priority = ");
10604 q.text("%#x" % self.priority)
10605 q.text(","); q.breakable()
10606 q.text("buffer_id = ");
10607 q.text("%#x" % self.buffer_id)
10608 q.text(","); q.breakable()
10609 q.text("out_port = ");
10610 q.text(util.pretty_port(self.out_port))
10611 q.text(","); q.breakable()
10612 q.text("out_group = ");
10613 q.text("%#x" % self.out_group)
10614 q.text(","); q.breakable()
10615 q.text("flags = ");
10616 q.text("%#x" % self.flags)
10617 q.text(","); q.breakable()
10618 q.text("importance = ");
10619 q.text("%#x" % self.importance)
10620 q.text(","); q.breakable()
10621 q.text("match = ");
10622 q.pp(self.match)
10623 q.text(","); q.breakable()
10624 q.text("instructions = ");
10625 q.pp(self.instructions)
10626 q.breakable()
10627 q.text('}')
10628
10629flow_mod.subtypes[4] = flow_delete_strict
10630
10631class flow_mod_failed_error_msg(error_msg):
10632 version = 5
10633 type = 1
10634 err_type = 5
10635
10636 def __init__(self, xid=None, code=None, data=None):
10637 if xid != None:
10638 self.xid = xid
10639 else:
10640 self.xid = None
10641 if code != None:
10642 self.code = code
10643 else:
10644 self.code = 0
10645 if data != None:
10646 self.data = data
10647 else:
10648 self.data = ''
10649 return
10650
10651 def pack(self):
10652 packed = []
10653 packed.append(struct.pack("!B", self.version))
10654 packed.append(struct.pack("!B", self.type))
10655 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
10656 packed.append(struct.pack("!L", self.xid))
10657 packed.append(struct.pack("!H", self.err_type))
10658 packed.append(struct.pack("!H", self.code))
10659 packed.append(self.data)
10660 length = sum([len(x) for x in packed])
10661 packed[2] = struct.pack("!H", length)
10662 return ''.join(packed)
10663
10664 @staticmethod
10665 def unpack(reader):
10666 obj = flow_mod_failed_error_msg()
10667 _version = reader.read("!B")[0]
10668 assert(_version == 5)
10669 _type = reader.read("!B")[0]
10670 assert(_type == 1)
10671 _length = reader.read("!H")[0]
10672 orig_reader = reader
10673 reader = orig_reader.slice(_length, 4)
10674 obj.xid = reader.read("!L")[0]
10675 _err_type = reader.read("!H")[0]
10676 assert(_err_type == 5)
10677 obj.code = reader.read("!H")[0]
10678 obj.data = str(reader.read_all())
10679 return obj
10680
10681 def __eq__(self, other):
10682 if type(self) != type(other): return False
10683 if self.xid != other.xid: return False
10684 if self.code != other.code: return False
10685 if self.data != other.data: return False
10686 return True
10687
10688 def pretty_print(self, q):
10689 q.text("flow_mod_failed_error_msg {")
10690 with q.group():
10691 with q.indent(2):
10692 q.breakable()
10693 q.text("xid = ");
10694 if self.xid != None:
10695 q.text("%#x" % self.xid)
10696 else:
10697 q.text('None')
10698 q.text(","); q.breakable()
10699 q.text("code = ");
10700 q.text("%#x" % self.code)
10701 q.text(","); q.breakable()
10702 q.text("data = ");
10703 q.pp(self.data)
10704 q.breakable()
10705 q.text('}')
10706
10707error_msg.subtypes[5] = flow_mod_failed_error_msg
10708
10709class flow_modify(flow_mod):
10710 version = 5
10711 type = 14
10712 _command = 1
10713
10714 def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, importance=None, match=None, instructions=None):
10715 if xid != None:
10716 self.xid = xid
10717 else:
10718 self.xid = None
10719 if cookie != None:
10720 self.cookie = cookie
10721 else:
10722 self.cookie = 0
10723 if cookie_mask != None:
10724 self.cookie_mask = cookie_mask
10725 else:
10726 self.cookie_mask = 0
10727 if table_id != None:
10728 self.table_id = table_id
10729 else:
10730 self.table_id = 0
10731 if idle_timeout != None:
10732 self.idle_timeout = idle_timeout
10733 else:
10734 self.idle_timeout = 0
10735 if hard_timeout != None:
10736 self.hard_timeout = hard_timeout
10737 else:
10738 self.hard_timeout = 0
10739 if priority != None:
10740 self.priority = priority
10741 else:
10742 self.priority = 0
10743 if buffer_id != None:
10744 self.buffer_id = buffer_id
10745 else:
10746 self.buffer_id = 0
10747 if out_port != None:
10748 self.out_port = out_port
10749 else:
10750 self.out_port = 0
10751 if out_group != None:
10752 self.out_group = out_group
10753 else:
10754 self.out_group = 0
10755 if flags != None:
10756 self.flags = flags
10757 else:
10758 self.flags = 0
10759 if importance != None:
10760 self.importance = importance
10761 else:
10762 self.importance = 0
10763 if match != None:
10764 self.match = match
10765 else:
10766 self.match = ofp.match()
10767 if instructions != None:
10768 self.instructions = instructions
10769 else:
10770 self.instructions = []
10771 return
10772
10773 def pack(self):
10774 packed = []
10775 packed.append(struct.pack("!B", self.version))
10776 packed.append(struct.pack("!B", self.type))
10777 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
10778 packed.append(struct.pack("!L", self.xid))
10779 packed.append(struct.pack("!Q", self.cookie))
10780 packed.append(struct.pack("!Q", self.cookie_mask))
10781 packed.append(struct.pack("!B", self.table_id))
10782 packed.append(util.pack_fm_cmd(self._command))
10783 packed.append(struct.pack("!H", self.idle_timeout))
10784 packed.append(struct.pack("!H", self.hard_timeout))
10785 packed.append(struct.pack("!H", self.priority))
10786 packed.append(struct.pack("!L", self.buffer_id))
10787 packed.append(util.pack_port_no(self.out_port))
10788 packed.append(struct.pack("!L", self.out_group))
10789 packed.append(struct.pack("!H", self.flags))
10790 packed.append(struct.pack("!H", self.importance))
10791 packed.append(self.match.pack())
10792 packed.append(loxi.generic_util.pack_list(self.instructions))
10793 length = sum([len(x) for x in packed])
10794 packed[2] = struct.pack("!H", length)
10795 return ''.join(packed)
10796
10797 @staticmethod
10798 def unpack(reader):
10799 obj = flow_modify()
10800 _version = reader.read("!B")[0]
10801 assert(_version == 5)
10802 _type = reader.read("!B")[0]
10803 assert(_type == 14)
10804 _length = reader.read("!H")[0]
10805 orig_reader = reader
10806 reader = orig_reader.slice(_length, 4)
10807 obj.xid = reader.read("!L")[0]
10808 obj.cookie = reader.read("!Q")[0]
10809 obj.cookie_mask = reader.read("!Q")[0]
10810 obj.table_id = reader.read("!B")[0]
10811 __command = util.unpack_fm_cmd(reader)
10812 assert(__command == 1)
10813 obj.idle_timeout = reader.read("!H")[0]
10814 obj.hard_timeout = reader.read("!H")[0]
10815 obj.priority = reader.read("!H")[0]
10816 obj.buffer_id = reader.read("!L")[0]
10817 obj.out_port = util.unpack_port_no(reader)
10818 obj.out_group = reader.read("!L")[0]
10819 obj.flags = reader.read("!H")[0]
10820 obj.importance = reader.read("!H")[0]
10821 obj.match = ofp.match.unpack(reader)
10822 obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
10823 return obj
10824
10825 def __eq__(self, other):
10826 if type(self) != type(other): return False
10827 if self.xid != other.xid: return False
10828 if self.cookie != other.cookie: return False
10829 if self.cookie_mask != other.cookie_mask: return False
10830 if self.table_id != other.table_id: return False
10831 if self.idle_timeout != other.idle_timeout: return False
10832 if self.hard_timeout != other.hard_timeout: return False
10833 if self.priority != other.priority: return False
10834 if self.buffer_id != other.buffer_id: return False
10835 if self.out_port != other.out_port: return False
10836 if self.out_group != other.out_group: return False
10837 if self.flags != other.flags: return False
10838 if self.importance != other.importance: return False
10839 if self.match != other.match: return False
10840 if self.instructions != other.instructions: return False
10841 return True
10842
10843 def pretty_print(self, q):
10844 q.text("flow_modify {")
10845 with q.group():
10846 with q.indent(2):
10847 q.breakable()
10848 q.text("xid = ");
10849 if self.xid != None:
10850 q.text("%#x" % self.xid)
10851 else:
10852 q.text('None')
10853 q.text(","); q.breakable()
10854 q.text("cookie = ");
10855 q.text("%#x" % self.cookie)
10856 q.text(","); q.breakable()
10857 q.text("cookie_mask = ");
10858 q.text("%#x" % self.cookie_mask)
10859 q.text(","); q.breakable()
10860 q.text("table_id = ");
10861 q.text("%#x" % self.table_id)
10862 q.text(","); q.breakable()
10863 q.text("idle_timeout = ");
10864 q.text("%#x" % self.idle_timeout)
10865 q.text(","); q.breakable()
10866 q.text("hard_timeout = ");
10867 q.text("%#x" % self.hard_timeout)
10868 q.text(","); q.breakable()
10869 q.text("priority = ");
10870 q.text("%#x" % self.priority)
10871 q.text(","); q.breakable()
10872 q.text("buffer_id = ");
10873 q.text("%#x" % self.buffer_id)
10874 q.text(","); q.breakable()
10875 q.text("out_port = ");
10876 q.text(util.pretty_port(self.out_port))
10877 q.text(","); q.breakable()
10878 q.text("out_group = ");
10879 q.text("%#x" % self.out_group)
10880 q.text(","); q.breakable()
10881 q.text("flags = ");
10882 q.text("%#x" % self.flags)
10883 q.text(","); q.breakable()
10884 q.text("importance = ");
10885 q.text("%#x" % self.importance)
10886 q.text(","); q.breakable()
10887 q.text("match = ");
10888 q.pp(self.match)
10889 q.text(","); q.breakable()
10890 q.text("instructions = ");
10891 q.pp(self.instructions)
10892 q.breakable()
10893 q.text('}')
10894
10895flow_mod.subtypes[1] = flow_modify
10896
10897class flow_modify_strict(flow_mod):
10898 version = 5
10899 type = 14
10900 _command = 2
10901
10902 def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, importance=None, match=None, instructions=None):
10903 if xid != None:
10904 self.xid = xid
10905 else:
10906 self.xid = None
10907 if cookie != None:
10908 self.cookie = cookie
10909 else:
10910 self.cookie = 0
10911 if cookie_mask != None:
10912 self.cookie_mask = cookie_mask
10913 else:
10914 self.cookie_mask = 0
10915 if table_id != None:
10916 self.table_id = table_id
10917 else:
10918 self.table_id = 0
10919 if idle_timeout != None:
10920 self.idle_timeout = idle_timeout
10921 else:
10922 self.idle_timeout = 0
10923 if hard_timeout != None:
10924 self.hard_timeout = hard_timeout
10925 else:
10926 self.hard_timeout = 0
10927 if priority != None:
10928 self.priority = priority
10929 else:
10930 self.priority = 0
10931 if buffer_id != None:
10932 self.buffer_id = buffer_id
10933 else:
10934 self.buffer_id = 0
10935 if out_port != None:
10936 self.out_port = out_port
10937 else:
10938 self.out_port = 0
10939 if out_group != None:
10940 self.out_group = out_group
10941 else:
10942 self.out_group = 0
10943 if flags != None:
10944 self.flags = flags
10945 else:
10946 self.flags = 0
10947 if importance != None:
10948 self.importance = importance
10949 else:
10950 self.importance = 0
10951 if match != None:
10952 self.match = match
10953 else:
10954 self.match = ofp.match()
10955 if instructions != None:
10956 self.instructions = instructions
10957 else:
10958 self.instructions = []
10959 return
10960
10961 def pack(self):
10962 packed = []
10963 packed.append(struct.pack("!B", self.version))
10964 packed.append(struct.pack("!B", self.type))
10965 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
10966 packed.append(struct.pack("!L", self.xid))
10967 packed.append(struct.pack("!Q", self.cookie))
10968 packed.append(struct.pack("!Q", self.cookie_mask))
10969 packed.append(struct.pack("!B", self.table_id))
10970 packed.append(util.pack_fm_cmd(self._command))
10971 packed.append(struct.pack("!H", self.idle_timeout))
10972 packed.append(struct.pack("!H", self.hard_timeout))
10973 packed.append(struct.pack("!H", self.priority))
10974 packed.append(struct.pack("!L", self.buffer_id))
10975 packed.append(util.pack_port_no(self.out_port))
10976 packed.append(struct.pack("!L", self.out_group))
10977 packed.append(struct.pack("!H", self.flags))
10978 packed.append(struct.pack("!H", self.importance))
10979 packed.append(self.match.pack())
10980 packed.append(loxi.generic_util.pack_list(self.instructions))
10981 length = sum([len(x) for x in packed])
10982 packed[2] = struct.pack("!H", length)
10983 return ''.join(packed)
10984
10985 @staticmethod
10986 def unpack(reader):
10987 obj = flow_modify_strict()
10988 _version = reader.read("!B")[0]
10989 assert(_version == 5)
10990 _type = reader.read("!B")[0]
10991 assert(_type == 14)
10992 _length = reader.read("!H")[0]
10993 orig_reader = reader
10994 reader = orig_reader.slice(_length, 4)
10995 obj.xid = reader.read("!L")[0]
10996 obj.cookie = reader.read("!Q")[0]
10997 obj.cookie_mask = reader.read("!Q")[0]
10998 obj.table_id = reader.read("!B")[0]
10999 __command = util.unpack_fm_cmd(reader)
11000 assert(__command == 2)
11001 obj.idle_timeout = reader.read("!H")[0]
11002 obj.hard_timeout = reader.read("!H")[0]
11003 obj.priority = reader.read("!H")[0]
11004 obj.buffer_id = reader.read("!L")[0]
11005 obj.out_port = util.unpack_port_no(reader)
11006 obj.out_group = reader.read("!L")[0]
11007 obj.flags = reader.read("!H")[0]
11008 obj.importance = reader.read("!H")[0]
11009 obj.match = ofp.match.unpack(reader)
11010 obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
11011 return obj
11012
11013 def __eq__(self, other):
11014 if type(self) != type(other): return False
11015 if self.xid != other.xid: return False
11016 if self.cookie != other.cookie: return False
11017 if self.cookie_mask != other.cookie_mask: return False
11018 if self.table_id != other.table_id: return False
11019 if self.idle_timeout != other.idle_timeout: return False
11020 if self.hard_timeout != other.hard_timeout: return False
11021 if self.priority != other.priority: return False
11022 if self.buffer_id != other.buffer_id: return False
11023 if self.out_port != other.out_port: return False
11024 if self.out_group != other.out_group: return False
11025 if self.flags != other.flags: return False
11026 if self.importance != other.importance: return False
11027 if self.match != other.match: return False
11028 if self.instructions != other.instructions: return False
11029 return True
11030
11031 def pretty_print(self, q):
11032 q.text("flow_modify_strict {")
11033 with q.group():
11034 with q.indent(2):
11035 q.breakable()
11036 q.text("xid = ");
11037 if self.xid != None:
11038 q.text("%#x" % self.xid)
11039 else:
11040 q.text('None')
11041 q.text(","); q.breakable()
11042 q.text("cookie = ");
11043 q.text("%#x" % self.cookie)
11044 q.text(","); q.breakable()
11045 q.text("cookie_mask = ");
11046 q.text("%#x" % self.cookie_mask)
11047 q.text(","); q.breakable()
11048 q.text("table_id = ");
11049 q.text("%#x" % self.table_id)
11050 q.text(","); q.breakable()
11051 q.text("idle_timeout = ");
11052 q.text("%#x" % self.idle_timeout)
11053 q.text(","); q.breakable()
11054 q.text("hard_timeout = ");
11055 q.text("%#x" % self.hard_timeout)
11056 q.text(","); q.breakable()
11057 q.text("priority = ");
11058 q.text("%#x" % self.priority)
11059 q.text(","); q.breakable()
11060 q.text("buffer_id = ");
11061 q.text("%#x" % self.buffer_id)
11062 q.text(","); q.breakable()
11063 q.text("out_port = ");
11064 q.text(util.pretty_port(self.out_port))
11065 q.text(","); q.breakable()
11066 q.text("out_group = ");
11067 q.text("%#x" % self.out_group)
11068 q.text(","); q.breakable()
11069 q.text("flags = ");
11070 q.text("%#x" % self.flags)
11071 q.text(","); q.breakable()
11072 q.text("importance = ");
11073 q.text("%#x" % self.importance)
11074 q.text(","); q.breakable()
11075 q.text("match = ");
11076 q.pp(self.match)
11077 q.text(","); q.breakable()
11078 q.text("instructions = ");
11079 q.pp(self.instructions)
11080 q.breakable()
11081 q.text('}')
11082
11083flow_mod.subtypes[2] = flow_modify_strict
11084
11085class flow_monitor_failed_error_msg(error_msg):
11086 version = 5
11087 type = 1
11088 err_type = 16
11089
11090 def __init__(self, xid=None, code=None, data=None):
11091 if xid != None:
11092 self.xid = xid
11093 else:
11094 self.xid = None
11095 if code != None:
11096 self.code = code
11097 else:
11098 self.code = 0
11099 if data != None:
11100 self.data = data
11101 else:
11102 self.data = ''
11103 return
11104
11105 def pack(self):
11106 packed = []
11107 packed.append(struct.pack("!B", self.version))
11108 packed.append(struct.pack("!B", self.type))
11109 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
11110 packed.append(struct.pack("!L", self.xid))
11111 packed.append(struct.pack("!H", self.err_type))
11112 packed.append(struct.pack("!H", self.code))
11113 packed.append(self.data)
11114 length = sum([len(x) for x in packed])
11115 packed[2] = struct.pack("!H", length)
11116 return ''.join(packed)
11117
11118 @staticmethod
11119 def unpack(reader):
11120 obj = flow_monitor_failed_error_msg()
11121 _version = reader.read("!B")[0]
11122 assert(_version == 5)
11123 _type = reader.read("!B")[0]
11124 assert(_type == 1)
11125 _length = reader.read("!H")[0]
11126 orig_reader = reader
11127 reader = orig_reader.slice(_length, 4)
11128 obj.xid = reader.read("!L")[0]
11129 _err_type = reader.read("!H")[0]
11130 assert(_err_type == 16)
11131 obj.code = reader.read("!H")[0]
11132 obj.data = str(reader.read_all())
11133 return obj
11134
11135 def __eq__(self, other):
11136 if type(self) != type(other): return False
11137 if self.xid != other.xid: return False
11138 if self.code != other.code: return False
11139 if self.data != other.data: return False
11140 return True
11141
11142 def pretty_print(self, q):
11143 q.text("flow_monitor_failed_error_msg {")
11144 with q.group():
11145 with q.indent(2):
11146 q.breakable()
11147 q.text("xid = ");
11148 if self.xid != None:
11149 q.text("%#x" % self.xid)
11150 else:
11151 q.text('None')
11152 q.text(","); q.breakable()
11153 q.text("code = ");
11154 q.text("%#x" % self.code)
11155 q.text(","); q.breakable()
11156 q.text("data = ");
11157 q.pp(self.data)
11158 q.breakable()
11159 q.text('}')
11160
11161error_msg.subtypes[16] = flow_monitor_failed_error_msg
11162
11163class flow_removed(message):
11164 version = 5
11165 type = 11
11166
11167 def __init__(self, xid=None, cookie=None, priority=None, reason=None, table_id=None, duration_sec=None, duration_nsec=None, idle_timeout=None, hard_timeout=None, packet_count=None, byte_count=None, match=None):
11168 if xid != None:
11169 self.xid = xid
11170 else:
11171 self.xid = None
11172 if cookie != None:
11173 self.cookie = cookie
11174 else:
11175 self.cookie = 0
11176 if priority != None:
11177 self.priority = priority
11178 else:
11179 self.priority = 0
11180 if reason != None:
11181 self.reason = reason
11182 else:
11183 self.reason = 0
11184 if table_id != None:
11185 self.table_id = table_id
11186 else:
11187 self.table_id = 0
11188 if duration_sec != None:
11189 self.duration_sec = duration_sec
11190 else:
11191 self.duration_sec = 0
11192 if duration_nsec != None:
11193 self.duration_nsec = duration_nsec
11194 else:
11195 self.duration_nsec = 0
11196 if idle_timeout != None:
11197 self.idle_timeout = idle_timeout
11198 else:
11199 self.idle_timeout = 0
11200 if hard_timeout != None:
11201 self.hard_timeout = hard_timeout
11202 else:
11203 self.hard_timeout = 0
11204 if packet_count != None:
11205 self.packet_count = packet_count
11206 else:
11207 self.packet_count = 0
11208 if byte_count != None:
11209 self.byte_count = byte_count
11210 else:
11211 self.byte_count = 0
11212 if match != None:
11213 self.match = match
11214 else:
11215 self.match = ofp.match()
11216 return
11217
11218 def pack(self):
11219 packed = []
11220 packed.append(struct.pack("!B", self.version))
11221 packed.append(struct.pack("!B", self.type))
11222 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
11223 packed.append(struct.pack("!L", self.xid))
11224 packed.append(struct.pack("!Q", self.cookie))
11225 packed.append(struct.pack("!H", self.priority))
11226 packed.append(struct.pack("!B", self.reason))
11227 packed.append(struct.pack("!B", self.table_id))
11228 packed.append(struct.pack("!L", self.duration_sec))
11229 packed.append(struct.pack("!L", self.duration_nsec))
11230 packed.append(struct.pack("!H", self.idle_timeout))
11231 packed.append(struct.pack("!H", self.hard_timeout))
11232 packed.append(struct.pack("!Q", self.packet_count))
11233 packed.append(struct.pack("!Q", self.byte_count))
11234 packed.append(self.match.pack())
11235 length = sum([len(x) for x in packed])
11236 packed[2] = struct.pack("!H", length)
11237 return ''.join(packed)
11238
11239 @staticmethod
11240 def unpack(reader):
11241 obj = flow_removed()
11242 _version = reader.read("!B")[0]
11243 assert(_version == 5)
11244 _type = reader.read("!B")[0]
11245 assert(_type == 11)
11246 _length = reader.read("!H")[0]
11247 orig_reader = reader
11248 reader = orig_reader.slice(_length, 4)
11249 obj.xid = reader.read("!L")[0]
11250 obj.cookie = reader.read("!Q")[0]
11251 obj.priority = reader.read("!H")[0]
11252 obj.reason = reader.read("!B")[0]
11253 obj.table_id = reader.read("!B")[0]
11254 obj.duration_sec = reader.read("!L")[0]
11255 obj.duration_nsec = reader.read("!L")[0]
11256 obj.idle_timeout = reader.read("!H")[0]
11257 obj.hard_timeout = reader.read("!H")[0]
11258 obj.packet_count = reader.read("!Q")[0]
11259 obj.byte_count = reader.read("!Q")[0]
11260 obj.match = ofp.match.unpack(reader)
11261 return obj
11262
11263 def __eq__(self, other):
11264 if type(self) != type(other): return False
11265 if self.xid != other.xid: return False
11266 if self.cookie != other.cookie: return False
11267 if self.priority != other.priority: return False
11268 if self.reason != other.reason: return False
11269 if self.table_id != other.table_id: return False
11270 if self.duration_sec != other.duration_sec: return False
11271 if self.duration_nsec != other.duration_nsec: return False
11272 if self.idle_timeout != other.idle_timeout: return False
11273 if self.hard_timeout != other.hard_timeout: return False
11274 if self.packet_count != other.packet_count: return False
11275 if self.byte_count != other.byte_count: return False
11276 if self.match != other.match: return False
11277 return True
11278
11279 def pretty_print(self, q):
11280 q.text("flow_removed {")
11281 with q.group():
11282 with q.indent(2):
11283 q.breakable()
11284 q.text("xid = ");
11285 if self.xid != None:
11286 q.text("%#x" % self.xid)
11287 else:
11288 q.text('None')
11289 q.text(","); q.breakable()
11290 q.text("cookie = ");
11291 q.text("%#x" % self.cookie)
11292 q.text(","); q.breakable()
11293 q.text("priority = ");
11294 q.text("%#x" % self.priority)
11295 q.text(","); q.breakable()
11296 q.text("reason = ");
11297 q.text("%#x" % self.reason)
11298 q.text(","); q.breakable()
11299 q.text("table_id = ");
11300 q.text("%#x" % self.table_id)
11301 q.text(","); q.breakable()
11302 q.text("duration_sec = ");
11303 q.text("%#x" % self.duration_sec)
11304 q.text(","); q.breakable()
11305 q.text("duration_nsec = ");
11306 q.text("%#x" % self.duration_nsec)
11307 q.text(","); q.breakable()
11308 q.text("idle_timeout = ");
11309 q.text("%#x" % self.idle_timeout)
11310 q.text(","); q.breakable()
11311 q.text("hard_timeout = ");
11312 q.text("%#x" % self.hard_timeout)
11313 q.text(","); q.breakable()
11314 q.text("packet_count = ");
11315 q.text("%#x" % self.packet_count)
11316 q.text(","); q.breakable()
11317 q.text("byte_count = ");
11318 q.text("%#x" % self.byte_count)
11319 q.text(","); q.breakable()
11320 q.text("match = ");
11321 q.pp(self.match)
11322 q.breakable()
11323 q.text('}')
11324
11325message.subtypes[11] = flow_removed
11326
11327class flow_stats_reply(stats_reply):
11328 version = 5
11329 type = 19
11330 stats_type = 1
11331
11332 def __init__(self, xid=None, flags=None, entries=None):
11333 if xid != None:
11334 self.xid = xid
11335 else:
11336 self.xid = None
11337 if flags != None:
11338 self.flags = flags
11339 else:
11340 self.flags = 0
11341 if entries != None:
11342 self.entries = entries
11343 else:
11344 self.entries = []
11345 return
11346
11347 def pack(self):
11348 packed = []
11349 packed.append(struct.pack("!B", self.version))
11350 packed.append(struct.pack("!B", self.type))
11351 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
11352 packed.append(struct.pack("!L", self.xid))
11353 packed.append(struct.pack("!H", self.stats_type))
11354 packed.append(struct.pack("!H", self.flags))
11355 packed.append('\x00' * 4)
11356 packed.append(loxi.generic_util.pack_list(self.entries))
11357 length = sum([len(x) for x in packed])
11358 packed[2] = struct.pack("!H", length)
11359 return ''.join(packed)
11360
11361 @staticmethod
11362 def unpack(reader):
11363 obj = flow_stats_reply()
11364 _version = reader.read("!B")[0]
11365 assert(_version == 5)
11366 _type = reader.read("!B")[0]
11367 assert(_type == 19)
11368 _length = reader.read("!H")[0]
11369 orig_reader = reader
11370 reader = orig_reader.slice(_length, 4)
11371 obj.xid = reader.read("!L")[0]
11372 _stats_type = reader.read("!H")[0]
11373 assert(_stats_type == 1)
11374 obj.flags = reader.read("!H")[0]
11375 reader.skip(4)
11376 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.flow_stats_entry.unpack)
11377 return obj
11378
11379 def __eq__(self, other):
11380 if type(self) != type(other): return False
11381 if self.xid != other.xid: return False
11382 if self.flags != other.flags: return False
11383 if self.entries != other.entries: return False
11384 return True
11385
11386 def pretty_print(self, q):
11387 q.text("flow_stats_reply {")
11388 with q.group():
11389 with q.indent(2):
11390 q.breakable()
11391 q.text("xid = ");
11392 if self.xid != None:
11393 q.text("%#x" % self.xid)
11394 else:
11395 q.text('None')
11396 q.text(","); q.breakable()
11397 q.text("flags = ");
11398 q.text("%#x" % self.flags)
11399 q.text(","); q.breakable()
11400 q.text("entries = ");
11401 q.pp(self.entries)
11402 q.breakable()
11403 q.text('}')
11404
11405stats_reply.subtypes[1] = flow_stats_reply
11406
11407class flow_stats_request(stats_request):
11408 version = 5
11409 type = 18
11410 stats_type = 1
11411
11412 def __init__(self, xid=None, flags=None, table_id=None, out_port=None, out_group=None, cookie=None, cookie_mask=None, match=None):
11413 if xid != None:
11414 self.xid = xid
11415 else:
11416 self.xid = None
11417 if flags != None:
11418 self.flags = flags
11419 else:
11420 self.flags = 0
11421 if table_id != None:
11422 self.table_id = table_id
11423 else:
11424 self.table_id = 0
11425 if out_port != None:
11426 self.out_port = out_port
11427 else:
11428 self.out_port = 0
11429 if out_group != None:
11430 self.out_group = out_group
11431 else:
11432 self.out_group = 0
11433 if cookie != None:
11434 self.cookie = cookie
11435 else:
11436 self.cookie = 0
11437 if cookie_mask != None:
11438 self.cookie_mask = cookie_mask
11439 else:
11440 self.cookie_mask = 0
11441 if match != None:
11442 self.match = match
11443 else:
11444 self.match = ofp.match()
11445 return
11446
11447 def pack(self):
11448 packed = []
11449 packed.append(struct.pack("!B", self.version))
11450 packed.append(struct.pack("!B", self.type))
11451 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
11452 packed.append(struct.pack("!L", self.xid))
11453 packed.append(struct.pack("!H", self.stats_type))
11454 packed.append(struct.pack("!H", self.flags))
11455 packed.append('\x00' * 4)
11456 packed.append(struct.pack("!B", self.table_id))
11457 packed.append('\x00' * 3)
11458 packed.append(util.pack_port_no(self.out_port))
11459 packed.append(struct.pack("!L", self.out_group))
11460 packed.append('\x00' * 4)
11461 packed.append(struct.pack("!Q", self.cookie))
11462 packed.append(struct.pack("!Q", self.cookie_mask))
11463 packed.append(self.match.pack())
11464 length = sum([len(x) for x in packed])
11465 packed[2] = struct.pack("!H", length)
11466 return ''.join(packed)
11467
11468 @staticmethod
11469 def unpack(reader):
11470 obj = flow_stats_request()
11471 _version = reader.read("!B")[0]
11472 assert(_version == 5)
11473 _type = reader.read("!B")[0]
11474 assert(_type == 18)
11475 _length = reader.read("!H")[0]
11476 orig_reader = reader
11477 reader = orig_reader.slice(_length, 4)
11478 obj.xid = reader.read("!L")[0]
11479 _stats_type = reader.read("!H")[0]
11480 assert(_stats_type == 1)
11481 obj.flags = reader.read("!H")[0]
11482 reader.skip(4)
11483 obj.table_id = reader.read("!B")[0]
11484 reader.skip(3)
11485 obj.out_port = util.unpack_port_no(reader)
11486 obj.out_group = reader.read("!L")[0]
11487 reader.skip(4)
11488 obj.cookie = reader.read("!Q")[0]
11489 obj.cookie_mask = reader.read("!Q")[0]
11490 obj.match = ofp.match.unpack(reader)
11491 return obj
11492
11493 def __eq__(self, other):
11494 if type(self) != type(other): return False
11495 if self.xid != other.xid: return False
11496 if self.flags != other.flags: return False
11497 if self.table_id != other.table_id: return False
11498 if self.out_port != other.out_port: return False
11499 if self.out_group != other.out_group: return False
11500 if self.cookie != other.cookie: return False
11501 if self.cookie_mask != other.cookie_mask: return False
11502 if self.match != other.match: return False
11503 return True
11504
11505 def pretty_print(self, q):
11506 q.text("flow_stats_request {")
11507 with q.group():
11508 with q.indent(2):
11509 q.breakable()
11510 q.text("xid = ");
11511 if self.xid != None:
11512 q.text("%#x" % self.xid)
11513 else:
11514 q.text('None')
11515 q.text(","); q.breakable()
11516 q.text("flags = ");
11517 q.text("%#x" % self.flags)
11518 q.text(","); q.breakable()
11519 q.text("table_id = ");
11520 q.text("%#x" % self.table_id)
11521 q.text(","); q.breakable()
11522 q.text("out_port = ");
11523 q.text(util.pretty_port(self.out_port))
11524 q.text(","); q.breakable()
11525 q.text("out_group = ");
11526 q.text("%#x" % self.out_group)
11527 q.text(","); q.breakable()
11528 q.text("cookie = ");
11529 q.text("%#x" % self.cookie)
11530 q.text(","); q.breakable()
11531 q.text("cookie_mask = ");
11532 q.text("%#x" % self.cookie_mask)
11533 q.text(","); q.breakable()
11534 q.text("match = ");
11535 q.pp(self.match)
11536 q.breakable()
11537 q.text('}')
11538
11539stats_request.subtypes[1] = flow_stats_request
11540
11541class get_config_reply(message):
11542 version = 5
11543 type = 8
11544
11545 def __init__(self, xid=None, flags=None, miss_send_len=None):
11546 if xid != None:
11547 self.xid = xid
11548 else:
11549 self.xid = None
11550 if flags != None:
11551 self.flags = flags
11552 else:
11553 self.flags = 0
11554 if miss_send_len != None:
11555 self.miss_send_len = miss_send_len
11556 else:
11557 self.miss_send_len = 0
11558 return
11559
11560 def pack(self):
11561 packed = []
11562 packed.append(struct.pack("!B", self.version))
11563 packed.append(struct.pack("!B", self.type))
11564 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
11565 packed.append(struct.pack("!L", self.xid))
11566 packed.append(struct.pack("!H", self.flags))
11567 packed.append(struct.pack("!H", self.miss_send_len))
11568 length = sum([len(x) for x in packed])
11569 packed[2] = struct.pack("!H", length)
11570 return ''.join(packed)
11571
11572 @staticmethod
11573 def unpack(reader):
11574 obj = get_config_reply()
11575 _version = reader.read("!B")[0]
11576 assert(_version == 5)
11577 _type = reader.read("!B")[0]
11578 assert(_type == 8)
11579 _length = reader.read("!H")[0]
11580 orig_reader = reader
11581 reader = orig_reader.slice(_length, 4)
11582 obj.xid = reader.read("!L")[0]
11583 obj.flags = reader.read("!H")[0]
11584 obj.miss_send_len = reader.read("!H")[0]
11585 return obj
11586
11587 def __eq__(self, other):
11588 if type(self) != type(other): return False
11589 if self.xid != other.xid: return False
11590 if self.flags != other.flags: return False
11591 if self.miss_send_len != other.miss_send_len: return False
11592 return True
11593
11594 def pretty_print(self, q):
11595 q.text("get_config_reply {")
11596 with q.group():
11597 with q.indent(2):
11598 q.breakable()
11599 q.text("xid = ");
11600 if self.xid != None:
11601 q.text("%#x" % self.xid)
11602 else:
11603 q.text('None')
11604 q.text(","); q.breakable()
11605 q.text("flags = ");
11606 q.text("%#x" % self.flags)
11607 q.text(","); q.breakable()
11608 q.text("miss_send_len = ");
11609 q.text("%#x" % self.miss_send_len)
11610 q.breakable()
11611 q.text('}')
11612
11613message.subtypes[8] = get_config_reply
11614
11615class get_config_request(message):
11616 version = 5
11617 type = 7
11618
11619 def __init__(self, xid=None):
11620 if xid != None:
11621 self.xid = xid
11622 else:
11623 self.xid = None
11624 return
11625
11626 def pack(self):
11627 packed = []
11628 packed.append(struct.pack("!B", self.version))
11629 packed.append(struct.pack("!B", self.type))
11630 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
11631 packed.append(struct.pack("!L", self.xid))
11632 length = sum([len(x) for x in packed])
11633 packed[2] = struct.pack("!H", length)
11634 return ''.join(packed)
11635
11636 @staticmethod
11637 def unpack(reader):
11638 obj = get_config_request()
11639 _version = reader.read("!B")[0]
11640 assert(_version == 5)
11641 _type = reader.read("!B")[0]
11642 assert(_type == 7)
11643 _length = reader.read("!H")[0]
11644 orig_reader = reader
11645 reader = orig_reader.slice(_length, 4)
11646 obj.xid = reader.read("!L")[0]
11647 return obj
11648
11649 def __eq__(self, other):
11650 if type(self) != type(other): return False
11651 if self.xid != other.xid: return False
11652 return True
11653
11654 def pretty_print(self, q):
11655 q.text("get_config_request {")
11656 with q.group():
11657 with q.indent(2):
11658 q.breakable()
11659 q.text("xid = ");
11660 if self.xid != None:
11661 q.text("%#x" % self.xid)
11662 else:
11663 q.text('None')
11664 q.breakable()
11665 q.text('}')
11666
11667message.subtypes[7] = get_config_request
11668
11669class group_mod(message):
11670 subtypes = {}
11671
11672 version = 5
11673 type = 15
11674
11675 def __init__(self, xid=None, command=None, group_type=None, group_id=None, buckets=None):
11676 if xid != None:
11677 self.xid = xid
11678 else:
11679 self.xid = None
11680 if command != None:
11681 self.command = command
11682 else:
11683 self.command = 0
11684 if group_type != None:
11685 self.group_type = group_type
11686 else:
11687 self.group_type = 0
11688 if group_id != None:
11689 self.group_id = group_id
11690 else:
11691 self.group_id = 0
11692 if buckets != None:
11693 self.buckets = buckets
11694 else:
11695 self.buckets = []
11696 return
11697
11698 def pack(self):
11699 packed = []
11700 packed.append(struct.pack("!B", self.version))
11701 packed.append(struct.pack("!B", self.type))
11702 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
11703 packed.append(struct.pack("!L", self.xid))
11704 packed.append(struct.pack("!H", self.command))
11705 packed.append(struct.pack("!B", self.group_type))
11706 packed.append('\x00' * 1)
11707 packed.append(struct.pack("!L", self.group_id))
11708 packed.append(loxi.generic_util.pack_list(self.buckets))
11709 length = sum([len(x) for x in packed])
11710 packed[2] = struct.pack("!H", length)
11711 return ''.join(packed)
11712
11713 @staticmethod
11714 def unpack(reader):
11715 subtype, = reader.peek('!H', 8)
11716 subclass = group_mod.subtypes.get(subtype)
11717 if subclass:
11718 return subclass.unpack(reader)
11719
11720 obj = group_mod()
11721 _version = reader.read("!B")[0]
11722 assert(_version == 5)
11723 _type = reader.read("!B")[0]
11724 assert(_type == 15)
11725 _length = reader.read("!H")[0]
11726 orig_reader = reader
11727 reader = orig_reader.slice(_length, 4)
11728 obj.xid = reader.read("!L")[0]
11729 obj.command = reader.read("!H")[0]
11730 obj.group_type = reader.read("!B")[0]
11731 reader.skip(1)
11732 obj.group_id = reader.read("!L")[0]
11733 obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
11734 return obj
11735
11736 def __eq__(self, other):
11737 if type(self) != type(other): return False
11738 if self.xid != other.xid: return False
11739 if self.command != other.command: return False
11740 if self.group_type != other.group_type: return False
11741 if self.group_id != other.group_id: return False
11742 if self.buckets != other.buckets: return False
11743 return True
11744
11745 def pretty_print(self, q):
11746 q.text("group_mod {")
11747 with q.group():
11748 with q.indent(2):
11749 q.breakable()
11750 q.text("xid = ");
11751 if self.xid != None:
11752 q.text("%#x" % self.xid)
11753 else:
11754 q.text('None')
11755 q.text(","); q.breakable()
11756 q.text("group_type = ");
11757 q.text("%#x" % self.group_type)
11758 q.text(","); q.breakable()
11759 q.text("group_id = ");
11760 q.text("%#x" % self.group_id)
11761 q.text(","); q.breakable()
11762 q.text("buckets = ");
11763 q.pp(self.buckets)
11764 q.breakable()
11765 q.text('}')
11766
11767message.subtypes[15] = group_mod
11768
11769class group_add(group_mod):
11770 version = 5
11771 type = 15
11772 command = 0
11773
11774 def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
11775 if xid != None:
11776 self.xid = xid
11777 else:
11778 self.xid = None
11779 if group_type != None:
11780 self.group_type = group_type
11781 else:
11782 self.group_type = 0
11783 if group_id != None:
11784 self.group_id = group_id
11785 else:
11786 self.group_id = 0
11787 if buckets != None:
11788 self.buckets = buckets
11789 else:
11790 self.buckets = []
11791 return
11792
11793 def pack(self):
11794 packed = []
11795 packed.append(struct.pack("!B", self.version))
11796 packed.append(struct.pack("!B", self.type))
11797 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
11798 packed.append(struct.pack("!L", self.xid))
11799 packed.append(struct.pack("!H", self.command))
11800 packed.append(struct.pack("!B", self.group_type))
11801 packed.append('\x00' * 1)
11802 packed.append(struct.pack("!L", self.group_id))
11803 packed.append(loxi.generic_util.pack_list(self.buckets))
11804 length = sum([len(x) for x in packed])
11805 packed[2] = struct.pack("!H", length)
11806 return ''.join(packed)
11807
11808 @staticmethod
11809 def unpack(reader):
11810 obj = group_add()
11811 _version = reader.read("!B")[0]
11812 assert(_version == 5)
11813 _type = reader.read("!B")[0]
11814 assert(_type == 15)
11815 _length = reader.read("!H")[0]
11816 orig_reader = reader
11817 reader = orig_reader.slice(_length, 4)
11818 obj.xid = reader.read("!L")[0]
11819 _command = reader.read("!H")[0]
11820 assert(_command == 0)
11821 obj.group_type = reader.read("!B")[0]
11822 reader.skip(1)
11823 obj.group_id = reader.read("!L")[0]
11824 obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
11825 return obj
11826
11827 def __eq__(self, other):
11828 if type(self) != type(other): return False
11829 if self.xid != other.xid: return False
11830 if self.group_type != other.group_type: return False
11831 if self.group_id != other.group_id: return False
11832 if self.buckets != other.buckets: return False
11833 return True
11834
11835 def pretty_print(self, q):
11836 q.text("group_add {")
11837 with q.group():
11838 with q.indent(2):
11839 q.breakable()
11840 q.text("xid = ");
11841 if self.xid != None:
11842 q.text("%#x" % self.xid)
11843 else:
11844 q.text('None')
11845 q.text(","); q.breakable()
11846 q.text("group_type = ");
11847 q.text("%#x" % self.group_type)
11848 q.text(","); q.breakable()
11849 q.text("group_id = ");
11850 q.text("%#x" % self.group_id)
11851 q.text(","); q.breakable()
11852 q.text("buckets = ");
11853 q.pp(self.buckets)
11854 q.breakable()
11855 q.text('}')
11856
11857group_mod.subtypes[0] = group_add
11858
11859class group_delete(group_mod):
11860 version = 5
11861 type = 15
11862 command = 2
11863
11864 def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
11865 if xid != None:
11866 self.xid = xid
11867 else:
11868 self.xid = None
11869 if group_type != None:
11870 self.group_type = group_type
11871 else:
11872 self.group_type = 0
11873 if group_id != None:
11874 self.group_id = group_id
11875 else:
11876 self.group_id = 0
11877 if buckets != None:
11878 self.buckets = buckets
11879 else:
11880 self.buckets = []
11881 return
11882
11883 def pack(self):
11884 packed = []
11885 packed.append(struct.pack("!B", self.version))
11886 packed.append(struct.pack("!B", self.type))
11887 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
11888 packed.append(struct.pack("!L", self.xid))
11889 packed.append(struct.pack("!H", self.command))
11890 packed.append(struct.pack("!B", self.group_type))
11891 packed.append('\x00' * 1)
11892 packed.append(struct.pack("!L", self.group_id))
11893 packed.append(loxi.generic_util.pack_list(self.buckets))
11894 length = sum([len(x) for x in packed])
11895 packed[2] = struct.pack("!H", length)
11896 return ''.join(packed)
11897
11898 @staticmethod
11899 def unpack(reader):
11900 obj = group_delete()
11901 _version = reader.read("!B")[0]
11902 assert(_version == 5)
11903 _type = reader.read("!B")[0]
11904 assert(_type == 15)
11905 _length = reader.read("!H")[0]
11906 orig_reader = reader
11907 reader = orig_reader.slice(_length, 4)
11908 obj.xid = reader.read("!L")[0]
11909 _command = reader.read("!H")[0]
11910 assert(_command == 2)
11911 obj.group_type = reader.read("!B")[0]
11912 reader.skip(1)
11913 obj.group_id = reader.read("!L")[0]
11914 obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
11915 return obj
11916
11917 def __eq__(self, other):
11918 if type(self) != type(other): return False
11919 if self.xid != other.xid: return False
11920 if self.group_type != other.group_type: return False
11921 if self.group_id != other.group_id: return False
11922 if self.buckets != other.buckets: return False
11923 return True
11924
11925 def pretty_print(self, q):
11926 q.text("group_delete {")
11927 with q.group():
11928 with q.indent(2):
11929 q.breakable()
11930 q.text("xid = ");
11931 if self.xid != None:
11932 q.text("%#x" % self.xid)
11933 else:
11934 q.text('None')
11935 q.text(","); q.breakable()
11936 q.text("group_type = ");
11937 q.text("%#x" % self.group_type)
11938 q.text(","); q.breakable()
11939 q.text("group_id = ");
11940 q.text("%#x" % self.group_id)
11941 q.text(","); q.breakable()
11942 q.text("buckets = ");
11943 q.pp(self.buckets)
11944 q.breakable()
11945 q.text('}')
11946
11947group_mod.subtypes[2] = group_delete
11948
11949class group_desc_stats_reply(stats_reply):
11950 version = 5
11951 type = 19
11952 stats_type = 7
11953
11954 def __init__(self, xid=None, flags=None, entries=None):
11955 if xid != None:
11956 self.xid = xid
11957 else:
11958 self.xid = None
11959 if flags != None:
11960 self.flags = flags
11961 else:
11962 self.flags = 0
11963 if entries != None:
11964 self.entries = entries
11965 else:
11966 self.entries = []
11967 return
11968
11969 def pack(self):
11970 packed = []
11971 packed.append(struct.pack("!B", self.version))
11972 packed.append(struct.pack("!B", self.type))
11973 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
11974 packed.append(struct.pack("!L", self.xid))
11975 packed.append(struct.pack("!H", self.stats_type))
11976 packed.append(struct.pack("!H", self.flags))
11977 packed.append('\x00' * 4)
11978 packed.append(loxi.generic_util.pack_list(self.entries))
11979 length = sum([len(x) for x in packed])
11980 packed[2] = struct.pack("!H", length)
11981 return ''.join(packed)
11982
11983 @staticmethod
11984 def unpack(reader):
11985 obj = group_desc_stats_reply()
11986 _version = reader.read("!B")[0]
11987 assert(_version == 5)
11988 _type = reader.read("!B")[0]
11989 assert(_type == 19)
11990 _length = reader.read("!H")[0]
11991 orig_reader = reader
11992 reader = orig_reader.slice(_length, 4)
11993 obj.xid = reader.read("!L")[0]
11994 _stats_type = reader.read("!H")[0]
11995 assert(_stats_type == 7)
11996 obj.flags = reader.read("!H")[0]
11997 reader.skip(4)
11998 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.group_desc_stats_entry.unpack)
11999 return obj
12000
12001 def __eq__(self, other):
12002 if type(self) != type(other): return False
12003 if self.xid != other.xid: return False
12004 if self.flags != other.flags: return False
12005 if self.entries != other.entries: return False
12006 return True
12007
12008 def pretty_print(self, q):
12009 q.text("group_desc_stats_reply {")
12010 with q.group():
12011 with q.indent(2):
12012 q.breakable()
12013 q.text("xid = ");
12014 if self.xid != None:
12015 q.text("%#x" % self.xid)
12016 else:
12017 q.text('None')
12018 q.text(","); q.breakable()
12019 q.text("flags = ");
12020 q.text("%#x" % self.flags)
12021 q.text(","); q.breakable()
12022 q.text("entries = ");
12023 q.pp(self.entries)
12024 q.breakable()
12025 q.text('}')
12026
12027stats_reply.subtypes[7] = group_desc_stats_reply
12028
12029class group_desc_stats_request(stats_request):
12030 version = 5
12031 type = 18
12032 stats_type = 7
12033
12034 def __init__(self, xid=None, flags=None):
12035 if xid != None:
12036 self.xid = xid
12037 else:
12038 self.xid = None
12039 if flags != None:
12040 self.flags = flags
12041 else:
12042 self.flags = 0
12043 return
12044
12045 def pack(self):
12046 packed = []
12047 packed.append(struct.pack("!B", self.version))
12048 packed.append(struct.pack("!B", self.type))
12049 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
12050 packed.append(struct.pack("!L", self.xid))
12051 packed.append(struct.pack("!H", self.stats_type))
12052 packed.append(struct.pack("!H", self.flags))
12053 packed.append('\x00' * 4)
12054 length = sum([len(x) for x in packed])
12055 packed[2] = struct.pack("!H", length)
12056 return ''.join(packed)
12057
12058 @staticmethod
12059 def unpack(reader):
12060 obj = group_desc_stats_request()
12061 _version = reader.read("!B")[0]
12062 assert(_version == 5)
12063 _type = reader.read("!B")[0]
12064 assert(_type == 18)
12065 _length = reader.read("!H")[0]
12066 orig_reader = reader
12067 reader = orig_reader.slice(_length, 4)
12068 obj.xid = reader.read("!L")[0]
12069 _stats_type = reader.read("!H")[0]
12070 assert(_stats_type == 7)
12071 obj.flags = reader.read("!H")[0]
12072 reader.skip(4)
12073 return obj
12074
12075 def __eq__(self, other):
12076 if type(self) != type(other): return False
12077 if self.xid != other.xid: return False
12078 if self.flags != other.flags: return False
12079 return True
12080
12081 def pretty_print(self, q):
12082 q.text("group_desc_stats_request {")
12083 with q.group():
12084 with q.indent(2):
12085 q.breakable()
12086 q.text("xid = ");
12087 if self.xid != None:
12088 q.text("%#x" % self.xid)
12089 else:
12090 q.text('None')
12091 q.text(","); q.breakable()
12092 q.text("flags = ");
12093 q.text("%#x" % self.flags)
12094 q.breakable()
12095 q.text('}')
12096
12097stats_request.subtypes[7] = group_desc_stats_request
12098
12099class group_features_stats_reply(stats_reply):
12100 version = 5
12101 type = 19
12102 stats_type = 8
12103
12104 def __init__(self, xid=None, flags=None, types=None, capabilities=None, max_groups_all=None, max_groups_select=None, max_groups_indirect=None, max_groups_ff=None, actions_all=None, actions_select=None, actions_indirect=None, actions_ff=None):
12105 if xid != None:
12106 self.xid = xid
12107 else:
12108 self.xid = None
12109 if flags != None:
12110 self.flags = flags
12111 else:
12112 self.flags = 0
12113 if types != None:
12114 self.types = types
12115 else:
12116 self.types = 0
12117 if capabilities != None:
12118 self.capabilities = capabilities
12119 else:
12120 self.capabilities = 0
12121 if max_groups_all != None:
12122 self.max_groups_all = max_groups_all
12123 else:
12124 self.max_groups_all = 0
12125 if max_groups_select != None:
12126 self.max_groups_select = max_groups_select
12127 else:
12128 self.max_groups_select = 0
12129 if max_groups_indirect != None:
12130 self.max_groups_indirect = max_groups_indirect
12131 else:
12132 self.max_groups_indirect = 0
12133 if max_groups_ff != None:
12134 self.max_groups_ff = max_groups_ff
12135 else:
12136 self.max_groups_ff = 0
12137 if actions_all != None:
12138 self.actions_all = actions_all
12139 else:
12140 self.actions_all = 0
12141 if actions_select != None:
12142 self.actions_select = actions_select
12143 else:
12144 self.actions_select = 0
12145 if actions_indirect != None:
12146 self.actions_indirect = actions_indirect
12147 else:
12148 self.actions_indirect = 0
12149 if actions_ff != None:
12150 self.actions_ff = actions_ff
12151 else:
12152 self.actions_ff = 0
12153 return
12154
12155 def pack(self):
12156 packed = []
12157 packed.append(struct.pack("!B", self.version))
12158 packed.append(struct.pack("!B", self.type))
12159 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
12160 packed.append(struct.pack("!L", self.xid))
12161 packed.append(struct.pack("!H", self.stats_type))
12162 packed.append(struct.pack("!H", self.flags))
12163 packed.append('\x00' * 4)
12164 packed.append(struct.pack("!L", self.types))
12165 packed.append(struct.pack("!L", self.capabilities))
12166 packed.append(struct.pack("!L", self.max_groups_all))
12167 packed.append(struct.pack("!L", self.max_groups_select))
12168 packed.append(struct.pack("!L", self.max_groups_indirect))
12169 packed.append(struct.pack("!L", self.max_groups_ff))
12170 packed.append(struct.pack("!L", self.actions_all))
12171 packed.append(struct.pack("!L", self.actions_select))
12172 packed.append(struct.pack("!L", self.actions_indirect))
12173 packed.append(struct.pack("!L", self.actions_ff))
12174 length = sum([len(x) for x in packed])
12175 packed[2] = struct.pack("!H", length)
12176 return ''.join(packed)
12177
12178 @staticmethod
12179 def unpack(reader):
12180 obj = group_features_stats_reply()
12181 _version = reader.read("!B")[0]
12182 assert(_version == 5)
12183 _type = reader.read("!B")[0]
12184 assert(_type == 19)
12185 _length = reader.read("!H")[0]
12186 orig_reader = reader
12187 reader = orig_reader.slice(_length, 4)
12188 obj.xid = reader.read("!L")[0]
12189 _stats_type = reader.read("!H")[0]
12190 assert(_stats_type == 8)
12191 obj.flags = reader.read("!H")[0]
12192 reader.skip(4)
12193 obj.types = reader.read("!L")[0]
12194 obj.capabilities = reader.read("!L")[0]
12195 obj.max_groups_all = reader.read("!L")[0]
12196 obj.max_groups_select = reader.read("!L")[0]
12197 obj.max_groups_indirect = reader.read("!L")[0]
12198 obj.max_groups_ff = reader.read("!L")[0]
12199 obj.actions_all = reader.read("!L")[0]
12200 obj.actions_select = reader.read("!L")[0]
12201 obj.actions_indirect = reader.read("!L")[0]
12202 obj.actions_ff = reader.read("!L")[0]
12203 return obj
12204
12205 def __eq__(self, other):
12206 if type(self) != type(other): return False
12207 if self.xid != other.xid: return False
12208 if self.flags != other.flags: return False
12209 if self.types != other.types: return False
12210 if self.capabilities != other.capabilities: return False
12211 if self.max_groups_all != other.max_groups_all: return False
12212 if self.max_groups_select != other.max_groups_select: return False
12213 if self.max_groups_indirect != other.max_groups_indirect: return False
12214 if self.max_groups_ff != other.max_groups_ff: return False
12215 if self.actions_all != other.actions_all: return False
12216 if self.actions_select != other.actions_select: return False
12217 if self.actions_indirect != other.actions_indirect: return False
12218 if self.actions_ff != other.actions_ff: return False
12219 return True
12220
12221 def pretty_print(self, q):
12222 q.text("group_features_stats_reply {")
12223 with q.group():
12224 with q.indent(2):
12225 q.breakable()
12226 q.text("xid = ");
12227 if self.xid != None:
12228 q.text("%#x" % self.xid)
12229 else:
12230 q.text('None')
12231 q.text(","); q.breakable()
12232 q.text("flags = ");
12233 q.text("%#x" % self.flags)
12234 q.text(","); q.breakable()
12235 q.text("types = ");
12236 q.text("%#x" % self.types)
12237 q.text(","); q.breakable()
12238 q.text("capabilities = ");
12239 q.text("%#x" % self.capabilities)
12240 q.text(","); q.breakable()
12241 q.text("max_groups_all = ");
12242 q.text("%#x" % self.max_groups_all)
12243 q.text(","); q.breakable()
12244 q.text("max_groups_select = ");
12245 q.text("%#x" % self.max_groups_select)
12246 q.text(","); q.breakable()
12247 q.text("max_groups_indirect = ");
12248 q.text("%#x" % self.max_groups_indirect)
12249 q.text(","); q.breakable()
12250 q.text("max_groups_ff = ");
12251 q.text("%#x" % self.max_groups_ff)
12252 q.text(","); q.breakable()
12253 q.text("actions_all = ");
12254 q.text("%#x" % self.actions_all)
12255 q.text(","); q.breakable()
12256 q.text("actions_select = ");
12257 q.text("%#x" % self.actions_select)
12258 q.text(","); q.breakable()
12259 q.text("actions_indirect = ");
12260 q.text("%#x" % self.actions_indirect)
12261 q.text(","); q.breakable()
12262 q.text("actions_ff = ");
12263 q.text("%#x" % self.actions_ff)
12264 q.breakable()
12265 q.text('}')
12266
12267stats_reply.subtypes[8] = group_features_stats_reply
12268
12269class group_features_stats_request(stats_request):
12270 version = 5
12271 type = 18
12272 stats_type = 8
12273
12274 def __init__(self, xid=None, flags=None):
12275 if xid != None:
12276 self.xid = xid
12277 else:
12278 self.xid = None
12279 if flags != None:
12280 self.flags = flags
12281 else:
12282 self.flags = 0
12283 return
12284
12285 def pack(self):
12286 packed = []
12287 packed.append(struct.pack("!B", self.version))
12288 packed.append(struct.pack("!B", self.type))
12289 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
12290 packed.append(struct.pack("!L", self.xid))
12291 packed.append(struct.pack("!H", self.stats_type))
12292 packed.append(struct.pack("!H", self.flags))
12293 packed.append('\x00' * 4)
12294 length = sum([len(x) for x in packed])
12295 packed[2] = struct.pack("!H", length)
12296 return ''.join(packed)
12297
12298 @staticmethod
12299 def unpack(reader):
12300 obj = group_features_stats_request()
12301 _version = reader.read("!B")[0]
12302 assert(_version == 5)
12303 _type = reader.read("!B")[0]
12304 assert(_type == 18)
12305 _length = reader.read("!H")[0]
12306 orig_reader = reader
12307 reader = orig_reader.slice(_length, 4)
12308 obj.xid = reader.read("!L")[0]
12309 _stats_type = reader.read("!H")[0]
12310 assert(_stats_type == 8)
12311 obj.flags = reader.read("!H")[0]
12312 reader.skip(4)
12313 return obj
12314
12315 def __eq__(self, other):
12316 if type(self) != type(other): return False
12317 if self.xid != other.xid: return False
12318 if self.flags != other.flags: return False
12319 return True
12320
12321 def pretty_print(self, q):
12322 q.text("group_features_stats_request {")
12323 with q.group():
12324 with q.indent(2):
12325 q.breakable()
12326 q.text("xid = ");
12327 if self.xid != None:
12328 q.text("%#x" % self.xid)
12329 else:
12330 q.text('None')
12331 q.text(","); q.breakable()
12332 q.text("flags = ");
12333 q.text("%#x" % self.flags)
12334 q.breakable()
12335 q.text('}')
12336
12337stats_request.subtypes[8] = group_features_stats_request
12338
12339class group_mod_failed_error_msg(error_msg):
12340 version = 5
12341 type = 1
12342 err_type = 6
12343
12344 def __init__(self, xid=None, code=None, data=None):
12345 if xid != None:
12346 self.xid = xid
12347 else:
12348 self.xid = None
12349 if code != None:
12350 self.code = code
12351 else:
12352 self.code = 0
12353 if data != None:
12354 self.data = data
12355 else:
12356 self.data = ''
12357 return
12358
12359 def pack(self):
12360 packed = []
12361 packed.append(struct.pack("!B", self.version))
12362 packed.append(struct.pack("!B", self.type))
12363 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
12364 packed.append(struct.pack("!L", self.xid))
12365 packed.append(struct.pack("!H", self.err_type))
12366 packed.append(struct.pack("!H", self.code))
12367 packed.append(self.data)
12368 length = sum([len(x) for x in packed])
12369 packed[2] = struct.pack("!H", length)
12370 return ''.join(packed)
12371
12372 @staticmethod
12373 def unpack(reader):
12374 obj = group_mod_failed_error_msg()
12375 _version = reader.read("!B")[0]
12376 assert(_version == 5)
12377 _type = reader.read("!B")[0]
12378 assert(_type == 1)
12379 _length = reader.read("!H")[0]
12380 orig_reader = reader
12381 reader = orig_reader.slice(_length, 4)
12382 obj.xid = reader.read("!L")[0]
12383 _err_type = reader.read("!H")[0]
12384 assert(_err_type == 6)
12385 obj.code = reader.read("!H")[0]
12386 obj.data = str(reader.read_all())
12387 return obj
12388
12389 def __eq__(self, other):
12390 if type(self) != type(other): return False
12391 if self.xid != other.xid: return False
12392 if self.code != other.code: return False
12393 if self.data != other.data: return False
12394 return True
12395
12396 def pretty_print(self, q):
12397 q.text("group_mod_failed_error_msg {")
12398 with q.group():
12399 with q.indent(2):
12400 q.breakable()
12401 q.text("xid = ");
12402 if self.xid != None:
12403 q.text("%#x" % self.xid)
12404 else:
12405 q.text('None')
12406 q.text(","); q.breakable()
12407 q.text("code = ");
12408 q.text("%#x" % self.code)
12409 q.text(","); q.breakable()
12410 q.text("data = ");
12411 q.pp(self.data)
12412 q.breakable()
12413 q.text('}')
12414
12415error_msg.subtypes[6] = group_mod_failed_error_msg
12416
12417class group_modify(group_mod):
12418 version = 5
12419 type = 15
12420 command = 1
12421
12422 def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
12423 if xid != None:
12424 self.xid = xid
12425 else:
12426 self.xid = None
12427 if group_type != None:
12428 self.group_type = group_type
12429 else:
12430 self.group_type = 0
12431 if group_id != None:
12432 self.group_id = group_id
12433 else:
12434 self.group_id = 0
12435 if buckets != None:
12436 self.buckets = buckets
12437 else:
12438 self.buckets = []
12439 return
12440
12441 def pack(self):
12442 packed = []
12443 packed.append(struct.pack("!B", self.version))
12444 packed.append(struct.pack("!B", self.type))
12445 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
12446 packed.append(struct.pack("!L", self.xid))
12447 packed.append(struct.pack("!H", self.command))
12448 packed.append(struct.pack("!B", self.group_type))
12449 packed.append('\x00' * 1)
12450 packed.append(struct.pack("!L", self.group_id))
12451 packed.append(loxi.generic_util.pack_list(self.buckets))
12452 length = sum([len(x) for x in packed])
12453 packed[2] = struct.pack("!H", length)
12454 return ''.join(packed)
12455
12456 @staticmethod
12457 def unpack(reader):
12458 obj = group_modify()
12459 _version = reader.read("!B")[0]
12460 assert(_version == 5)
12461 _type = reader.read("!B")[0]
12462 assert(_type == 15)
12463 _length = reader.read("!H")[0]
12464 orig_reader = reader
12465 reader = orig_reader.slice(_length, 4)
12466 obj.xid = reader.read("!L")[0]
12467 _command = reader.read("!H")[0]
12468 assert(_command == 1)
12469 obj.group_type = reader.read("!B")[0]
12470 reader.skip(1)
12471 obj.group_id = reader.read("!L")[0]
12472 obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
12473 return obj
12474
12475 def __eq__(self, other):
12476 if type(self) != type(other): return False
12477 if self.xid != other.xid: return False
12478 if self.group_type != other.group_type: return False
12479 if self.group_id != other.group_id: return False
12480 if self.buckets != other.buckets: return False
12481 return True
12482
12483 def pretty_print(self, q):
12484 q.text("group_modify {")
12485 with q.group():
12486 with q.indent(2):
12487 q.breakable()
12488 q.text("xid = ");
12489 if self.xid != None:
12490 q.text("%#x" % self.xid)
12491 else:
12492 q.text('None')
12493 q.text(","); q.breakable()
12494 q.text("group_type = ");
12495 q.text("%#x" % self.group_type)
12496 q.text(","); q.breakable()
12497 q.text("group_id = ");
12498 q.text("%#x" % self.group_id)
12499 q.text(","); q.breakable()
12500 q.text("buckets = ");
12501 q.pp(self.buckets)
12502 q.breakable()
12503 q.text('}')
12504
12505group_mod.subtypes[1] = group_modify
12506
12507class group_stats_reply(stats_reply):
12508 version = 5
12509 type = 19
12510 stats_type = 6
12511
12512 def __init__(self, xid=None, flags=None, entries=None):
12513 if xid != None:
12514 self.xid = xid
12515 else:
12516 self.xid = None
12517 if flags != None:
12518 self.flags = flags
12519 else:
12520 self.flags = 0
12521 if entries != None:
12522 self.entries = entries
12523 else:
12524 self.entries = []
12525 return
12526
12527 def pack(self):
12528 packed = []
12529 packed.append(struct.pack("!B", self.version))
12530 packed.append(struct.pack("!B", self.type))
12531 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
12532 packed.append(struct.pack("!L", self.xid))
12533 packed.append(struct.pack("!H", self.stats_type))
12534 packed.append(struct.pack("!H", self.flags))
12535 packed.append('\x00' * 4)
12536 packed.append(loxi.generic_util.pack_list(self.entries))
12537 length = sum([len(x) for x in packed])
12538 packed[2] = struct.pack("!H", length)
12539 return ''.join(packed)
12540
12541 @staticmethod
12542 def unpack(reader):
12543 obj = group_stats_reply()
12544 _version = reader.read("!B")[0]
12545 assert(_version == 5)
12546 _type = reader.read("!B")[0]
12547 assert(_type == 19)
12548 _length = reader.read("!H")[0]
12549 orig_reader = reader
12550 reader = orig_reader.slice(_length, 4)
12551 obj.xid = reader.read("!L")[0]
12552 _stats_type = reader.read("!H")[0]
12553 assert(_stats_type == 6)
12554 obj.flags = reader.read("!H")[0]
12555 reader.skip(4)
12556 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.group_stats_entry.unpack)
12557 return obj
12558
12559 def __eq__(self, other):
12560 if type(self) != type(other): return False
12561 if self.xid != other.xid: return False
12562 if self.flags != other.flags: return False
12563 if self.entries != other.entries: return False
12564 return True
12565
12566 def pretty_print(self, q):
12567 q.text("group_stats_reply {")
12568 with q.group():
12569 with q.indent(2):
12570 q.breakable()
12571 q.text("xid = ");
12572 if self.xid != None:
12573 q.text("%#x" % self.xid)
12574 else:
12575 q.text('None')
12576 q.text(","); q.breakable()
12577 q.text("flags = ");
12578 q.text("%#x" % self.flags)
12579 q.text(","); q.breakable()
12580 q.text("entries = ");
12581 q.pp(self.entries)
12582 q.breakable()
12583 q.text('}')
12584
12585stats_reply.subtypes[6] = group_stats_reply
12586
12587class group_stats_request(stats_request):
12588 version = 5
12589 type = 18
12590 stats_type = 6
12591
12592 def __init__(self, xid=None, flags=None, group_id=None):
12593 if xid != None:
12594 self.xid = xid
12595 else:
12596 self.xid = None
12597 if flags != None:
12598 self.flags = flags
12599 else:
12600 self.flags = 0
12601 if group_id != None:
12602 self.group_id = group_id
12603 else:
12604 self.group_id = 0
12605 return
12606
12607 def pack(self):
12608 packed = []
12609 packed.append(struct.pack("!B", self.version))
12610 packed.append(struct.pack("!B", self.type))
12611 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
12612 packed.append(struct.pack("!L", self.xid))
12613 packed.append(struct.pack("!H", self.stats_type))
12614 packed.append(struct.pack("!H", self.flags))
12615 packed.append('\x00' * 4)
12616 packed.append(struct.pack("!L", self.group_id))
12617 packed.append('\x00' * 4)
12618 length = sum([len(x) for x in packed])
12619 packed[2] = struct.pack("!H", length)
12620 return ''.join(packed)
12621
12622 @staticmethod
12623 def unpack(reader):
12624 obj = group_stats_request()
12625 _version = reader.read("!B")[0]
12626 assert(_version == 5)
12627 _type = reader.read("!B")[0]
12628 assert(_type == 18)
12629 _length = reader.read("!H")[0]
12630 orig_reader = reader
12631 reader = orig_reader.slice(_length, 4)
12632 obj.xid = reader.read("!L")[0]
12633 _stats_type = reader.read("!H")[0]
12634 assert(_stats_type == 6)
12635 obj.flags = reader.read("!H")[0]
12636 reader.skip(4)
12637 obj.group_id = reader.read("!L")[0]
12638 reader.skip(4)
12639 return obj
12640
12641 def __eq__(self, other):
12642 if type(self) != type(other): return False
12643 if self.xid != other.xid: return False
12644 if self.flags != other.flags: return False
12645 if self.group_id != other.group_id: return False
12646 return True
12647
12648 def pretty_print(self, q):
12649 q.text("group_stats_request {")
12650 with q.group():
12651 with q.indent(2):
12652 q.breakable()
12653 q.text("xid = ");
12654 if self.xid != None:
12655 q.text("%#x" % self.xid)
12656 else:
12657 q.text('None')
12658 q.text(","); q.breakable()
12659 q.text("flags = ");
12660 q.text("%#x" % self.flags)
12661 q.text(","); q.breakable()
12662 q.text("group_id = ");
12663 q.text("%#x" % self.group_id)
12664 q.breakable()
12665 q.text('}')
12666
12667stats_request.subtypes[6] = group_stats_request
12668
12669class hello(message):
12670 version = 5
12671 type = 0
12672
12673 def __init__(self, xid=None, elements=None):
12674 if xid != None:
12675 self.xid = xid
12676 else:
12677 self.xid = None
12678 if elements != None:
12679 self.elements = elements
12680 else:
12681 self.elements = []
12682 return
12683
12684 def pack(self):
12685 packed = []
12686 packed.append(struct.pack("!B", self.version))
12687 packed.append(struct.pack("!B", self.type))
12688 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
12689 packed.append(struct.pack("!L", self.xid))
12690 packed.append(loxi.generic_util.pack_list(self.elements))
12691 length = sum([len(x) for x in packed])
12692 packed[2] = struct.pack("!H", length)
12693 return ''.join(packed)
12694
12695 @staticmethod
12696 def unpack(reader):
12697 obj = hello()
12698 _version = reader.read("!B")[0]
12699 assert(_version == 5)
12700 _type = reader.read("!B")[0]
12701 assert(_type == 0)
12702 _length = reader.read("!H")[0]
12703 orig_reader = reader
12704 reader = orig_reader.slice(_length, 4)
12705 obj.xid = reader.read("!L")[0]
12706 obj.elements = loxi.generic_util.unpack_list(reader, ofp.common.hello_elem.unpack)
12707 return obj
12708
12709 def __eq__(self, other):
12710 if type(self) != type(other): return False
12711 if self.xid != other.xid: return False
12712 if self.elements != other.elements: return False
12713 return True
12714
12715 def pretty_print(self, q):
12716 q.text("hello {")
12717 with q.group():
12718 with q.indent(2):
12719 q.breakable()
12720 q.text("xid = ");
12721 if self.xid != None:
12722 q.text("%#x" % self.xid)
12723 else:
12724 q.text('None')
12725 q.text(","); q.breakable()
12726 q.text("elements = ");
12727 q.pp(self.elements)
12728 q.breakable()
12729 q.text('}')
12730
12731message.subtypes[0] = hello
12732
12733class hello_failed_error_msg(error_msg):
12734 version = 5
12735 type = 1
12736 err_type = 0
12737
12738 def __init__(self, xid=None, code=None, data=None):
12739 if xid != None:
12740 self.xid = xid
12741 else:
12742 self.xid = None
12743 if code != None:
12744 self.code = code
12745 else:
12746 self.code = 0
12747 if data != None:
12748 self.data = data
12749 else:
12750 self.data = ''
12751 return
12752
12753 def pack(self):
12754 packed = []
12755 packed.append(struct.pack("!B", self.version))
12756 packed.append(struct.pack("!B", self.type))
12757 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
12758 packed.append(struct.pack("!L", self.xid))
12759 packed.append(struct.pack("!H", self.err_type))
12760 packed.append(struct.pack("!H", self.code))
12761 packed.append(self.data)
12762 length = sum([len(x) for x in packed])
12763 packed[2] = struct.pack("!H", length)
12764 return ''.join(packed)
12765
12766 @staticmethod
12767 def unpack(reader):
12768 obj = hello_failed_error_msg()
12769 _version = reader.read("!B")[0]
12770 assert(_version == 5)
12771 _type = reader.read("!B")[0]
12772 assert(_type == 1)
12773 _length = reader.read("!H")[0]
12774 orig_reader = reader
12775 reader = orig_reader.slice(_length, 4)
12776 obj.xid = reader.read("!L")[0]
12777 _err_type = reader.read("!H")[0]
12778 assert(_err_type == 0)
12779 obj.code = reader.read("!H")[0]
12780 obj.data = str(reader.read_all())
12781 return obj
12782
12783 def __eq__(self, other):
12784 if type(self) != type(other): return False
12785 if self.xid != other.xid: return False
12786 if self.code != other.code: return False
12787 if self.data != other.data: return False
12788 return True
12789
12790 def pretty_print(self, q):
12791 q.text("hello_failed_error_msg {")
12792 with q.group():
12793 with q.indent(2):
12794 q.breakable()
12795 q.text("xid = ");
12796 if self.xid != None:
12797 q.text("%#x" % self.xid)
12798 else:
12799 q.text('None')
12800 q.text(","); q.breakable()
12801 q.text("code = ");
12802 q.text("%#x" % self.code)
12803 q.text(","); q.breakable()
12804 q.text("data = ");
12805 q.pp(self.data)
12806 q.breakable()
12807 q.text('}')
12808
12809error_msg.subtypes[0] = hello_failed_error_msg
12810
12811class meter_config_stats_reply(stats_reply):
12812 version = 5
12813 type = 19
12814 stats_type = 10
12815
12816 def __init__(self, xid=None, flags=None, entries=None):
12817 if xid != None:
12818 self.xid = xid
12819 else:
12820 self.xid = None
12821 if flags != None:
12822 self.flags = flags
12823 else:
12824 self.flags = 0
12825 if entries != None:
12826 self.entries = entries
12827 else:
12828 self.entries = []
12829 return
12830
12831 def pack(self):
12832 packed = []
12833 packed.append(struct.pack("!B", self.version))
12834 packed.append(struct.pack("!B", self.type))
12835 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
12836 packed.append(struct.pack("!L", self.xid))
12837 packed.append(struct.pack("!H", self.stats_type))
12838 packed.append(struct.pack("!H", self.flags))
12839 packed.append('\x00' * 4)
12840 packed.append(loxi.generic_util.pack_list(self.entries))
12841 length = sum([len(x) for x in packed])
12842 packed[2] = struct.pack("!H", length)
12843 return ''.join(packed)
12844
12845 @staticmethod
12846 def unpack(reader):
12847 obj = meter_config_stats_reply()
12848 _version = reader.read("!B")[0]
12849 assert(_version == 5)
12850 _type = reader.read("!B")[0]
12851 assert(_type == 19)
12852 _length = reader.read("!H")[0]
12853 orig_reader = reader
12854 reader = orig_reader.slice(_length, 4)
12855 obj.xid = reader.read("!L")[0]
12856 _stats_type = reader.read("!H")[0]
12857 assert(_stats_type == 10)
12858 obj.flags = reader.read("!H")[0]
12859 reader.skip(4)
12860 obj.entries = loxi.generic_util.unpack_list(reader, ofp.meter_band.meter_band.unpack)
12861 return obj
12862
12863 def __eq__(self, other):
12864 if type(self) != type(other): return False
12865 if self.xid != other.xid: return False
12866 if self.flags != other.flags: return False
12867 if self.entries != other.entries: return False
12868 return True
12869
12870 def pretty_print(self, q):
12871 q.text("meter_config_stats_reply {")
12872 with q.group():
12873 with q.indent(2):
12874 q.breakable()
12875 q.text("xid = ");
12876 if self.xid != None:
12877 q.text("%#x" % self.xid)
12878 else:
12879 q.text('None')
12880 q.text(","); q.breakable()
12881 q.text("flags = ");
12882 q.text("%#x" % self.flags)
12883 q.text(","); q.breakable()
12884 q.text("entries = ");
12885 q.pp(self.entries)
12886 q.breakable()
12887 q.text('}')
12888
12889stats_reply.subtypes[10] = meter_config_stats_reply
12890
12891class meter_config_stats_request(stats_request):
12892 version = 5
12893 type = 18
12894 stats_type = 10
12895
12896 def __init__(self, xid=None, flags=None, meter_id=None):
12897 if xid != None:
12898 self.xid = xid
12899 else:
12900 self.xid = None
12901 if flags != None:
12902 self.flags = flags
12903 else:
12904 self.flags = 0
12905 if meter_id != None:
12906 self.meter_id = meter_id
12907 else:
12908 self.meter_id = 0
12909 return
12910
12911 def pack(self):
12912 packed = []
12913 packed.append(struct.pack("!B", self.version))
12914 packed.append(struct.pack("!B", self.type))
12915 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
12916 packed.append(struct.pack("!L", self.xid))
12917 packed.append(struct.pack("!H", self.stats_type))
12918 packed.append(struct.pack("!H", self.flags))
12919 packed.append('\x00' * 4)
12920 packed.append(struct.pack("!L", self.meter_id))
12921 packed.append('\x00' * 4)
12922 length = sum([len(x) for x in packed])
12923 packed[2] = struct.pack("!H", length)
12924 return ''.join(packed)
12925
12926 @staticmethod
12927 def unpack(reader):
12928 obj = meter_config_stats_request()
12929 _version = reader.read("!B")[0]
12930 assert(_version == 5)
12931 _type = reader.read("!B")[0]
12932 assert(_type == 18)
12933 _length = reader.read("!H")[0]
12934 orig_reader = reader
12935 reader = orig_reader.slice(_length, 4)
12936 obj.xid = reader.read("!L")[0]
12937 _stats_type = reader.read("!H")[0]
12938 assert(_stats_type == 10)
12939 obj.flags = reader.read("!H")[0]
12940 reader.skip(4)
12941 obj.meter_id = reader.read("!L")[0]
12942 reader.skip(4)
12943 return obj
12944
12945 def __eq__(self, other):
12946 if type(self) != type(other): return False
12947 if self.xid != other.xid: return False
12948 if self.flags != other.flags: return False
12949 if self.meter_id != other.meter_id: return False
12950 return True
12951
12952 def pretty_print(self, q):
12953 q.text("meter_config_stats_request {")
12954 with q.group():
12955 with q.indent(2):
12956 q.breakable()
12957 q.text("xid = ");
12958 if self.xid != None:
12959 q.text("%#x" % self.xid)
12960 else:
12961 q.text('None')
12962 q.text(","); q.breakable()
12963 q.text("flags = ");
12964 q.text("%#x" % self.flags)
12965 q.text(","); q.breakable()
12966 q.text("meter_id = ");
12967 q.text("%#x" % self.meter_id)
12968 q.breakable()
12969 q.text('}')
12970
12971stats_request.subtypes[10] = meter_config_stats_request
12972
12973class meter_features_stats_reply(stats_reply):
12974 version = 5
12975 type = 19
12976 stats_type = 11
12977
12978 def __init__(self, xid=None, flags=None, features=None):
12979 if xid != None:
12980 self.xid = xid
12981 else:
12982 self.xid = None
12983 if flags != None:
12984 self.flags = flags
12985 else:
12986 self.flags = 0
12987 if features != None:
12988 self.features = features
12989 else:
12990 self.features = ofp.meter_features()
12991 return
12992
12993 def pack(self):
12994 packed = []
12995 packed.append(struct.pack("!B", self.version))
12996 packed.append(struct.pack("!B", self.type))
12997 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
12998 packed.append(struct.pack("!L", self.xid))
12999 packed.append(struct.pack("!H", self.stats_type))
13000 packed.append(struct.pack("!H", self.flags))
13001 packed.append('\x00' * 4)
13002 packed.append(self.features.pack())
13003 length = sum([len(x) for x in packed])
13004 packed[2] = struct.pack("!H", length)
13005 return ''.join(packed)
13006
13007 @staticmethod
13008 def unpack(reader):
13009 obj = meter_features_stats_reply()
13010 _version = reader.read("!B")[0]
13011 assert(_version == 5)
13012 _type = reader.read("!B")[0]
13013 assert(_type == 19)
13014 _length = reader.read("!H")[0]
13015 orig_reader = reader
13016 reader = orig_reader.slice(_length, 4)
13017 obj.xid = reader.read("!L")[0]
13018 _stats_type = reader.read("!H")[0]
13019 assert(_stats_type == 11)
13020 obj.flags = reader.read("!H")[0]
13021 reader.skip(4)
13022 obj.features = ofp.meter_features.unpack(reader)
13023 return obj
13024
13025 def __eq__(self, other):
13026 if type(self) != type(other): return False
13027 if self.xid != other.xid: return False
13028 if self.flags != other.flags: return False
13029 if self.features != other.features: return False
13030 return True
13031
13032 def pretty_print(self, q):
13033 q.text("meter_features_stats_reply {")
13034 with q.group():
13035 with q.indent(2):
13036 q.breakable()
13037 q.text("xid = ");
13038 if self.xid != None:
13039 q.text("%#x" % self.xid)
13040 else:
13041 q.text('None')
13042 q.text(","); q.breakable()
13043 q.text("flags = ");
13044 q.text("%#x" % self.flags)
13045 q.text(","); q.breakable()
13046 q.text("features = ");
13047 q.pp(self.features)
13048 q.breakable()
13049 q.text('}')
13050
13051stats_reply.subtypes[11] = meter_features_stats_reply
13052
13053class meter_features_stats_request(stats_request):
13054 version = 5
13055 type = 18
13056 stats_type = 11
13057
13058 def __init__(self, xid=None, flags=None):
13059 if xid != None:
13060 self.xid = xid
13061 else:
13062 self.xid = None
13063 if flags != None:
13064 self.flags = flags
13065 else:
13066 self.flags = 0
13067 return
13068
13069 def pack(self):
13070 packed = []
13071 packed.append(struct.pack("!B", self.version))
13072 packed.append(struct.pack("!B", self.type))
13073 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
13074 packed.append(struct.pack("!L", self.xid))
13075 packed.append(struct.pack("!H", self.stats_type))
13076 packed.append(struct.pack("!H", self.flags))
13077 packed.append('\x00' * 4)
13078 length = sum([len(x) for x in packed])
13079 packed[2] = struct.pack("!H", length)
13080 return ''.join(packed)
13081
13082 @staticmethod
13083 def unpack(reader):
13084 obj = meter_features_stats_request()
13085 _version = reader.read("!B")[0]
13086 assert(_version == 5)
13087 _type = reader.read("!B")[0]
13088 assert(_type == 18)
13089 _length = reader.read("!H")[0]
13090 orig_reader = reader
13091 reader = orig_reader.slice(_length, 4)
13092 obj.xid = reader.read("!L")[0]
13093 _stats_type = reader.read("!H")[0]
13094 assert(_stats_type == 11)
13095 obj.flags = reader.read("!H")[0]
13096 reader.skip(4)
13097 return obj
13098
13099 def __eq__(self, other):
13100 if type(self) != type(other): return False
13101 if self.xid != other.xid: return False
13102 if self.flags != other.flags: return False
13103 return True
13104
13105 def pretty_print(self, q):
13106 q.text("meter_features_stats_request {")
13107 with q.group():
13108 with q.indent(2):
13109 q.breakable()
13110 q.text("xid = ");
13111 if self.xid != None:
13112 q.text("%#x" % self.xid)
13113 else:
13114 q.text('None')
13115 q.text(","); q.breakable()
13116 q.text("flags = ");
13117 q.text("%#x" % self.flags)
13118 q.breakable()
13119 q.text('}')
13120
13121stats_request.subtypes[11] = meter_features_stats_request
13122
13123class meter_mod(message):
13124 version = 5
13125 type = 29
13126
13127 def __init__(self, xid=None, command=None, flags=None, meter_id=None, bands=None):
13128 if xid != None:
13129 self.xid = xid
13130 else:
13131 self.xid = None
13132 if command != None:
13133 self.command = command
13134 else:
13135 self.command = 0
13136 if flags != None:
13137 self.flags = flags
13138 else:
13139 self.flags = 0
13140 if meter_id != None:
13141 self.meter_id = meter_id
13142 else:
13143 self.meter_id = 0
13144 if bands != None:
13145 self.bands = bands
13146 else:
13147 self.bands = []
13148 return
13149
13150 def pack(self):
13151 packed = []
13152 packed.append(struct.pack("!B", self.version))
13153 packed.append(struct.pack("!B", self.type))
13154 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
13155 packed.append(struct.pack("!L", self.xid))
13156 packed.append(struct.pack("!H", self.command))
13157 packed.append(struct.pack("!H", self.flags))
13158 packed.append(struct.pack("!L", self.meter_id))
13159 packed.append(loxi.generic_util.pack_list(self.bands))
13160 length = sum([len(x) for x in packed])
13161 packed[2] = struct.pack("!H", length)
13162 return ''.join(packed)
13163
13164 @staticmethod
13165 def unpack(reader):
13166 obj = meter_mod()
13167 _version = reader.read("!B")[0]
13168 assert(_version == 5)
13169 _type = reader.read("!B")[0]
13170 assert(_type == 29)
13171 _length = reader.read("!H")[0]
13172 orig_reader = reader
13173 reader = orig_reader.slice(_length, 4)
13174 obj.xid = reader.read("!L")[0]
13175 obj.command = reader.read("!H")[0]
13176 obj.flags = reader.read("!H")[0]
13177 obj.meter_id = reader.read("!L")[0]
13178 obj.bands = loxi.generic_util.unpack_list(reader, ofp.meter_band.meter_band.unpack)
13179 return obj
13180
13181 def __eq__(self, other):
13182 if type(self) != type(other): return False
13183 if self.xid != other.xid: return False
13184 if self.command != other.command: return False
13185 if self.flags != other.flags: return False
13186 if self.meter_id != other.meter_id: return False
13187 if self.bands != other.bands: return False
13188 return True
13189
13190 def pretty_print(self, q):
13191 q.text("meter_mod {")
13192 with q.group():
13193 with q.indent(2):
13194 q.breakable()
13195 q.text("xid = ");
13196 if self.xid != None:
13197 q.text("%#x" % self.xid)
13198 else:
13199 q.text('None')
13200 q.text(","); q.breakable()
13201 q.text("command = ");
13202 q.text("%#x" % self.command)
13203 q.text(","); q.breakable()
13204 q.text("flags = ");
13205 q.text("%#x" % self.flags)
13206 q.text(","); q.breakable()
13207 q.text("meter_id = ");
13208 q.text("%#x" % self.meter_id)
13209 q.text(","); q.breakable()
13210 q.text("bands = ");
13211 q.pp(self.bands)
13212 q.breakable()
13213 q.text('}')
13214
13215message.subtypes[29] = meter_mod
13216
13217class meter_mod_failed_error_msg(error_msg):
13218 version = 5
13219 type = 1
13220 err_type = 12
13221
13222 def __init__(self, xid=None, code=None, data=None):
13223 if xid != None:
13224 self.xid = xid
13225 else:
13226 self.xid = None
13227 if code != None:
13228 self.code = code
13229 else:
13230 self.code = 0
13231 if data != None:
13232 self.data = data
13233 else:
13234 self.data = ''
13235 return
13236
13237 def pack(self):
13238 packed = []
13239 packed.append(struct.pack("!B", self.version))
13240 packed.append(struct.pack("!B", self.type))
13241 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
13242 packed.append(struct.pack("!L", self.xid))
13243 packed.append(struct.pack("!H", self.err_type))
13244 packed.append(struct.pack("!H", self.code))
13245 packed.append(self.data)
13246 length = sum([len(x) for x in packed])
13247 packed[2] = struct.pack("!H", length)
13248 return ''.join(packed)
13249
13250 @staticmethod
13251 def unpack(reader):
13252 obj = meter_mod_failed_error_msg()
13253 _version = reader.read("!B")[0]
13254 assert(_version == 5)
13255 _type = reader.read("!B")[0]
13256 assert(_type == 1)
13257 _length = reader.read("!H")[0]
13258 orig_reader = reader
13259 reader = orig_reader.slice(_length, 4)
13260 obj.xid = reader.read("!L")[0]
13261 _err_type = reader.read("!H")[0]
13262 assert(_err_type == 12)
13263 obj.code = reader.read("!H")[0]
13264 obj.data = str(reader.read_all())
13265 return obj
13266
13267 def __eq__(self, other):
13268 if type(self) != type(other): return False
13269 if self.xid != other.xid: return False
13270 if self.code != other.code: return False
13271 if self.data != other.data: return False
13272 return True
13273
13274 def pretty_print(self, q):
13275 q.text("meter_mod_failed_error_msg {")
13276 with q.group():
13277 with q.indent(2):
13278 q.breakable()
13279 q.text("xid = ");
13280 if self.xid != None:
13281 q.text("%#x" % self.xid)
13282 else:
13283 q.text('None')
13284 q.text(","); q.breakable()
13285 q.text("code = ");
13286 q.text("%#x" % self.code)
13287 q.text(","); q.breakable()
13288 q.text("data = ");
13289 q.pp(self.data)
13290 q.breakable()
13291 q.text('}')
13292
13293error_msg.subtypes[12] = meter_mod_failed_error_msg
13294
13295class meter_stats_reply(stats_reply):
13296 version = 5
13297 type = 19
13298 stats_type = 9
13299
13300 def __init__(self, xid=None, flags=None, entries=None):
13301 if xid != None:
13302 self.xid = xid
13303 else:
13304 self.xid = None
13305 if flags != None:
13306 self.flags = flags
13307 else:
13308 self.flags = 0
13309 if entries != None:
13310 self.entries = entries
13311 else:
13312 self.entries = []
13313 return
13314
13315 def pack(self):
13316 packed = []
13317 packed.append(struct.pack("!B", self.version))
13318 packed.append(struct.pack("!B", self.type))
13319 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
13320 packed.append(struct.pack("!L", self.xid))
13321 packed.append(struct.pack("!H", self.stats_type))
13322 packed.append(struct.pack("!H", self.flags))
13323 packed.append('\x00' * 4)
13324 packed.append(loxi.generic_util.pack_list(self.entries))
13325 length = sum([len(x) for x in packed])
13326 packed[2] = struct.pack("!H", length)
13327 return ''.join(packed)
13328
13329 @staticmethod
13330 def unpack(reader):
13331 obj = meter_stats_reply()
13332 _version = reader.read("!B")[0]
13333 assert(_version == 5)
13334 _type = reader.read("!B")[0]
13335 assert(_type == 19)
13336 _length = reader.read("!H")[0]
13337 orig_reader = reader
13338 reader = orig_reader.slice(_length, 4)
13339 obj.xid = reader.read("!L")[0]
13340 _stats_type = reader.read("!H")[0]
13341 assert(_stats_type == 9)
13342 obj.flags = reader.read("!H")[0]
13343 reader.skip(4)
13344 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.meter_stats.unpack)
13345 return obj
13346
13347 def __eq__(self, other):
13348 if type(self) != type(other): return False
13349 if self.xid != other.xid: return False
13350 if self.flags != other.flags: return False
13351 if self.entries != other.entries: return False
13352 return True
13353
13354 def pretty_print(self, q):
13355 q.text("meter_stats_reply {")
13356 with q.group():
13357 with q.indent(2):
13358 q.breakable()
13359 q.text("xid = ");
13360 if self.xid != None:
13361 q.text("%#x" % self.xid)
13362 else:
13363 q.text('None')
13364 q.text(","); q.breakable()
13365 q.text("flags = ");
13366 q.text("%#x" % self.flags)
13367 q.text(","); q.breakable()
13368 q.text("entries = ");
13369 q.pp(self.entries)
13370 q.breakable()
13371 q.text('}')
13372
13373stats_reply.subtypes[9] = meter_stats_reply
13374
13375class meter_stats_request(stats_request):
13376 version = 5
13377 type = 18
13378 stats_type = 9
13379
13380 def __init__(self, xid=None, flags=None, meter_id=None):
13381 if xid != None:
13382 self.xid = xid
13383 else:
13384 self.xid = None
13385 if flags != None:
13386 self.flags = flags
13387 else:
13388 self.flags = 0
13389 if meter_id != None:
13390 self.meter_id = meter_id
13391 else:
13392 self.meter_id = 0
13393 return
13394
13395 def pack(self):
13396 packed = []
13397 packed.append(struct.pack("!B", self.version))
13398 packed.append(struct.pack("!B", self.type))
13399 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
13400 packed.append(struct.pack("!L", self.xid))
13401 packed.append(struct.pack("!H", self.stats_type))
13402 packed.append(struct.pack("!H", self.flags))
13403 packed.append('\x00' * 4)
13404 packed.append(struct.pack("!L", self.meter_id))
13405 packed.append('\x00' * 4)
13406 length = sum([len(x) for x in packed])
13407 packed[2] = struct.pack("!H", length)
13408 return ''.join(packed)
13409
13410 @staticmethod
13411 def unpack(reader):
13412 obj = meter_stats_request()
13413 _version = reader.read("!B")[0]
13414 assert(_version == 5)
13415 _type = reader.read("!B")[0]
13416 assert(_type == 18)
13417 _length = reader.read("!H")[0]
13418 orig_reader = reader
13419 reader = orig_reader.slice(_length, 4)
13420 obj.xid = reader.read("!L")[0]
13421 _stats_type = reader.read("!H")[0]
13422 assert(_stats_type == 9)
13423 obj.flags = reader.read("!H")[0]
13424 reader.skip(4)
13425 obj.meter_id = reader.read("!L")[0]
13426 reader.skip(4)
13427 return obj
13428
13429 def __eq__(self, other):
13430 if type(self) != type(other): return False
13431 if self.xid != other.xid: return False
13432 if self.flags != other.flags: return False
13433 if self.meter_id != other.meter_id: return False
13434 return True
13435
13436 def pretty_print(self, q):
13437 q.text("meter_stats_request {")
13438 with q.group():
13439 with q.indent(2):
13440 q.breakable()
13441 q.text("xid = ");
13442 if self.xid != None:
13443 q.text("%#x" % self.xid)
13444 else:
13445 q.text('None')
13446 q.text(","); q.breakable()
13447 q.text("flags = ");
13448 q.text("%#x" % self.flags)
13449 q.text(","); q.breakable()
13450 q.text("meter_id = ");
13451 q.text("%#x" % self.meter_id)
13452 q.breakable()
13453 q.text('}')
13454
13455stats_request.subtypes[9] = meter_stats_request
13456
13457class nicira_header(experimenter):
13458 subtypes = {}
13459
13460 version = 5
13461 type = 4
13462 experimenter = 8992
13463
13464 def __init__(self, xid=None, subtype=None):
13465 if xid != None:
13466 self.xid = xid
13467 else:
13468 self.xid = None
13469 if subtype != None:
13470 self.subtype = subtype
13471 else:
13472 self.subtype = 0
13473 return
13474
13475 def pack(self):
13476 packed = []
13477 packed.append(struct.pack("!B", self.version))
13478 packed.append(struct.pack("!B", self.type))
13479 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
13480 packed.append(struct.pack("!L", self.xid))
13481 packed.append(struct.pack("!L", self.experimenter))
13482 packed.append(struct.pack("!L", self.subtype))
13483 length = sum([len(x) for x in packed])
13484 packed[2] = struct.pack("!H", length)
13485 return ''.join(packed)
13486
13487 @staticmethod
13488 def unpack(reader):
13489 subtype, = reader.peek('!L', 12)
13490 subclass = nicira_header.subtypes.get(subtype)
13491 if subclass:
13492 return subclass.unpack(reader)
13493
13494 obj = nicira_header()
13495 _version = reader.read("!B")[0]
13496 assert(_version == 5)
13497 _type = reader.read("!B")[0]
13498 assert(_type == 4)
13499 _length = reader.read("!H")[0]
13500 orig_reader = reader
13501 reader = orig_reader.slice(_length, 4)
13502 obj.xid = reader.read("!L")[0]
13503 _experimenter = reader.read("!L")[0]
13504 assert(_experimenter == 8992)
13505 obj.subtype = reader.read("!L")[0]
13506 return obj
13507
13508 def __eq__(self, other):
13509 if type(self) != type(other): return False
13510 if self.xid != other.xid: return False
13511 if self.subtype != other.subtype: return False
13512 return True
13513
13514 def pretty_print(self, q):
13515 q.text("nicira_header {")
13516 with q.group():
13517 with q.indent(2):
13518 q.breakable()
13519 q.text("xid = ");
13520 if self.xid != None:
13521 q.text("%#x" % self.xid)
13522 else:
13523 q.text('None')
13524 q.breakable()
13525 q.text('}')
13526
13527experimenter.subtypes[8992] = nicira_header
13528
13529class packet_in(message):
13530 version = 5
13531 type = 10
13532
13533 def __init__(self, xid=None, buffer_id=None, total_len=None, reason=None, table_id=None, cookie=None, match=None, data=None):
13534 if xid != None:
13535 self.xid = xid
13536 else:
13537 self.xid = None
13538 if buffer_id != None:
13539 self.buffer_id = buffer_id
13540 else:
13541 self.buffer_id = 0
13542 if total_len != None:
13543 self.total_len = total_len
13544 else:
13545 self.total_len = 0
13546 if reason != None:
13547 self.reason = reason
13548 else:
13549 self.reason = 0
13550 if table_id != None:
13551 self.table_id = table_id
13552 else:
13553 self.table_id = 0
13554 if cookie != None:
13555 self.cookie = cookie
13556 else:
13557 self.cookie = 0
13558 if match != None:
13559 self.match = match
13560 else:
13561 self.match = ofp.match()
13562 if data != None:
13563 self.data = data
13564 else:
13565 self.data = ''
13566 return
13567
13568 def pack(self):
13569 packed = []
13570 packed.append(struct.pack("!B", self.version))
13571 packed.append(struct.pack("!B", self.type))
13572 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
13573 packed.append(struct.pack("!L", self.xid))
13574 packed.append(struct.pack("!L", self.buffer_id))
13575 packed.append(struct.pack("!H", self.total_len))
13576 packed.append(struct.pack("!B", self.reason))
13577 packed.append(struct.pack("!B", self.table_id))
13578 packed.append(struct.pack("!Q", self.cookie))
13579 packed.append(self.match.pack())
13580 packed.append('\x00' * 2)
13581 packed.append(self.data)
13582 length = sum([len(x) for x in packed])
13583 packed[2] = struct.pack("!H", length)
13584 return ''.join(packed)
13585
13586 @staticmethod
13587 def unpack(reader):
13588 obj = packet_in()
13589 _version = reader.read("!B")[0]
13590 assert(_version == 5)
13591 _type = reader.read("!B")[0]
13592 assert(_type == 10)
13593 _length = reader.read("!H")[0]
13594 orig_reader = reader
13595 reader = orig_reader.slice(_length, 4)
13596 obj.xid = reader.read("!L")[0]
13597 obj.buffer_id = reader.read("!L")[0]
13598 obj.total_len = reader.read("!H")[0]
13599 obj.reason = reader.read("!B")[0]
13600 obj.table_id = reader.read("!B")[0]
13601 obj.cookie = reader.read("!Q")[0]
13602 obj.match = ofp.match.unpack(reader)
13603 reader.skip(2)
13604 obj.data = str(reader.read_all())
13605 return obj
13606
13607 def __eq__(self, other):
13608 if type(self) != type(other): return False
13609 if self.xid != other.xid: return False
13610 if self.buffer_id != other.buffer_id: return False
13611 if self.total_len != other.total_len: return False
13612 if self.reason != other.reason: return False
13613 if self.table_id != other.table_id: return False
13614 if self.cookie != other.cookie: return False
13615 if self.match != other.match: return False
13616 if self.data != other.data: return False
13617 return True
13618
13619 def pretty_print(self, q):
13620 q.text("packet_in {")
13621 with q.group():
13622 with q.indent(2):
13623 q.breakable()
13624 q.text("xid = ");
13625 if self.xid != None:
13626 q.text("%#x" % self.xid)
13627 else:
13628 q.text('None')
13629 q.text(","); q.breakable()
13630 q.text("buffer_id = ");
13631 q.text("%#x" % self.buffer_id)
13632 q.text(","); q.breakable()
13633 q.text("total_len = ");
13634 q.text("%#x" % self.total_len)
13635 q.text(","); q.breakable()
13636 q.text("reason = ");
13637 q.text("%#x" % self.reason)
13638 q.text(","); q.breakable()
13639 q.text("table_id = ");
13640 q.text("%#x" % self.table_id)
13641 q.text(","); q.breakable()
13642 q.text("cookie = ");
13643 q.text("%#x" % self.cookie)
13644 q.text(","); q.breakable()
13645 q.text("match = ");
13646 q.pp(self.match)
13647 q.text(","); q.breakable()
13648 q.text("data = ");
13649 q.pp(self.data)
13650 q.breakable()
13651 q.text('}')
13652
13653message.subtypes[10] = packet_in
13654
13655class packet_out(message):
13656 version = 5
13657 type = 13
13658
13659 def __init__(self, xid=None, buffer_id=None, in_port=None, actions=None, data=None):
13660 if xid != None:
13661 self.xid = xid
13662 else:
13663 self.xid = None
13664 if buffer_id != None:
13665 self.buffer_id = buffer_id
13666 else:
13667 self.buffer_id = 0
13668 if in_port != None:
13669 self.in_port = in_port
13670 else:
13671 self.in_port = 0
13672 if actions != None:
13673 self.actions = actions
13674 else:
13675 self.actions = []
13676 if data != None:
13677 self.data = data
13678 else:
13679 self.data = ''
13680 return
13681
13682 def pack(self):
13683 packed = []
13684 packed.append(struct.pack("!B", self.version))
13685 packed.append(struct.pack("!B", self.type))
13686 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
13687 packed.append(struct.pack("!L", self.xid))
13688 packed.append(struct.pack("!L", self.buffer_id))
13689 packed.append(util.pack_port_no(self.in_port))
13690 packed.append(struct.pack("!H", 0)) # placeholder for actions_len at index 6
13691 packed.append('\x00' * 6)
13692 packed.append(loxi.generic_util.pack_list(self.actions))
13693 packed[6] = struct.pack("!H", len(packed[-1]))
13694 packed.append(self.data)
13695 length = sum([len(x) for x in packed])
13696 packed[2] = struct.pack("!H", length)
13697 return ''.join(packed)
13698
13699 @staticmethod
13700 def unpack(reader):
13701 obj = packet_out()
13702 _version = reader.read("!B")[0]
13703 assert(_version == 5)
13704 _type = reader.read("!B")[0]
13705 assert(_type == 13)
13706 _length = reader.read("!H")[0]
13707 orig_reader = reader
13708 reader = orig_reader.slice(_length, 4)
13709 obj.xid = reader.read("!L")[0]
13710 obj.buffer_id = reader.read("!L")[0]
13711 obj.in_port = util.unpack_port_no(reader)
13712 _actions_len = reader.read("!H")[0]
13713 reader.skip(6)
13714 obj.actions = loxi.generic_util.unpack_list(reader.slice(_actions_len), ofp.action.action.unpack)
13715 obj.data = str(reader.read_all())
13716 return obj
13717
13718 def __eq__(self, other):
13719 if type(self) != type(other): return False
13720 if self.xid != other.xid: return False
13721 if self.buffer_id != other.buffer_id: return False
13722 if self.in_port != other.in_port: return False
13723 if self.actions != other.actions: return False
13724 if self.data != other.data: return False
13725 return True
13726
13727 def pretty_print(self, q):
13728 q.text("packet_out {")
13729 with q.group():
13730 with q.indent(2):
13731 q.breakable()
13732 q.text("xid = ");
13733 if self.xid != None:
13734 q.text("%#x" % self.xid)
13735 else:
13736 q.text('None')
13737 q.text(","); q.breakable()
13738 q.text("buffer_id = ");
13739 q.text("%#x" % self.buffer_id)
13740 q.text(","); q.breakable()
13741 q.text("in_port = ");
13742 q.text(util.pretty_port(self.in_port))
13743 q.text(","); q.breakable()
13744 q.text("actions = ");
13745 q.pp(self.actions)
13746 q.text(","); q.breakable()
13747 q.text("data = ");
13748 q.pp(self.data)
13749 q.breakable()
13750 q.text('}')
13751
13752message.subtypes[13] = packet_out
13753
13754class port_desc_stats_reply(stats_reply):
13755 version = 5
13756 type = 19
13757 stats_type = 13
13758
13759 def __init__(self, xid=None, flags=None, entries=None):
13760 if xid != None:
13761 self.xid = xid
13762 else:
13763 self.xid = None
13764 if flags != None:
13765 self.flags = flags
13766 else:
13767 self.flags = 0
13768 if entries != None:
13769 self.entries = entries
13770 else:
13771 self.entries = []
13772 return
13773
13774 def pack(self):
13775 packed = []
13776 packed.append(struct.pack("!B", self.version))
13777 packed.append(struct.pack("!B", self.type))
13778 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
13779 packed.append(struct.pack("!L", self.xid))
13780 packed.append(struct.pack("!H", self.stats_type))
13781 packed.append(struct.pack("!H", self.flags))
13782 packed.append('\x00' * 4)
13783 packed.append(loxi.generic_util.pack_list(self.entries))
13784 length = sum([len(x) for x in packed])
13785 packed[2] = struct.pack("!H", length)
13786 return ''.join(packed)
13787
13788 @staticmethod
13789 def unpack(reader):
13790 obj = port_desc_stats_reply()
13791 _version = reader.read("!B")[0]
13792 assert(_version == 5)
13793 _type = reader.read("!B")[0]
13794 assert(_type == 19)
13795 _length = reader.read("!H")[0]
13796 orig_reader = reader
13797 reader = orig_reader.slice(_length, 4)
13798 obj.xid = reader.read("!L")[0]
13799 _stats_type = reader.read("!H")[0]
13800 assert(_stats_type == 13)
13801 obj.flags = reader.read("!H")[0]
13802 reader.skip(4)
13803 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.port_desc.unpack)
13804 return obj
13805
13806 def __eq__(self, other):
13807 if type(self) != type(other): return False
13808 if self.xid != other.xid: return False
13809 if self.flags != other.flags: return False
13810 if self.entries != other.entries: return False
13811 return True
13812
13813 def pretty_print(self, q):
13814 q.text("port_desc_stats_reply {")
13815 with q.group():
13816 with q.indent(2):
13817 q.breakable()
13818 q.text("xid = ");
13819 if self.xid != None:
13820 q.text("%#x" % self.xid)
13821 else:
13822 q.text('None')
13823 q.text(","); q.breakable()
13824 q.text("flags = ");
13825 q.text("%#x" % self.flags)
13826 q.text(","); q.breakable()
13827 q.text("entries = ");
13828 q.pp(self.entries)
13829 q.breakable()
13830 q.text('}')
13831
13832stats_reply.subtypes[13] = port_desc_stats_reply
13833
13834class port_desc_stats_request(stats_request):
13835 version = 5
13836 type = 18
13837 stats_type = 13
13838
13839 def __init__(self, xid=None, flags=None):
13840 if xid != None:
13841 self.xid = xid
13842 else:
13843 self.xid = None
13844 if flags != None:
13845 self.flags = flags
13846 else:
13847 self.flags = 0
13848 return
13849
13850 def pack(self):
13851 packed = []
13852 packed.append(struct.pack("!B", self.version))
13853 packed.append(struct.pack("!B", self.type))
13854 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
13855 packed.append(struct.pack("!L", self.xid))
13856 packed.append(struct.pack("!H", self.stats_type))
13857 packed.append(struct.pack("!H", self.flags))
13858 packed.append('\x00' * 4)
13859 length = sum([len(x) for x in packed])
13860 packed[2] = struct.pack("!H", length)
13861 return ''.join(packed)
13862
13863 @staticmethod
13864 def unpack(reader):
13865 obj = port_desc_stats_request()
13866 _version = reader.read("!B")[0]
13867 assert(_version == 5)
13868 _type = reader.read("!B")[0]
13869 assert(_type == 18)
13870 _length = reader.read("!H")[0]
13871 orig_reader = reader
13872 reader = orig_reader.slice(_length, 4)
13873 obj.xid = reader.read("!L")[0]
13874 _stats_type = reader.read("!H")[0]
13875 assert(_stats_type == 13)
13876 obj.flags = reader.read("!H")[0]
13877 reader.skip(4)
13878 return obj
13879
13880 def __eq__(self, other):
13881 if type(self) != type(other): return False
13882 if self.xid != other.xid: return False
13883 if self.flags != other.flags: return False
13884 return True
13885
13886 def pretty_print(self, q):
13887 q.text("port_desc_stats_request {")
13888 with q.group():
13889 with q.indent(2):
13890 q.breakable()
13891 q.text("xid = ");
13892 if self.xid != None:
13893 q.text("%#x" % self.xid)
13894 else:
13895 q.text('None')
13896 q.text(","); q.breakable()
13897 q.text("flags = ");
13898 q.text("%#x" % self.flags)
13899 q.breakable()
13900 q.text('}')
13901
13902stats_request.subtypes[13] = port_desc_stats_request
13903
13904class port_mod(message):
13905 version = 5
13906 type = 16
13907
13908 def __init__(self, xid=None, port_no=None, hw_addr=None, config=None, mask=None, properties=None):
13909 if xid != None:
13910 self.xid = xid
13911 else:
13912 self.xid = None
13913 if port_no != None:
13914 self.port_no = port_no
13915 else:
13916 self.port_no = 0
13917 if hw_addr != None:
13918 self.hw_addr = hw_addr
13919 else:
13920 self.hw_addr = [0,0,0,0,0,0]
13921 if config != None:
13922 self.config = config
13923 else:
13924 self.config = 0
13925 if mask != None:
13926 self.mask = mask
13927 else:
13928 self.mask = 0
13929 if properties != None:
13930 self.properties = properties
13931 else:
13932 self.properties = []
13933 return
13934
13935 def pack(self):
13936 packed = []
13937 packed.append(struct.pack("!B", self.version))
13938 packed.append(struct.pack("!B", self.type))
13939 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
13940 packed.append(struct.pack("!L", self.xid))
13941 packed.append(util.pack_port_no(self.port_no))
13942 packed.append('\x00' * 4)
13943 packed.append(struct.pack("!6B", *self.hw_addr))
13944 packed.append('\x00' * 2)
13945 packed.append(struct.pack("!L", self.config))
13946 packed.append(struct.pack("!L", self.mask))
13947 packed.append(loxi.generic_util.pack_list(self.properties))
13948 length = sum([len(x) for x in packed])
13949 packed[2] = struct.pack("!H", length)
13950 return ''.join(packed)
13951
13952 @staticmethod
13953 def unpack(reader):
13954 obj = port_mod()
13955 _version = reader.read("!B")[0]
13956 assert(_version == 5)
13957 _type = reader.read("!B")[0]
13958 assert(_type == 16)
13959 _length = reader.read("!H")[0]
13960 orig_reader = reader
13961 reader = orig_reader.slice(_length, 4)
13962 obj.xid = reader.read("!L")[0]
13963 obj.port_no = util.unpack_port_no(reader)
13964 reader.skip(4)
13965 obj.hw_addr = list(reader.read('!6B'))
13966 reader.skip(2)
13967 obj.config = reader.read("!L")[0]
13968 obj.mask = reader.read("!L")[0]
13969 obj.properties = loxi.generic_util.unpack_list(reader, ofp.port_mod_prop.port_mod_prop.unpack)
13970 return obj
13971
13972 def __eq__(self, other):
13973 if type(self) != type(other): return False
13974 if self.xid != other.xid: return False
13975 if self.port_no != other.port_no: return False
13976 if self.hw_addr != other.hw_addr: return False
13977 if self.config != other.config: return False
13978 if self.mask != other.mask: return False
13979 if self.properties != other.properties: return False
13980 return True
13981
13982 def pretty_print(self, q):
13983 q.text("port_mod {")
13984 with q.group():
13985 with q.indent(2):
13986 q.breakable()
13987 q.text("xid = ");
13988 if self.xid != None:
13989 q.text("%#x" % self.xid)
13990 else:
13991 q.text('None')
13992 q.text(","); q.breakable()
13993 q.text("port_no = ");
13994 q.text(util.pretty_port(self.port_no))
13995 q.text(","); q.breakable()
13996 q.text("hw_addr = ");
13997 q.text(util.pretty_mac(self.hw_addr))
13998 q.text(","); q.breakable()
13999 q.text("config = ");
14000 q.text("%#x" % self.config)
14001 q.text(","); q.breakable()
14002 q.text("mask = ");
14003 q.text("%#x" % self.mask)
14004 q.text(","); q.breakable()
14005 q.text("properties = ");
14006 q.pp(self.properties)
14007 q.breakable()
14008 q.text('}')
14009
14010message.subtypes[16] = port_mod
14011
14012class port_mod_failed_error_msg(error_msg):
14013 version = 5
14014 type = 1
14015 err_type = 7
14016
14017 def __init__(self, xid=None, code=None, data=None):
14018 if xid != None:
14019 self.xid = xid
14020 else:
14021 self.xid = None
14022 if code != None:
14023 self.code = code
14024 else:
14025 self.code = 0
14026 if data != None:
14027 self.data = data
14028 else:
14029 self.data = ''
14030 return
14031
14032 def pack(self):
14033 packed = []
14034 packed.append(struct.pack("!B", self.version))
14035 packed.append(struct.pack("!B", self.type))
14036 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14037 packed.append(struct.pack("!L", self.xid))
14038 packed.append(struct.pack("!H", self.err_type))
14039 packed.append(struct.pack("!H", self.code))
14040 packed.append(self.data)
14041 length = sum([len(x) for x in packed])
14042 packed[2] = struct.pack("!H", length)
14043 return ''.join(packed)
14044
14045 @staticmethod
14046 def unpack(reader):
14047 obj = port_mod_failed_error_msg()
14048 _version = reader.read("!B")[0]
14049 assert(_version == 5)
14050 _type = reader.read("!B")[0]
14051 assert(_type == 1)
14052 _length = reader.read("!H")[0]
14053 orig_reader = reader
14054 reader = orig_reader.slice(_length, 4)
14055 obj.xid = reader.read("!L")[0]
14056 _err_type = reader.read("!H")[0]
14057 assert(_err_type == 7)
14058 obj.code = reader.read("!H")[0]
14059 obj.data = str(reader.read_all())
14060 return obj
14061
14062 def __eq__(self, other):
14063 if type(self) != type(other): return False
14064 if self.xid != other.xid: return False
14065 if self.code != other.code: return False
14066 if self.data != other.data: return False
14067 return True
14068
14069 def pretty_print(self, q):
14070 q.text("port_mod_failed_error_msg {")
14071 with q.group():
14072 with q.indent(2):
14073 q.breakable()
14074 q.text("xid = ");
14075 if self.xid != None:
14076 q.text("%#x" % self.xid)
14077 else:
14078 q.text('None')
14079 q.text(","); q.breakable()
14080 q.text("code = ");
14081 q.text("%#x" % self.code)
14082 q.text(","); q.breakable()
14083 q.text("data = ");
14084 q.pp(self.data)
14085 q.breakable()
14086 q.text('}')
14087
14088error_msg.subtypes[7] = port_mod_failed_error_msg
14089
14090class port_stats_reply(stats_reply):
14091 version = 5
14092 type = 19
14093 stats_type = 4
14094
14095 def __init__(self, xid=None, flags=None, entries=None):
14096 if xid != None:
14097 self.xid = xid
14098 else:
14099 self.xid = None
14100 if flags != None:
14101 self.flags = flags
14102 else:
14103 self.flags = 0
14104 if entries != None:
14105 self.entries = entries
14106 else:
14107 self.entries = []
14108 return
14109
14110 def pack(self):
14111 packed = []
14112 packed.append(struct.pack("!B", self.version))
14113 packed.append(struct.pack("!B", self.type))
14114 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14115 packed.append(struct.pack("!L", self.xid))
14116 packed.append(struct.pack("!H", self.stats_type))
14117 packed.append(struct.pack("!H", self.flags))
14118 packed.append('\x00' * 4)
14119 packed.append(loxi.generic_util.pack_list(self.entries))
14120 length = sum([len(x) for x in packed])
14121 packed[2] = struct.pack("!H", length)
14122 return ''.join(packed)
14123
14124 @staticmethod
14125 def unpack(reader):
14126 obj = port_stats_reply()
14127 _version = reader.read("!B")[0]
14128 assert(_version == 5)
14129 _type = reader.read("!B")[0]
14130 assert(_type == 19)
14131 _length = reader.read("!H")[0]
14132 orig_reader = reader
14133 reader = orig_reader.slice(_length, 4)
14134 obj.xid = reader.read("!L")[0]
14135 _stats_type = reader.read("!H")[0]
14136 assert(_stats_type == 4)
14137 obj.flags = reader.read("!H")[0]
14138 reader.skip(4)
14139 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.port_stats_entry.unpack)
14140 return obj
14141
14142 def __eq__(self, other):
14143 if type(self) != type(other): return False
14144 if self.xid != other.xid: return False
14145 if self.flags != other.flags: return False
14146 if self.entries != other.entries: return False
14147 return True
14148
14149 def pretty_print(self, q):
14150 q.text("port_stats_reply {")
14151 with q.group():
14152 with q.indent(2):
14153 q.breakable()
14154 q.text("xid = ");
14155 if self.xid != None:
14156 q.text("%#x" % self.xid)
14157 else:
14158 q.text('None')
14159 q.text(","); q.breakable()
14160 q.text("flags = ");
14161 q.text("%#x" % self.flags)
14162 q.text(","); q.breakable()
14163 q.text("entries = ");
14164 q.pp(self.entries)
14165 q.breakable()
14166 q.text('}')
14167
14168stats_reply.subtypes[4] = port_stats_reply
14169
14170class port_stats_request(stats_request):
14171 version = 5
14172 type = 18
14173 stats_type = 4
14174
14175 def __init__(self, xid=None, flags=None, port_no=None):
14176 if xid != None:
14177 self.xid = xid
14178 else:
14179 self.xid = None
14180 if flags != None:
14181 self.flags = flags
14182 else:
14183 self.flags = 0
14184 if port_no != None:
14185 self.port_no = port_no
14186 else:
14187 self.port_no = 0
14188 return
14189
14190 def pack(self):
14191 packed = []
14192 packed.append(struct.pack("!B", self.version))
14193 packed.append(struct.pack("!B", self.type))
14194 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14195 packed.append(struct.pack("!L", self.xid))
14196 packed.append(struct.pack("!H", self.stats_type))
14197 packed.append(struct.pack("!H", self.flags))
14198 packed.append('\x00' * 4)
14199 packed.append(util.pack_port_no(self.port_no))
14200 packed.append('\x00' * 4)
14201 length = sum([len(x) for x in packed])
14202 packed[2] = struct.pack("!H", length)
14203 return ''.join(packed)
14204
14205 @staticmethod
14206 def unpack(reader):
14207 obj = port_stats_request()
14208 _version = reader.read("!B")[0]
14209 assert(_version == 5)
14210 _type = reader.read("!B")[0]
14211 assert(_type == 18)
14212 _length = reader.read("!H")[0]
14213 orig_reader = reader
14214 reader = orig_reader.slice(_length, 4)
14215 obj.xid = reader.read("!L")[0]
14216 _stats_type = reader.read("!H")[0]
14217 assert(_stats_type == 4)
14218 obj.flags = reader.read("!H")[0]
14219 reader.skip(4)
14220 obj.port_no = util.unpack_port_no(reader)
14221 reader.skip(4)
14222 return obj
14223
14224 def __eq__(self, other):
14225 if type(self) != type(other): return False
14226 if self.xid != other.xid: return False
14227 if self.flags != other.flags: return False
14228 if self.port_no != other.port_no: return False
14229 return True
14230
14231 def pretty_print(self, q):
14232 q.text("port_stats_request {")
14233 with q.group():
14234 with q.indent(2):
14235 q.breakable()
14236 q.text("xid = ");
14237 if self.xid != None:
14238 q.text("%#x" % self.xid)
14239 else:
14240 q.text('None')
14241 q.text(","); q.breakable()
14242 q.text("flags = ");
14243 q.text("%#x" % self.flags)
14244 q.text(","); q.breakable()
14245 q.text("port_no = ");
14246 q.text(util.pretty_port(self.port_no))
14247 q.breakable()
14248 q.text('}')
14249
14250stats_request.subtypes[4] = port_stats_request
14251
14252class port_status(message):
14253 version = 5
14254 type = 12
14255
14256 def __init__(self, xid=None, reason=None, desc=None):
14257 if xid != None:
14258 self.xid = xid
14259 else:
14260 self.xid = None
14261 if reason != None:
14262 self.reason = reason
14263 else:
14264 self.reason = 0
14265 if desc != None:
14266 self.desc = desc
14267 else:
14268 self.desc = ofp.port_desc()
14269 return
14270
14271 def pack(self):
14272 packed = []
14273 packed.append(struct.pack("!B", self.version))
14274 packed.append(struct.pack("!B", self.type))
14275 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14276 packed.append(struct.pack("!L", self.xid))
14277 packed.append(struct.pack("!B", self.reason))
14278 packed.append('\x00' * 7)
14279 packed.append(self.desc.pack())
14280 length = sum([len(x) for x in packed])
14281 packed[2] = struct.pack("!H", length)
14282 return ''.join(packed)
14283
14284 @staticmethod
14285 def unpack(reader):
14286 obj = port_status()
14287 _version = reader.read("!B")[0]
14288 assert(_version == 5)
14289 _type = reader.read("!B")[0]
14290 assert(_type == 12)
14291 _length = reader.read("!H")[0]
14292 orig_reader = reader
14293 reader = orig_reader.slice(_length, 4)
14294 obj.xid = reader.read("!L")[0]
14295 obj.reason = reader.read("!B")[0]
14296 reader.skip(7)
14297 obj.desc = ofp.port_desc.unpack(reader)
14298 return obj
14299
14300 def __eq__(self, other):
14301 if type(self) != type(other): return False
14302 if self.xid != other.xid: return False
14303 if self.reason != other.reason: return False
14304 if self.desc != other.desc: return False
14305 return True
14306
14307 def pretty_print(self, q):
14308 q.text("port_status {")
14309 with q.group():
14310 with q.indent(2):
14311 q.breakable()
14312 q.text("xid = ");
14313 if self.xid != None:
14314 q.text("%#x" % self.xid)
14315 else:
14316 q.text('None')
14317 q.text(","); q.breakable()
14318 q.text("reason = ");
14319 q.text("%#x" % self.reason)
14320 q.text(","); q.breakable()
14321 q.text("desc = ");
14322 q.pp(self.desc)
14323 q.breakable()
14324 q.text('}')
14325
14326message.subtypes[12] = port_status
14327
14328class queue_desc_stats_reply(stats_reply):
14329 version = 5
14330 type = 19
14331 stats_type = 15
14332
14333 def __init__(self, xid=None, flags=None, entries=None):
14334 if xid != None:
14335 self.xid = xid
14336 else:
14337 self.xid = None
14338 if flags != None:
14339 self.flags = flags
14340 else:
14341 self.flags = 0
14342 if entries != None:
14343 self.entries = entries
14344 else:
14345 self.entries = []
14346 return
14347
14348 def pack(self):
14349 packed = []
14350 packed.append(struct.pack("!B", self.version))
14351 packed.append(struct.pack("!B", self.type))
14352 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14353 packed.append(struct.pack("!L", self.xid))
14354 packed.append(struct.pack("!H", self.stats_type))
14355 packed.append(struct.pack("!H", self.flags))
14356 packed.append('\x00' * 4)
14357 packed.append(loxi.generic_util.pack_list(self.entries))
14358 length = sum([len(x) for x in packed])
14359 packed[2] = struct.pack("!H", length)
14360 return ''.join(packed)
14361
14362 @staticmethod
14363 def unpack(reader):
14364 obj = queue_desc_stats_reply()
14365 _version = reader.read("!B")[0]
14366 assert(_version == 5)
14367 _type = reader.read("!B")[0]
14368 assert(_type == 19)
14369 _length = reader.read("!H")[0]
14370 orig_reader = reader
14371 reader = orig_reader.slice(_length, 4)
14372 obj.xid = reader.read("!L")[0]
14373 _stats_type = reader.read("!H")[0]
14374 assert(_stats_type == 15)
14375 obj.flags = reader.read("!H")[0]
14376 reader.skip(4)
14377 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.queue_desc.unpack)
14378 return obj
14379
14380 def __eq__(self, other):
14381 if type(self) != type(other): return False
14382 if self.xid != other.xid: return False
14383 if self.flags != other.flags: return False
14384 if self.entries != other.entries: return False
14385 return True
14386
14387 def pretty_print(self, q):
14388 q.text("queue_desc_stats_reply {")
14389 with q.group():
14390 with q.indent(2):
14391 q.breakable()
14392 q.text("xid = ");
14393 if self.xid != None:
14394 q.text("%#x" % self.xid)
14395 else:
14396 q.text('None')
14397 q.text(","); q.breakable()
14398 q.text("flags = ");
14399 q.text("%#x" % self.flags)
14400 q.text(","); q.breakable()
14401 q.text("entries = ");
14402 q.pp(self.entries)
14403 q.breakable()
14404 q.text('}')
14405
14406stats_reply.subtypes[15] = queue_desc_stats_reply
14407
14408class queue_desc_stats_request(stats_request):
14409 version = 5
14410 type = 18
14411 stats_type = 15
14412
14413 def __init__(self, xid=None, flags=None):
14414 if xid != None:
14415 self.xid = xid
14416 else:
14417 self.xid = None
14418 if flags != None:
14419 self.flags = flags
14420 else:
14421 self.flags = 0
14422 return
14423
14424 def pack(self):
14425 packed = []
14426 packed.append(struct.pack("!B", self.version))
14427 packed.append(struct.pack("!B", self.type))
14428 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14429 packed.append(struct.pack("!L", self.xid))
14430 packed.append(struct.pack("!H", self.stats_type))
14431 packed.append(struct.pack("!H", self.flags))
14432 packed.append('\x00' * 4)
14433 length = sum([len(x) for x in packed])
14434 packed[2] = struct.pack("!H", length)
14435 return ''.join(packed)
14436
14437 @staticmethod
14438 def unpack(reader):
14439 obj = queue_desc_stats_request()
14440 _version = reader.read("!B")[0]
14441 assert(_version == 5)
14442 _type = reader.read("!B")[0]
14443 assert(_type == 18)
14444 _length = reader.read("!H")[0]
14445 orig_reader = reader
14446 reader = orig_reader.slice(_length, 4)
14447 obj.xid = reader.read("!L")[0]
14448 _stats_type = reader.read("!H")[0]
14449 assert(_stats_type == 15)
14450 obj.flags = reader.read("!H")[0]
14451 reader.skip(4)
14452 return obj
14453
14454 def __eq__(self, other):
14455 if type(self) != type(other): return False
14456 if self.xid != other.xid: return False
14457 if self.flags != other.flags: return False
14458 return True
14459
14460 def pretty_print(self, q):
14461 q.text("queue_desc_stats_request {")
14462 with q.group():
14463 with q.indent(2):
14464 q.breakable()
14465 q.text("xid = ");
14466 if self.xid != None:
14467 q.text("%#x" % self.xid)
14468 else:
14469 q.text('None')
14470 q.text(","); q.breakable()
14471 q.text("flags = ");
14472 q.text("%#x" % self.flags)
14473 q.breakable()
14474 q.text('}')
14475
14476stats_request.subtypes[15] = queue_desc_stats_request
14477
14478class queue_op_failed_error_msg(error_msg):
14479 version = 5
14480 type = 1
14481 err_type = 9
14482
14483 def __init__(self, xid=None, code=None, data=None):
14484 if xid != None:
14485 self.xid = xid
14486 else:
14487 self.xid = None
14488 if code != None:
14489 self.code = code
14490 else:
14491 self.code = 0
14492 if data != None:
14493 self.data = data
14494 else:
14495 self.data = ''
14496 return
14497
14498 def pack(self):
14499 packed = []
14500 packed.append(struct.pack("!B", self.version))
14501 packed.append(struct.pack("!B", self.type))
14502 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14503 packed.append(struct.pack("!L", self.xid))
14504 packed.append(struct.pack("!H", self.err_type))
14505 packed.append(struct.pack("!H", self.code))
14506 packed.append(self.data)
14507 length = sum([len(x) for x in packed])
14508 packed[2] = struct.pack("!H", length)
14509 return ''.join(packed)
14510
14511 @staticmethod
14512 def unpack(reader):
14513 obj = queue_op_failed_error_msg()
14514 _version = reader.read("!B")[0]
14515 assert(_version == 5)
14516 _type = reader.read("!B")[0]
14517 assert(_type == 1)
14518 _length = reader.read("!H")[0]
14519 orig_reader = reader
14520 reader = orig_reader.slice(_length, 4)
14521 obj.xid = reader.read("!L")[0]
14522 _err_type = reader.read("!H")[0]
14523 assert(_err_type == 9)
14524 obj.code = reader.read("!H")[0]
14525 obj.data = str(reader.read_all())
14526 return obj
14527
14528 def __eq__(self, other):
14529 if type(self) != type(other): return False
14530 if self.xid != other.xid: return False
14531 if self.code != other.code: return False
14532 if self.data != other.data: return False
14533 return True
14534
14535 def pretty_print(self, q):
14536 q.text("queue_op_failed_error_msg {")
14537 with q.group():
14538 with q.indent(2):
14539 q.breakable()
14540 q.text("xid = ");
14541 if self.xid != None:
14542 q.text("%#x" % self.xid)
14543 else:
14544 q.text('None')
14545 q.text(","); q.breakable()
14546 q.text("code = ");
14547 q.text("%#x" % self.code)
14548 q.text(","); q.breakable()
14549 q.text("data = ");
14550 q.pp(self.data)
14551 q.breakable()
14552 q.text('}')
14553
14554error_msg.subtypes[9] = queue_op_failed_error_msg
14555
14556class queue_stats_reply(stats_reply):
14557 version = 5
14558 type = 19
14559 stats_type = 5
14560
14561 def __init__(self, xid=None, flags=None, entries=None):
14562 if xid != None:
14563 self.xid = xid
14564 else:
14565 self.xid = None
14566 if flags != None:
14567 self.flags = flags
14568 else:
14569 self.flags = 0
14570 if entries != None:
14571 self.entries = entries
14572 else:
14573 self.entries = []
14574 return
14575
14576 def pack(self):
14577 packed = []
14578 packed.append(struct.pack("!B", self.version))
14579 packed.append(struct.pack("!B", self.type))
14580 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14581 packed.append(struct.pack("!L", self.xid))
14582 packed.append(struct.pack("!H", self.stats_type))
14583 packed.append(struct.pack("!H", self.flags))
14584 packed.append('\x00' * 4)
14585 packed.append(loxi.generic_util.pack_list(self.entries))
14586 length = sum([len(x) for x in packed])
14587 packed[2] = struct.pack("!H", length)
14588 return ''.join(packed)
14589
14590 @staticmethod
14591 def unpack(reader):
14592 obj = queue_stats_reply()
14593 _version = reader.read("!B")[0]
14594 assert(_version == 5)
14595 _type = reader.read("!B")[0]
14596 assert(_type == 19)
14597 _length = reader.read("!H")[0]
14598 orig_reader = reader
14599 reader = orig_reader.slice(_length, 4)
14600 obj.xid = reader.read("!L")[0]
14601 _stats_type = reader.read("!H")[0]
14602 assert(_stats_type == 5)
14603 obj.flags = reader.read("!H")[0]
14604 reader.skip(4)
14605 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.queue_stats_entry.unpack)
14606 return obj
14607
14608 def __eq__(self, other):
14609 if type(self) != type(other): return False
14610 if self.xid != other.xid: return False
14611 if self.flags != other.flags: return False
14612 if self.entries != other.entries: return False
14613 return True
14614
14615 def pretty_print(self, q):
14616 q.text("queue_stats_reply {")
14617 with q.group():
14618 with q.indent(2):
14619 q.breakable()
14620 q.text("xid = ");
14621 if self.xid != None:
14622 q.text("%#x" % self.xid)
14623 else:
14624 q.text('None')
14625 q.text(","); q.breakable()
14626 q.text("flags = ");
14627 q.text("%#x" % self.flags)
14628 q.text(","); q.breakable()
14629 q.text("entries = ");
14630 q.pp(self.entries)
14631 q.breakable()
14632 q.text('}')
14633
14634stats_reply.subtypes[5] = queue_stats_reply
14635
14636class queue_stats_request(stats_request):
14637 version = 5
14638 type = 18
14639 stats_type = 5
14640
14641 def __init__(self, xid=None, flags=None, port_no=None, queue_id=None):
14642 if xid != None:
14643 self.xid = xid
14644 else:
14645 self.xid = None
14646 if flags != None:
14647 self.flags = flags
14648 else:
14649 self.flags = 0
14650 if port_no != None:
14651 self.port_no = port_no
14652 else:
14653 self.port_no = 0
14654 if queue_id != None:
14655 self.queue_id = queue_id
14656 else:
14657 self.queue_id = 0
14658 return
14659
14660 def pack(self):
14661 packed = []
14662 packed.append(struct.pack("!B", self.version))
14663 packed.append(struct.pack("!B", self.type))
14664 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14665 packed.append(struct.pack("!L", self.xid))
14666 packed.append(struct.pack("!H", self.stats_type))
14667 packed.append(struct.pack("!H", self.flags))
14668 packed.append('\x00' * 4)
14669 packed.append(util.pack_port_no(self.port_no))
14670 packed.append(struct.pack("!L", self.queue_id))
14671 length = sum([len(x) for x in packed])
14672 packed[2] = struct.pack("!H", length)
14673 return ''.join(packed)
14674
14675 @staticmethod
14676 def unpack(reader):
14677 obj = queue_stats_request()
14678 _version = reader.read("!B")[0]
14679 assert(_version == 5)
14680 _type = reader.read("!B")[0]
14681 assert(_type == 18)
14682 _length = reader.read("!H")[0]
14683 orig_reader = reader
14684 reader = orig_reader.slice(_length, 4)
14685 obj.xid = reader.read("!L")[0]
14686 _stats_type = reader.read("!H")[0]
14687 assert(_stats_type == 5)
14688 obj.flags = reader.read("!H")[0]
14689 reader.skip(4)
14690 obj.port_no = util.unpack_port_no(reader)
14691 obj.queue_id = reader.read("!L")[0]
14692 return obj
14693
14694 def __eq__(self, other):
14695 if type(self) != type(other): return False
14696 if self.xid != other.xid: return False
14697 if self.flags != other.flags: return False
14698 if self.port_no != other.port_no: return False
14699 if self.queue_id != other.queue_id: return False
14700 return True
14701
14702 def pretty_print(self, q):
14703 q.text("queue_stats_request {")
14704 with q.group():
14705 with q.indent(2):
14706 q.breakable()
14707 q.text("xid = ");
14708 if self.xid != None:
14709 q.text("%#x" % self.xid)
14710 else:
14711 q.text('None')
14712 q.text(","); q.breakable()
14713 q.text("flags = ");
14714 q.text("%#x" % self.flags)
14715 q.text(","); q.breakable()
14716 q.text("port_no = ");
14717 q.text(util.pretty_port(self.port_no))
14718 q.text(","); q.breakable()
14719 q.text("queue_id = ");
14720 q.text("%#x" % self.queue_id)
14721 q.breakable()
14722 q.text('}')
14723
14724stats_request.subtypes[5] = queue_stats_request
14725
14726class requestforward(message):
14727 version = 5
14728 type = 32
14729
14730 def __init__(self, xid=None, role=None, data=None):
14731 if xid != None:
14732 self.xid = xid
14733 else:
14734 self.xid = None
14735 if role != None:
14736 self.role = role
14737 else:
14738 self.role = 0
14739 if data != None:
14740 self.data = data
14741 else:
14742 self.data = ''
14743 return
14744
14745 def pack(self):
14746 packed = []
14747 packed.append(struct.pack("!B", self.version))
14748 packed.append(struct.pack("!B", self.type))
14749 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14750 packed.append(struct.pack("!L", self.xid))
14751 packed.append(struct.pack("!L", self.role))
14752 packed.append(self.data)
14753 length = sum([len(x) for x in packed])
14754 packed[2] = struct.pack("!H", length)
14755 return ''.join(packed)
14756
14757 @staticmethod
14758 def unpack(reader):
14759 obj = requestforward()
14760 _version = reader.read("!B")[0]
14761 assert(_version == 5)
14762 _type = reader.read("!B")[0]
14763 assert(_type == 32)
14764 _length = reader.read("!H")[0]
14765 orig_reader = reader
14766 reader = orig_reader.slice(_length, 4)
14767 obj.xid = reader.read("!L")[0]
14768 obj.role = reader.read("!L")[0]
14769 obj.data = str(reader.read_all())
14770 return obj
14771
14772 def __eq__(self, other):
14773 if type(self) != type(other): return False
14774 if self.xid != other.xid: return False
14775 if self.role != other.role: return False
14776 if self.data != other.data: return False
14777 return True
14778
14779 def pretty_print(self, q):
14780 q.text("requestforward {")
14781 with q.group():
14782 with q.indent(2):
14783 q.breakable()
14784 q.text("xid = ");
14785 if self.xid != None:
14786 q.text("%#x" % self.xid)
14787 else:
14788 q.text('None')
14789 q.text(","); q.breakable()
14790 q.text("role = ");
14791 q.text("%#x" % self.role)
14792 q.text(","); q.breakable()
14793 q.text("data = ");
14794 q.pp(self.data)
14795 q.breakable()
14796 q.text('}')
14797
14798message.subtypes[32] = requestforward
14799
14800class role_reply(message):
14801 version = 5
14802 type = 25
14803
14804 def __init__(self, xid=None, role=None, generation_id=None):
14805 if xid != None:
14806 self.xid = xid
14807 else:
14808 self.xid = None
14809 if role != None:
14810 self.role = role
14811 else:
14812 self.role = 0
14813 if generation_id != None:
14814 self.generation_id = generation_id
14815 else:
14816 self.generation_id = 0
14817 return
14818
14819 def pack(self):
14820 packed = []
14821 packed.append(struct.pack("!B", self.version))
14822 packed.append(struct.pack("!B", self.type))
14823 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14824 packed.append(struct.pack("!L", self.xid))
14825 packed.append(struct.pack("!L", self.role))
14826 packed.append('\x00' * 4)
14827 packed.append(struct.pack("!Q", self.generation_id))
14828 length = sum([len(x) for x in packed])
14829 packed[2] = struct.pack("!H", length)
14830 return ''.join(packed)
14831
14832 @staticmethod
14833 def unpack(reader):
14834 obj = role_reply()
14835 _version = reader.read("!B")[0]
14836 assert(_version == 5)
14837 _type = reader.read("!B")[0]
14838 assert(_type == 25)
14839 _length = reader.read("!H")[0]
14840 orig_reader = reader
14841 reader = orig_reader.slice(_length, 4)
14842 obj.xid = reader.read("!L")[0]
14843 obj.role = reader.read("!L")[0]
14844 reader.skip(4)
14845 obj.generation_id = reader.read("!Q")[0]
14846 return obj
14847
14848 def __eq__(self, other):
14849 if type(self) != type(other): return False
14850 if self.xid != other.xid: return False
14851 if self.role != other.role: return False
14852 if self.generation_id != other.generation_id: return False
14853 return True
14854
14855 def pretty_print(self, q):
14856 q.text("role_reply {")
14857 with q.group():
14858 with q.indent(2):
14859 q.breakable()
14860 q.text("xid = ");
14861 if self.xid != None:
14862 q.text("%#x" % self.xid)
14863 else:
14864 q.text('None')
14865 q.text(","); q.breakable()
14866 q.text("role = ");
14867 q.text("%#x" % self.role)
14868 q.text(","); q.breakable()
14869 q.text("generation_id = ");
14870 q.text("%#x" % self.generation_id)
14871 q.breakable()
14872 q.text('}')
14873
14874message.subtypes[25] = role_reply
14875
14876class role_request(message):
14877 version = 5
14878 type = 24
14879
14880 def __init__(self, xid=None, role=None, generation_id=None):
14881 if xid != None:
14882 self.xid = xid
14883 else:
14884 self.xid = None
14885 if role != None:
14886 self.role = role
14887 else:
14888 self.role = 0
14889 if generation_id != None:
14890 self.generation_id = generation_id
14891 else:
14892 self.generation_id = 0
14893 return
14894
14895 def pack(self):
14896 packed = []
14897 packed.append(struct.pack("!B", self.version))
14898 packed.append(struct.pack("!B", self.type))
14899 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14900 packed.append(struct.pack("!L", self.xid))
14901 packed.append(struct.pack("!L", self.role))
14902 packed.append('\x00' * 4)
14903 packed.append(struct.pack("!Q", self.generation_id))
14904 length = sum([len(x) for x in packed])
14905 packed[2] = struct.pack("!H", length)
14906 return ''.join(packed)
14907
14908 @staticmethod
14909 def unpack(reader):
14910 obj = role_request()
14911 _version = reader.read("!B")[0]
14912 assert(_version == 5)
14913 _type = reader.read("!B")[0]
14914 assert(_type == 24)
14915 _length = reader.read("!H")[0]
14916 orig_reader = reader
14917 reader = orig_reader.slice(_length, 4)
14918 obj.xid = reader.read("!L")[0]
14919 obj.role = reader.read("!L")[0]
14920 reader.skip(4)
14921 obj.generation_id = reader.read("!Q")[0]
14922 return obj
14923
14924 def __eq__(self, other):
14925 if type(self) != type(other): return False
14926 if self.xid != other.xid: return False
14927 if self.role != other.role: return False
14928 if self.generation_id != other.generation_id: return False
14929 return True
14930
14931 def pretty_print(self, q):
14932 q.text("role_request {")
14933 with q.group():
14934 with q.indent(2):
14935 q.breakable()
14936 q.text("xid = ");
14937 if self.xid != None:
14938 q.text("%#x" % self.xid)
14939 else:
14940 q.text('None')
14941 q.text(","); q.breakable()
14942 q.text("role = ");
14943 q.text("%#x" % self.role)
14944 q.text(","); q.breakable()
14945 q.text("generation_id = ");
14946 q.text("%#x" % self.generation_id)
14947 q.breakable()
14948 q.text('}')
14949
14950message.subtypes[24] = role_request
14951
14952class role_request_failed_error_msg(error_msg):
14953 version = 5
14954 type = 1
14955 err_type = 11
14956
14957 def __init__(self, xid=None, code=None, data=None):
14958 if xid != None:
14959 self.xid = xid
14960 else:
14961 self.xid = None
14962 if code != None:
14963 self.code = code
14964 else:
14965 self.code = 0
14966 if data != None:
14967 self.data = data
14968 else:
14969 self.data = ''
14970 return
14971
14972 def pack(self):
14973 packed = []
14974 packed.append(struct.pack("!B", self.version))
14975 packed.append(struct.pack("!B", self.type))
14976 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
14977 packed.append(struct.pack("!L", self.xid))
14978 packed.append(struct.pack("!H", self.err_type))
14979 packed.append(struct.pack("!H", self.code))
14980 packed.append(self.data)
14981 length = sum([len(x) for x in packed])
14982 packed[2] = struct.pack("!H", length)
14983 return ''.join(packed)
14984
14985 @staticmethod
14986 def unpack(reader):
14987 obj = role_request_failed_error_msg()
14988 _version = reader.read("!B")[0]
14989 assert(_version == 5)
14990 _type = reader.read("!B")[0]
14991 assert(_type == 1)
14992 _length = reader.read("!H")[0]
14993 orig_reader = reader
14994 reader = orig_reader.slice(_length, 4)
14995 obj.xid = reader.read("!L")[0]
14996 _err_type = reader.read("!H")[0]
14997 assert(_err_type == 11)
14998 obj.code = reader.read("!H")[0]
14999 obj.data = str(reader.read_all())
15000 return obj
15001
15002 def __eq__(self, other):
15003 if type(self) != type(other): return False
15004 if self.xid != other.xid: return False
15005 if self.code != other.code: return False
15006 if self.data != other.data: return False
15007 return True
15008
15009 def pretty_print(self, q):
15010 q.text("role_request_failed_error_msg {")
15011 with q.group():
15012 with q.indent(2):
15013 q.breakable()
15014 q.text("xid = ");
15015 if self.xid != None:
15016 q.text("%#x" % self.xid)
15017 else:
15018 q.text('None')
15019 q.text(","); q.breakable()
15020 q.text("code = ");
15021 q.text("%#x" % self.code)
15022 q.text(","); q.breakable()
15023 q.text("data = ");
15024 q.pp(self.data)
15025 q.breakable()
15026 q.text('}')
15027
15028error_msg.subtypes[11] = role_request_failed_error_msg
15029
15030class role_status(message):
15031 version = 5
15032 type = 30
15033
15034 def __init__(self, xid=None, role=None, reason=None, generation_id=None, properties=None):
15035 if xid != None:
15036 self.xid = xid
15037 else:
15038 self.xid = None
15039 if role != None:
15040 self.role = role
15041 else:
15042 self.role = 0
15043 if reason != None:
15044 self.reason = reason
15045 else:
15046 self.reason = 0
15047 if generation_id != None:
15048 self.generation_id = generation_id
15049 else:
15050 self.generation_id = 0
15051 if properties != None:
15052 self.properties = properties
15053 else:
15054 self.properties = []
15055 return
15056
15057 def pack(self):
15058 packed = []
15059 packed.append(struct.pack("!B", self.version))
15060 packed.append(struct.pack("!B", self.type))
15061 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
15062 packed.append(struct.pack("!L", self.xid))
15063 packed.append(struct.pack("!L", self.role))
15064 packed.append(struct.pack("!B", self.reason))
15065 packed.append('\x00' * 3)
15066 packed.append(struct.pack("!Q", self.generation_id))
15067 packed.append(loxi.generic_util.pack_list(self.properties))
15068 length = sum([len(x) for x in packed])
15069 packed[2] = struct.pack("!H", length)
15070 return ''.join(packed)
15071
15072 @staticmethod
15073 def unpack(reader):
15074 obj = role_status()
15075 _version = reader.read("!B")[0]
15076 assert(_version == 5)
15077 _type = reader.read("!B")[0]
15078 assert(_type == 30)
15079 _length = reader.read("!H")[0]
15080 orig_reader = reader
15081 reader = orig_reader.slice(_length, 4)
15082 obj.xid = reader.read("!L")[0]
15083 obj.role = reader.read("!L")[0]
15084 obj.reason = reader.read("!B")[0]
15085 reader.skip(3)
15086 obj.generation_id = reader.read("!Q")[0]
15087 obj.properties = loxi.generic_util.unpack_list(reader, ofp.role_prop.role_prop.unpack)
15088 return obj
15089
15090 def __eq__(self, other):
15091 if type(self) != type(other): return False
15092 if self.xid != other.xid: return False
15093 if self.role != other.role: return False
15094 if self.reason != other.reason: return False
15095 if self.generation_id != other.generation_id: return False
15096 if self.properties != other.properties: return False
15097 return True
15098
15099 def pretty_print(self, q):
15100 q.text("role_status {")
15101 with q.group():
15102 with q.indent(2):
15103 q.breakable()
15104 q.text("xid = ");
15105 if self.xid != None:
15106 q.text("%#x" % self.xid)
15107 else:
15108 q.text('None')
15109 q.text(","); q.breakable()
15110 q.text("role = ");
15111 q.text("%#x" % self.role)
15112 q.text(","); q.breakable()
15113 q.text("reason = ");
15114 q.text("%#x" % self.reason)
15115 q.text(","); q.breakable()
15116 q.text("generation_id = ");
15117 q.text("%#x" % self.generation_id)
15118 q.text(","); q.breakable()
15119 q.text("properties = ");
15120 q.pp(self.properties)
15121 q.breakable()
15122 q.text('}')
15123
15124message.subtypes[30] = role_status
15125
15126class set_config(message):
15127 version = 5
15128 type = 9
15129
15130 def __init__(self, xid=None, flags=None, miss_send_len=None):
15131 if xid != None:
15132 self.xid = xid
15133 else:
15134 self.xid = None
15135 if flags != None:
15136 self.flags = flags
15137 else:
15138 self.flags = 0
15139 if miss_send_len != None:
15140 self.miss_send_len = miss_send_len
15141 else:
15142 self.miss_send_len = 0
15143 return
15144
15145 def pack(self):
15146 packed = []
15147 packed.append(struct.pack("!B", self.version))
15148 packed.append(struct.pack("!B", self.type))
15149 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
15150 packed.append(struct.pack("!L", self.xid))
15151 packed.append(struct.pack("!H", self.flags))
15152 packed.append(struct.pack("!H", self.miss_send_len))
15153 length = sum([len(x) for x in packed])
15154 packed[2] = struct.pack("!H", length)
15155 return ''.join(packed)
15156
15157 @staticmethod
15158 def unpack(reader):
15159 obj = set_config()
15160 _version = reader.read("!B")[0]
15161 assert(_version == 5)
15162 _type = reader.read("!B")[0]
15163 assert(_type == 9)
15164 _length = reader.read("!H")[0]
15165 orig_reader = reader
15166 reader = orig_reader.slice(_length, 4)
15167 obj.xid = reader.read("!L")[0]
15168 obj.flags = reader.read("!H")[0]
15169 obj.miss_send_len = reader.read("!H")[0]
15170 return obj
15171
15172 def __eq__(self, other):
15173 if type(self) != type(other): return False
15174 if self.xid != other.xid: return False
15175 if self.flags != other.flags: return False
15176 if self.miss_send_len != other.miss_send_len: return False
15177 return True
15178
15179 def pretty_print(self, q):
15180 q.text("set_config {")
15181 with q.group():
15182 with q.indent(2):
15183 q.breakable()
15184 q.text("xid = ");
15185 if self.xid != None:
15186 q.text("%#x" % self.xid)
15187 else:
15188 q.text('None')
15189 q.text(","); q.breakable()
15190 q.text("flags = ");
15191 q.text("%#x" % self.flags)
15192 q.text(","); q.breakable()
15193 q.text("miss_send_len = ");
15194 q.text("%#x" % self.miss_send_len)
15195 q.breakable()
15196 q.text('}')
15197
15198message.subtypes[9] = set_config
15199
15200class switch_config_failed_error_msg(error_msg):
15201 version = 5
15202 type = 1
15203 err_type = 10
15204
15205 def __init__(self, xid=None, code=None, data=None):
15206 if xid != None:
15207 self.xid = xid
15208 else:
15209 self.xid = None
15210 if code != None:
15211 self.code = code
15212 else:
15213 self.code = 0
15214 if data != None:
15215 self.data = data
15216 else:
15217 self.data = ''
15218 return
15219
15220 def pack(self):
15221 packed = []
15222 packed.append(struct.pack("!B", self.version))
15223 packed.append(struct.pack("!B", self.type))
15224 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
15225 packed.append(struct.pack("!L", self.xid))
15226 packed.append(struct.pack("!H", self.err_type))
15227 packed.append(struct.pack("!H", self.code))
15228 packed.append(self.data)
15229 length = sum([len(x) for x in packed])
15230 packed[2] = struct.pack("!H", length)
15231 return ''.join(packed)
15232
15233 @staticmethod
15234 def unpack(reader):
15235 obj = switch_config_failed_error_msg()
15236 _version = reader.read("!B")[0]
15237 assert(_version == 5)
15238 _type = reader.read("!B")[0]
15239 assert(_type == 1)
15240 _length = reader.read("!H")[0]
15241 orig_reader = reader
15242 reader = orig_reader.slice(_length, 4)
15243 obj.xid = reader.read("!L")[0]
15244 _err_type = reader.read("!H")[0]
15245 assert(_err_type == 10)
15246 obj.code = reader.read("!H")[0]
15247 obj.data = str(reader.read_all())
15248 return obj
15249
15250 def __eq__(self, other):
15251 if type(self) != type(other): return False
15252 if self.xid != other.xid: return False
15253 if self.code != other.code: return False
15254 if self.data != other.data: return False
15255 return True
15256
15257 def pretty_print(self, q):
15258 q.text("switch_config_failed_error_msg {")
15259 with q.group():
15260 with q.indent(2):
15261 q.breakable()
15262 q.text("xid = ");
15263 if self.xid != None:
15264 q.text("%#x" % self.xid)
15265 else:
15266 q.text('None')
15267 q.text(","); q.breakable()
15268 q.text("code = ");
15269 q.text("%#x" % self.code)
15270 q.text(","); q.breakable()
15271 q.text("data = ");
15272 q.pp(self.data)
15273 q.breakable()
15274 q.text('}')
15275
15276error_msg.subtypes[10] = switch_config_failed_error_msg
15277
15278class table_desc_stats_reply(stats_reply):
15279 version = 5
15280 type = 19
15281 stats_type = 14
15282
15283 def __init__(self, xid=None, flags=None, entries=None):
15284 if xid != None:
15285 self.xid = xid
15286 else:
15287 self.xid = None
15288 if flags != None:
15289 self.flags = flags
15290 else:
15291 self.flags = 0
15292 if entries != None:
15293 self.entries = entries
15294 else:
15295 self.entries = []
15296 return
15297
15298 def pack(self):
15299 packed = []
15300 packed.append(struct.pack("!B", self.version))
15301 packed.append(struct.pack("!B", self.type))
15302 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
15303 packed.append(struct.pack("!L", self.xid))
15304 packed.append(struct.pack("!H", self.stats_type))
15305 packed.append(struct.pack("!H", self.flags))
15306 packed.append('\x00' * 4)
15307 packed.append(loxi.generic_util.pack_list(self.entries))
15308 length = sum([len(x) for x in packed])
15309 packed[2] = struct.pack("!H", length)
15310 return ''.join(packed)
15311
15312 @staticmethod
15313 def unpack(reader):
15314 obj = table_desc_stats_reply()
15315 _version = reader.read("!B")[0]
15316 assert(_version == 5)
15317 _type = reader.read("!B")[0]
15318 assert(_type == 19)
15319 _length = reader.read("!H")[0]
15320 orig_reader = reader
15321 reader = orig_reader.slice(_length, 4)
15322 obj.xid = reader.read("!L")[0]
15323 _stats_type = reader.read("!H")[0]
15324 assert(_stats_type == 14)
15325 obj.flags = reader.read("!H")[0]
15326 reader.skip(4)
15327 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_desc.unpack)
15328 return obj
15329
15330 def __eq__(self, other):
15331 if type(self) != type(other): return False
15332 if self.xid != other.xid: return False
15333 if self.flags != other.flags: return False
15334 if self.entries != other.entries: return False
15335 return True
15336
15337 def pretty_print(self, q):
15338 q.text("table_desc_stats_reply {")
15339 with q.group():
15340 with q.indent(2):
15341 q.breakable()
15342 q.text("xid = ");
15343 if self.xid != None:
15344 q.text("%#x" % self.xid)
15345 else:
15346 q.text('None')
15347 q.text(","); q.breakable()
15348 q.text("flags = ");
15349 q.text("%#x" % self.flags)
15350 q.text(","); q.breakable()
15351 q.text("entries = ");
15352 q.pp(self.entries)
15353 q.breakable()
15354 q.text('}')
15355
15356stats_reply.subtypes[14] = table_desc_stats_reply
15357
15358class table_desc_stats_request(stats_request):
15359 version = 5
15360 type = 18
15361 stats_type = 14
15362
15363 def __init__(self, xid=None, flags=None):
15364 if xid != None:
15365 self.xid = xid
15366 else:
15367 self.xid = None
15368 if flags != None:
15369 self.flags = flags
15370 else:
15371 self.flags = 0
15372 return
15373
15374 def pack(self):
15375 packed = []
15376 packed.append(struct.pack("!B", self.version))
15377 packed.append(struct.pack("!B", self.type))
15378 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
15379 packed.append(struct.pack("!L", self.xid))
15380 packed.append(struct.pack("!H", self.stats_type))
15381 packed.append(struct.pack("!H", self.flags))
15382 packed.append('\x00' * 4)
15383 length = sum([len(x) for x in packed])
15384 packed[2] = struct.pack("!H", length)
15385 return ''.join(packed)
15386
15387 @staticmethod
15388 def unpack(reader):
15389 obj = table_desc_stats_request()
15390 _version = reader.read("!B")[0]
15391 assert(_version == 5)
15392 _type = reader.read("!B")[0]
15393 assert(_type == 18)
15394 _length = reader.read("!H")[0]
15395 orig_reader = reader
15396 reader = orig_reader.slice(_length, 4)
15397 obj.xid = reader.read("!L")[0]
15398 _stats_type = reader.read("!H")[0]
15399 assert(_stats_type == 14)
15400 obj.flags = reader.read("!H")[0]
15401 reader.skip(4)
15402 return obj
15403
15404 def __eq__(self, other):
15405 if type(self) != type(other): return False
15406 if self.xid != other.xid: return False
15407 if self.flags != other.flags: return False
15408 return True
15409
15410 def pretty_print(self, q):
15411 q.text("table_desc_stats_request {")
15412 with q.group():
15413 with q.indent(2):
15414 q.breakable()
15415 q.text("xid = ");
15416 if self.xid != None:
15417 q.text("%#x" % self.xid)
15418 else:
15419 q.text('None')
15420 q.text(","); q.breakable()
15421 q.text("flags = ");
15422 q.text("%#x" % self.flags)
15423 q.breakable()
15424 q.text('}')
15425
15426stats_request.subtypes[14] = table_desc_stats_request
15427
15428class table_features_failed_error_msg(error_msg):
15429 version = 5
15430 type = 1
15431 err_type = 13
15432
15433 def __init__(self, xid=None, code=None, data=None):
15434 if xid != None:
15435 self.xid = xid
15436 else:
15437 self.xid = None
15438 if code != None:
15439 self.code = code
15440 else:
15441 self.code = 0
15442 if data != None:
15443 self.data = data
15444 else:
15445 self.data = ''
15446 return
15447
15448 def pack(self):
15449 packed = []
15450 packed.append(struct.pack("!B", self.version))
15451 packed.append(struct.pack("!B", self.type))
15452 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
15453 packed.append(struct.pack("!L", self.xid))
15454 packed.append(struct.pack("!H", self.err_type))
15455 packed.append(struct.pack("!H", self.code))
15456 packed.append(self.data)
15457 length = sum([len(x) for x in packed])
15458 packed[2] = struct.pack("!H", length)
15459 return ''.join(packed)
15460
15461 @staticmethod
15462 def unpack(reader):
15463 obj = table_features_failed_error_msg()
15464 _version = reader.read("!B")[0]
15465 assert(_version == 5)
15466 _type = reader.read("!B")[0]
15467 assert(_type == 1)
15468 _length = reader.read("!H")[0]
15469 orig_reader = reader
15470 reader = orig_reader.slice(_length, 4)
15471 obj.xid = reader.read("!L")[0]
15472 _err_type = reader.read("!H")[0]
15473 assert(_err_type == 13)
15474 obj.code = reader.read("!H")[0]
15475 obj.data = str(reader.read_all())
15476 return obj
15477
15478 def __eq__(self, other):
15479 if type(self) != type(other): return False
15480 if self.xid != other.xid: return False
15481 if self.code != other.code: return False
15482 if self.data != other.data: return False
15483 return True
15484
15485 def pretty_print(self, q):
15486 q.text("table_features_failed_error_msg {")
15487 with q.group():
15488 with q.indent(2):
15489 q.breakable()
15490 q.text("xid = ");
15491 if self.xid != None:
15492 q.text("%#x" % self.xid)
15493 else:
15494 q.text('None')
15495 q.text(","); q.breakable()
15496 q.text("code = ");
15497 q.text("%#x" % self.code)
15498 q.text(","); q.breakable()
15499 q.text("data = ");
15500 q.pp(self.data)
15501 q.breakable()
15502 q.text('}')
15503
15504error_msg.subtypes[13] = table_features_failed_error_msg
15505
15506class table_features_stats_reply(stats_reply):
15507 version = 5
15508 type = 19
15509 stats_type = 12
15510
15511 def __init__(self, xid=None, flags=None, entries=None):
15512 if xid != None:
15513 self.xid = xid
15514 else:
15515 self.xid = None
15516 if flags != None:
15517 self.flags = flags
15518 else:
15519 self.flags = 0
15520 if entries != None:
15521 self.entries = entries
15522 else:
15523 self.entries = []
15524 return
15525
15526 def pack(self):
15527 packed = []
15528 packed.append(struct.pack("!B", self.version))
15529 packed.append(struct.pack("!B", self.type))
15530 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
15531 packed.append(struct.pack("!L", self.xid))
15532 packed.append(struct.pack("!H", self.stats_type))
15533 packed.append(struct.pack("!H", self.flags))
15534 packed.append('\x00' * 4)
15535 packed.append(loxi.generic_util.pack_list(self.entries))
15536 length = sum([len(x) for x in packed])
15537 packed[2] = struct.pack("!H", length)
15538 return ''.join(packed)
15539
15540 @staticmethod
15541 def unpack(reader):
15542 obj = table_features_stats_reply()
15543 _version = reader.read("!B")[0]
15544 assert(_version == 5)
15545 _type = reader.read("!B")[0]
15546 assert(_type == 19)
15547 _length = reader.read("!H")[0]
15548 orig_reader = reader
15549 reader = orig_reader.slice(_length, 4)
15550 obj.xid = reader.read("!L")[0]
15551 _stats_type = reader.read("!H")[0]
15552 assert(_stats_type == 12)
15553 obj.flags = reader.read("!H")[0]
15554 reader.skip(4)
15555 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_features.unpack)
15556 return obj
15557
15558 def __eq__(self, other):
15559 if type(self) != type(other): return False
15560 if self.xid != other.xid: return False
15561 if self.flags != other.flags: return False
15562 if self.entries != other.entries: return False
15563 return True
15564
15565 def pretty_print(self, q):
15566 q.text("table_features_stats_reply {")
15567 with q.group():
15568 with q.indent(2):
15569 q.breakable()
15570 q.text("xid = ");
15571 if self.xid != None:
15572 q.text("%#x" % self.xid)
15573 else:
15574 q.text('None')
15575 q.text(","); q.breakable()
15576 q.text("flags = ");
15577 q.text("%#x" % self.flags)
15578 q.text(","); q.breakable()
15579 q.text("entries = ");
15580 q.pp(self.entries)
15581 q.breakable()
15582 q.text('}')
15583
15584stats_reply.subtypes[12] = table_features_stats_reply
15585
15586class table_features_stats_request(stats_request):
15587 version = 5
15588 type = 18
15589 stats_type = 12
15590
15591 def __init__(self, xid=None, flags=None, entries=None):
15592 if xid != None:
15593 self.xid = xid
15594 else:
15595 self.xid = None
15596 if flags != None:
15597 self.flags = flags
15598 else:
15599 self.flags = 0
15600 if entries != None:
15601 self.entries = entries
15602 else:
15603 self.entries = []
15604 return
15605
15606 def pack(self):
15607 packed = []
15608 packed.append(struct.pack("!B", self.version))
15609 packed.append(struct.pack("!B", self.type))
15610 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
15611 packed.append(struct.pack("!L", self.xid))
15612 packed.append(struct.pack("!H", self.stats_type))
15613 packed.append(struct.pack("!H", self.flags))
15614 packed.append('\x00' * 4)
15615 packed.append(loxi.generic_util.pack_list(self.entries))
15616 length = sum([len(x) for x in packed])
15617 packed[2] = struct.pack("!H", length)
15618 return ''.join(packed)
15619
15620 @staticmethod
15621 def unpack(reader):
15622 obj = table_features_stats_request()
15623 _version = reader.read("!B")[0]
15624 assert(_version == 5)
15625 _type = reader.read("!B")[0]
15626 assert(_type == 18)
15627 _length = reader.read("!H")[0]
15628 orig_reader = reader
15629 reader = orig_reader.slice(_length, 4)
15630 obj.xid = reader.read("!L")[0]
15631 _stats_type = reader.read("!H")[0]
15632 assert(_stats_type == 12)
15633 obj.flags = reader.read("!H")[0]
15634 reader.skip(4)
15635 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_features.unpack)
15636 return obj
15637
15638 def __eq__(self, other):
15639 if type(self) != type(other): return False
15640 if self.xid != other.xid: return False
15641 if self.flags != other.flags: return False
15642 if self.entries != other.entries: return False
15643 return True
15644
15645 def pretty_print(self, q):
15646 q.text("table_features_stats_request {")
15647 with q.group():
15648 with q.indent(2):
15649 q.breakable()
15650 q.text("xid = ");
15651 if self.xid != None:
15652 q.text("%#x" % self.xid)
15653 else:
15654 q.text('None')
15655 q.text(","); q.breakable()
15656 q.text("flags = ");
15657 q.text("%#x" % self.flags)
15658 q.text(","); q.breakable()
15659 q.text("entries = ");
15660 q.pp(self.entries)
15661 q.breakable()
15662 q.text('}')
15663
15664stats_request.subtypes[12] = table_features_stats_request
15665
15666class table_mod(message):
15667 version = 5
15668 type = 17
15669
15670 def __init__(self, xid=None, table_id=None, config=None, properties=None):
15671 if xid != None:
15672 self.xid = xid
15673 else:
15674 self.xid = None
15675 if table_id != None:
15676 self.table_id = table_id
15677 else:
15678 self.table_id = 0
15679 if config != None:
15680 self.config = config
15681 else:
15682 self.config = 0
15683 if properties != None:
15684 self.properties = properties
15685 else:
15686 self.properties = []
15687 return
15688
15689 def pack(self):
15690 packed = []
15691 packed.append(struct.pack("!B", self.version))
15692 packed.append(struct.pack("!B", self.type))
15693 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
15694 packed.append(struct.pack("!L", self.xid))
15695 packed.append(struct.pack("!B", self.table_id))
15696 packed.append('\x00' * 3)
15697 packed.append(struct.pack("!L", self.config))
15698 packed.append(loxi.generic_util.pack_list(self.properties))
15699 length = sum([len(x) for x in packed])
15700 packed[2] = struct.pack("!H", length)
15701 return ''.join(packed)
15702
15703 @staticmethod
15704 def unpack(reader):
15705 obj = table_mod()
15706 _version = reader.read("!B")[0]
15707 assert(_version == 5)
15708 _type = reader.read("!B")[0]
15709 assert(_type == 17)
15710 _length = reader.read("!H")[0]
15711 orig_reader = reader
15712 reader = orig_reader.slice(_length, 4)
15713 obj.xid = reader.read("!L")[0]
15714 obj.table_id = reader.read("!B")[0]
15715 reader.skip(3)
15716 obj.config = reader.read("!L")[0]
15717 obj.properties = loxi.generic_util.unpack_list(reader, ofp.table_mod_prop.table_mod_prop.unpack)
15718 return obj
15719
15720 def __eq__(self, other):
15721 if type(self) != type(other): return False
15722 if self.xid != other.xid: return False
15723 if self.table_id != other.table_id: return False
15724 if self.config != other.config: return False
15725 if self.properties != other.properties: return False
15726 return True
15727
15728 def pretty_print(self, q):
15729 q.text("table_mod {")
15730 with q.group():
15731 with q.indent(2):
15732 q.breakable()
15733 q.text("xid = ");
15734 if self.xid != None:
15735 q.text("%#x" % self.xid)
15736 else:
15737 q.text('None')
15738 q.text(","); q.breakable()
15739 q.text("table_id = ");
15740 q.text("%#x" % self.table_id)
15741 q.text(","); q.breakable()
15742 q.text("config = ");
15743 q.text("%#x" % self.config)
15744 q.text(","); q.breakable()
15745 q.text("properties = ");
15746 q.pp(self.properties)
15747 q.breakable()
15748 q.text('}')
15749
15750message.subtypes[17] = table_mod
15751
15752class table_mod_failed_error_msg(error_msg):
15753 version = 5
15754 type = 1
15755 err_type = 8
15756
15757 def __init__(self, xid=None, code=None, data=None):
15758 if xid != None:
15759 self.xid = xid
15760 else:
15761 self.xid = None
15762 if code != None:
15763 self.code = code
15764 else:
15765 self.code = 0
15766 if data != None:
15767 self.data = data
15768 else:
15769 self.data = ''
15770 return
15771
15772 def pack(self):
15773 packed = []
15774 packed.append(struct.pack("!B", self.version))
15775 packed.append(struct.pack("!B", self.type))
15776 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
15777 packed.append(struct.pack("!L", self.xid))
15778 packed.append(struct.pack("!H", self.err_type))
15779 packed.append(struct.pack("!H", self.code))
15780 packed.append(self.data)
15781 length = sum([len(x) for x in packed])
15782 packed[2] = struct.pack("!H", length)
15783 return ''.join(packed)
15784
15785 @staticmethod
15786 def unpack(reader):
15787 obj = table_mod_failed_error_msg()
15788 _version = reader.read("!B")[0]
15789 assert(_version == 5)
15790 _type = reader.read("!B")[0]
15791 assert(_type == 1)
15792 _length = reader.read("!H")[0]
15793 orig_reader = reader
15794 reader = orig_reader.slice(_length, 4)
15795 obj.xid = reader.read("!L")[0]
15796 _err_type = reader.read("!H")[0]
15797 assert(_err_type == 8)
15798 obj.code = reader.read("!H")[0]
15799 obj.data = str(reader.read_all())
15800 return obj
15801
15802 def __eq__(self, other):
15803 if type(self) != type(other): return False
15804 if self.xid != other.xid: return False
15805 if self.code != other.code: return False
15806 if self.data != other.data: return False
15807 return True
15808
15809 def pretty_print(self, q):
15810 q.text("table_mod_failed_error_msg {")
15811 with q.group():
15812 with q.indent(2):
15813 q.breakable()
15814 q.text("xid = ");
15815 if self.xid != None:
15816 q.text("%#x" % self.xid)
15817 else:
15818 q.text('None')
15819 q.text(","); q.breakable()
15820 q.text("code = ");
15821 q.text("%#x" % self.code)
15822 q.text(","); q.breakable()
15823 q.text("data = ");
15824 q.pp(self.data)
15825 q.breakable()
15826 q.text('}')
15827
15828error_msg.subtypes[8] = table_mod_failed_error_msg
15829
15830class table_stats_reply(stats_reply):
15831 version = 5
15832 type = 19
15833 stats_type = 3
15834
15835 def __init__(self, xid=None, flags=None, entries=None):
15836 if xid != None:
15837 self.xid = xid
15838 else:
15839 self.xid = None
15840 if flags != None:
15841 self.flags = flags
15842 else:
15843 self.flags = 0
15844 if entries != None:
15845 self.entries = entries
15846 else:
15847 self.entries = []
15848 return
15849
15850 def pack(self):
15851 packed = []
15852 packed.append(struct.pack("!B", self.version))
15853 packed.append(struct.pack("!B", self.type))
15854 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
15855 packed.append(struct.pack("!L", self.xid))
15856 packed.append(struct.pack("!H", self.stats_type))
15857 packed.append(struct.pack("!H", self.flags))
15858 packed.append('\x00' * 4)
15859 packed.append(loxi.generic_util.pack_list(self.entries))
15860 length = sum([len(x) for x in packed])
15861 packed[2] = struct.pack("!H", length)
15862 return ''.join(packed)
15863
15864 @staticmethod
15865 def unpack(reader):
15866 obj = table_stats_reply()
15867 _version = reader.read("!B")[0]
15868 assert(_version == 5)
15869 _type = reader.read("!B")[0]
15870 assert(_type == 19)
15871 _length = reader.read("!H")[0]
15872 orig_reader = reader
15873 reader = orig_reader.slice(_length, 4)
15874 obj.xid = reader.read("!L")[0]
15875 _stats_type = reader.read("!H")[0]
15876 assert(_stats_type == 3)
15877 obj.flags = reader.read("!H")[0]
15878 reader.skip(4)
15879 obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_stats_entry.unpack)
15880 return obj
15881
15882 def __eq__(self, other):
15883 if type(self) != type(other): return False
15884 if self.xid != other.xid: return False
15885 if self.flags != other.flags: return False
15886 if self.entries != other.entries: return False
15887 return True
15888
15889 def pretty_print(self, q):
15890 q.text("table_stats_reply {")
15891 with q.group():
15892 with q.indent(2):
15893 q.breakable()
15894 q.text("xid = ");
15895 if self.xid != None:
15896 q.text("%#x" % self.xid)
15897 else:
15898 q.text('None')
15899 q.text(","); q.breakable()
15900 q.text("flags = ");
15901 q.text("%#x" % self.flags)
15902 q.text(","); q.breakable()
15903 q.text("entries = ");
15904 q.pp(self.entries)
15905 q.breakable()
15906 q.text('}')
15907
15908stats_reply.subtypes[3] = table_stats_reply
15909
15910class table_stats_request(stats_request):
15911 version = 5
15912 type = 18
15913 stats_type = 3
15914
15915 def __init__(self, xid=None, flags=None):
15916 if xid != None:
15917 self.xid = xid
15918 else:
15919 self.xid = None
15920 if flags != None:
15921 self.flags = flags
15922 else:
15923 self.flags = 0
15924 return
15925
15926 def pack(self):
15927 packed = []
15928 packed.append(struct.pack("!B", self.version))
15929 packed.append(struct.pack("!B", self.type))
15930 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
15931 packed.append(struct.pack("!L", self.xid))
15932 packed.append(struct.pack("!H", self.stats_type))
15933 packed.append(struct.pack("!H", self.flags))
15934 packed.append('\x00' * 4)
15935 length = sum([len(x) for x in packed])
15936 packed[2] = struct.pack("!H", length)
15937 return ''.join(packed)
15938
15939 @staticmethod
15940 def unpack(reader):
15941 obj = table_stats_request()
15942 _version = reader.read("!B")[0]
15943 assert(_version == 5)
15944 _type = reader.read("!B")[0]
15945 assert(_type == 18)
15946 _length = reader.read("!H")[0]
15947 orig_reader = reader
15948 reader = orig_reader.slice(_length, 4)
15949 obj.xid = reader.read("!L")[0]
15950 _stats_type = reader.read("!H")[0]
15951 assert(_stats_type == 3)
15952 obj.flags = reader.read("!H")[0]
15953 reader.skip(4)
15954 return obj
15955
15956 def __eq__(self, other):
15957 if type(self) != type(other): return False
15958 if self.xid != other.xid: return False
15959 if self.flags != other.flags: return False
15960 return True
15961
15962 def pretty_print(self, q):
15963 q.text("table_stats_request {")
15964 with q.group():
15965 with q.indent(2):
15966 q.breakable()
15967 q.text("xid = ");
15968 if self.xid != None:
15969 q.text("%#x" % self.xid)
15970 else:
15971 q.text('None')
15972 q.text(","); q.breakable()
15973 q.text("flags = ");
15974 q.text("%#x" % self.flags)
15975 q.breakable()
15976 q.text('}')
15977
15978stats_request.subtypes[3] = table_stats_request
15979
15980class table_status(message):
15981 version = 5
15982 type = 31
15983
15984 def __init__(self, xid=None, role=None, reason=None, table=None):
15985 if xid != None:
15986 self.xid = xid
15987 else:
15988 self.xid = None
15989 if role != None:
15990 self.role = role
15991 else:
15992 self.role = 0
15993 if reason != None:
15994 self.reason = reason
15995 else:
15996 self.reason = 0
15997 if table != None:
15998 self.table = table
15999 else:
16000 self.table = ofp.table_desc()
16001 return
16002
16003 def pack(self):
16004 packed = []
16005 packed.append(struct.pack("!B", self.version))
16006 packed.append(struct.pack("!B", self.type))
16007 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
16008 packed.append(struct.pack("!L", self.xid))
16009 packed.append(struct.pack("!L", self.role))
16010 packed.append(struct.pack("!B", self.reason))
16011 packed.append('\x00' * 7)
16012 packed.append(self.table.pack())
16013 length = sum([len(x) for x in packed])
16014 packed[2] = struct.pack("!H", length)
16015 return ''.join(packed)
16016
16017 @staticmethod
16018 def unpack(reader):
16019 obj = table_status()
16020 _version = reader.read("!B")[0]
16021 assert(_version == 5)
16022 _type = reader.read("!B")[0]
16023 assert(_type == 31)
16024 _length = reader.read("!H")[0]
16025 orig_reader = reader
16026 reader = orig_reader.slice(_length, 4)
16027 obj.xid = reader.read("!L")[0]
16028 obj.role = reader.read("!L")[0]
16029 obj.reason = reader.read("!B")[0]
16030 reader.skip(7)
16031 obj.table = ofp.table_desc.unpack(reader)
16032 return obj
16033
16034 def __eq__(self, other):
16035 if type(self) != type(other): return False
16036 if self.xid != other.xid: return False
16037 if self.role != other.role: return False
16038 if self.reason != other.reason: return False
16039 if self.table != other.table: return False
16040 return True
16041
16042 def pretty_print(self, q):
16043 q.text("table_status {")
16044 with q.group():
16045 with q.indent(2):
16046 q.breakable()
16047 q.text("xid = ");
16048 if self.xid != None:
16049 q.text("%#x" % self.xid)
16050 else:
16051 q.text('None')
16052 q.text(","); q.breakable()
16053 q.text("role = ");
16054 q.text("%#x" % self.role)
16055 q.text(","); q.breakable()
16056 q.text("reason = ");
16057 q.text("%#x" % self.reason)
16058 q.text(","); q.breakable()
16059 q.text("table = ");
16060 q.pp(self.table)
16061 q.breakable()
16062 q.text('}')
16063
16064message.subtypes[31] = table_status
16065
16066
16067def parse_header(buf):
16068 if len(buf) < 8:
16069 raise loxi.ProtocolError("too short to be an OpenFlow message")
16070 return struct.unpack_from("!BBHL", buf)
16071
16072def parse_message(buf):
16073 msg_ver, msg_type, msg_len, msg_xid = parse_header(buf)
16074 if msg_ver != ofp.OFP_VERSION and msg_type != ofp.OFPT_HELLO:
16075 raise loxi.ProtocolError("wrong OpenFlow version (expected %d, got %d)" % (ofp.OFP_VERSION, msg_ver))
16076 if len(buf) != msg_len:
16077 raise loxi.ProtocolError("incorrect message size")
16078 return message.unpack(loxi.generic_util.OFReader(buf))